# Example: override the preset from your own profile patch.
#
# The bundle inserts the row id preset-superpowers. A patch entry whose id
# matches that row REPLACES its whole config — Cordis never deep-merges — so an
# override has to restate the fields it wants to keep.
#
# This file is a complete, valid override that:
#   * renames the mode and moves it to the top of the roster (order: 2),
#   * replaces the description, and
#   * drops the present row,
# while keeping the persona bootstrap and every other row byte for byte.
#
# Install it by pasting its contents into:
#   /profiles/<your-profile>/cordis.patch.yml
# then restarting the profile.
#
# Regenerate after a DSH or preset change: copy the config.plugins list out of
# cordis.patch.yml and edit it. Keeping the two in step matters, because a stale
# override pins the mode to an old composition — including an old set of tools
# and, if it predates them, no local-skill provider at all.
- insert:
    - id: preset-superpowers
      name: '@deepseek-ai/dsh-agent-preset'
      config:
        id: superpowers
        name: Superpowers (custom)
        description: My own description of this mode.
        order: 2
        plugins:
          # ---- Superpowers additions ---------------------------------------------
          # The identity line matches the shipped `standard` preset; everything after
          # it is the bootstrap from skills/using-superpowers/SKILL.md.
          # `scripts/sync-bootstrap.mjs` regenerates this block and `scripts/verify.mjs`
          # fails if it drifts from the skill file.
          - id: persona
            name: '@deepseek-ai/dsh-persona'
            config:
              prefix: |-
                You are a coding agent powered by the {{model}} model.

                <IF-YOU-ARE-A-SUBAGENT>
                If you were dispatched as a subagent to execute a specific task: follow the
                skills that apply to the task you were given — an implementer uses
                test-driven-development, a reviewer uses the review template it was handed.
                Skip the conversation-level parts of this skill: do not re-open brainstorming,
                do not dispatch your own subagents, and do not ask the user clarifying
                questions unless your task explicitly says to. Report evidence, not conclusions.
                </IF-YOU-ARE-A-SUBAGENT>

                <EXTREMELY-IMPORTANT>
                If you think there is even a 1% chance a skill might apply to what you are doing, you ABSOLUTELY MUST invoke the skill.

                IF A SKILL APPLIES TO YOUR TASK, YOU DO NOT HAVE A CHOICE. YOU MUST USE IT.

                This is not negotiable. You cannot rationalize your way out of this.
                </EXTREMELY-IMPORTANT>

                ## The Rule

                **Invoke relevant or requested skills BEFORE any response or action** — including clarifying questions, exploring the codebase, or checking files. If it turns out wrong for the situation, you don't have to use it.

                **Before entering plan mode:** if you haven't already brainstormed, invoke the brainstorming skill first.

                Then announce "Using [skill] to [purpose]" and follow the skill exactly. If it has a checklist, create a todo per item.

                ## Skill Priority

                When multiple skills apply, process skills come first — they set the approach, then implementation skills (frontend-design, etc.) carry it out. Brainstorming and systematic-debugging are Superpowers' most common process skills, but the rule holds for any of them.

                - "Let's build X" → brainstorming first, then implementation skills.
                - "Fix this bug" → systematic-debugging first, then domain skills.

                ## Red Flags

                These thoughts mean STOP—you're rationalizing:

                | Thought | Reality |
                |---------|---------|
                | "This is just a simple question" | Questions are tasks. Check for skills. |
                | "I need more context first" | Skill check comes BEFORE clarifying questions. |
                | "Let me explore the codebase first" | Skills tell you HOW to explore. Check first. |
                | "I can check git/files quickly" | Files lack conversation context. Check for skills. |
                | "Let me gather information first" | Skills tell you HOW to gather information. |
                | "This doesn't need a formal skill" | If a skill exists, use it. |
                | "I remember this skill" | Skills evolve. Read current version. |
                | "This doesn't count as a task" | Action = task. Check for skills. |
                | "The skill is overkill" | Simple things become complex. Use it. |
                | "I'll just do this one thing first" | Check BEFORE doing anything. |
                | "This feels productive" | Undisciplined action wastes time. Skills prevent this. |
                | "I know what that means" | Knowing the concept ≠ using the skill. Invoke it. |

                ## Platform Adaptation

                This is the DeepSeek Harness (DSH) port, mounted by the `superpowers` agent
                preset. The platform reference is `references/dsh-tools.md`: the Claude Code →
                DSH tool mapping, the DSH capabilities these skills use (`skill`, `subagent` /
                `subagent_fork`, `workflow`, `goal`, `todo_write`), the bundled-script rules,
                and the Windows `pwsh` notes. Read it before acting on any instruction below
                that names a tool this harness does not have.

                These rules are active only in a task started with the `superpowers` preset.
                Do not assume they apply in Standard, PTC, Minimal, or Creator mode.

                ## User Instructions

                User instructions (`AGENTS.md` — user level at `$DSH_HOME/AGENTS.md`, project level at `<project>/AGENTS.md` — and direct requests) take precedence over skills, which in turn override default behavior. Only skip skill workflows or instructions when your human partner has explicitly told you to.
              suffix: Your working directory is {{cwd}}.
          - id: superpowers-skills
            name: 'superpowers-preset-dsh/skills'

          # ---- everything below mirrors the shipped `standard` preset --------------
          # Regenerate with: node scripts/sync-preset-from-dsh.mjs <dsh-root>
          # `scripts/verify.mjs` fails if any row Standard carries goes missing here,
          # which is how a dropped local-skill provider would be caught.
          - id: agent-instructions
            name: '@deepseek-ai/dsh-agent-instructions'
            config:
              maxBytes: 65536
          - id: time-context
            name: '@deepseek-ai/dsh-time-context'
          - id: tool-bash
            name: '@deepseek-ai/dsh-tool-bash'
            disabled: !!js process.platform === 'win32'
          - id: tool-pwsh
            name: '@deepseek-ai/dsh-tool-pwsh'
            disabled: !!js process.platform !== 'win32'
          - id: tool-fs
            name: '@deepseek-ai/dsh-tool-fs'
          - id: tool-fs-search
            name: '@deepseek-ai/dsh-tool-fs-search'
            config:
              sampleOverCapGlobResults: false
          - id: tool-jobs
            name: '@deepseek-ai/dsh-tool-jobs'
          - id: tool-schedule
            name: '@deepseek-ai/dsh-tool-schedule'
          - id: skill-filesystem
            name: '@deepseek-ai/dsh-skill-filesystem'
          - id: tool-skill
            name: '@deepseek-ai/dsh-tool-skill'
          - id: command-goal
            name: '@deepseek-ai/dsh-command-goal'
          - id: tool-goal
            name: '@deepseek-ai/dsh-tool-goal'
          - id: planning
            name: cordis:group
            group: true
            isolate:
              planMode: true
            config:
              - id: plan-mode
                name: '@deepseek-ai/dsh-plan-mode'
                config:
                  section: |
                    You are in plan mode. Stay in plan mode until exit_plan_mode succeeds or the user switches the session mode. Imperative language to implement changes means plan the implementation, not execute it. A user's conversational agreement — including an answer confirming something you asked — approves nothing and does not end plan mode; fold the confirmed decision into the plan and submit it through exit_plan_mode.

                    Explore first. Use non-mutating reads, searches, static analysis, and checks to ground the plan in the actual repository. Do not edit or write files, change configuration, run formatters or code generation that rewrites tracked files, commit, or otherwise carry out the plan. Prefer existing functions and patterns over new machinery.

                    The tool catalog stays the same across modes for request-cache stability. These plan-mode rules override any later tool description or guidance that suggests using mutation tools; those tools remain listed to keep the tool catalog unchanged. Do not use todo_write to track this planning phase: it tracks implementation after an approved plan, while the plan itself belongs in exit_plan_mode.

                    Resolve discoverable facts by inspection. Use ask_user_question only for user-owned choices or material ambiguity that inspection cannot answer. Do not ask the user where code lives or how current behavior works when you can find out.

                    Make the plan decision-complete: state the goal and success criteria; group implementation changes by subsystem; identify public API, schema, and data-flow changes; cover edge cases, failure modes, tests, acceptance criteria, and explicit assumptions. Keep it concise enough to review but detailed enough that another engineer can implement it without making design decisions.

                    When ready, call exit_plan_mode with the complete plan markdown, starting with a # title. Make exit_plan_mode the only and final tool call in that assistant response: it presents the plan for approval, and implementation begins only in a later step after approval. Do not paste the final plan as a plain reply or ask "should I proceed?" through prose or ask_user_question. If review rejects it, incorporate the feedback and present again. If the review channel is unavailable or aborted, stay in plan mode and ask the user to switch modes manually; do not proceed with implementation.
          - id: compaction
            name: cordis:group
            group: true
            isolate:
              compaction: true
              toolResultPruner: true
            config:
              - id: compaction-basic
                name: '@deepseek-ai/dsh-compaction-basic'
              - id: command-compact
                name: '@deepseek-ai/dsh-command-compact'
              - id: tool-result-pruner
                name: '@deepseek-ai/dsh-compaction-tool-result-pruner'
                config:
                  thresholdChars: 8192
                  headChars: 4096
                  tailChars: 1024
          - id: delegation
            name: cordis:group
            group: true
            isolate:
              workflowEngine: true
            config:
              - id: tool-subagent-control
                name: '@deepseek-ai/dsh-tool-subagent-control'
              - id: tool-subagent-list-agents
                name: '@deepseek-ai/dsh-tool-subagent-control/list-agents'
              - id: tool-subagent
                name: '@deepseek-ai/dsh-tool-subagent'
                config:
                  provider: spawn
                  toolName: subagent
                  modelSelectionSettings: true
                  backgroundMode: continuable
                  toolFilter:
                    deny:
                      - schedule_create
                      - schedule_delete
                      - schedule_list
                      - schedule_update
              - id: tool-subagent-fork
                name: '@deepseek-ai/dsh-tool-subagent'
                config:
                  provider: fork
                  toolName: subagent_fork
                  backgroundMode: continuable
                  toolFilter:
                    deny:
                      - schedule_create
                      - schedule_delete
                      - schedule_list
                      - schedule_update
              - id: tool-subagent-codex
                name: '@deepseek-ai/dsh-tool-subagent'
                disabled: true
                config:
                  provider: codex
                  toolName: subagent_codex
                  backgroundMode: one-shot
                  maxDepth: provider-managed
              - id: tool-subagent-claude-code
                name: '@deepseek-ai/dsh-tool-subagent'
                disabled: true
                config:
                  provider: claude-code
                  toolName: subagent_claude_code
                  backgroundMode: one-shot
                  maxDepth: provider-managed
              - id: workflow-ptc
                name: '@deepseek-ai/dsh-workflow-ptc'
                config:
                  provider: spawn
              - id: tool-workflow
                name: '@deepseek-ai/dsh-tool-workflow'
              - id: tool-ralph
                name: '@deepseek-ai/dsh-tool-ralph'
                disabled: true
                config:
                  subagentProvider: spawn
                  maxRounds: 64
          - id: tool-ask-user
            name: '@deepseek-ai/dsh-tool-ask-user'
          - id: tool-todo
            name: '@deepseek-ai/dsh-tool-todo'
            config:
              allowParallelInProgress: true
          - id: tool-web
            name: '@deepseek-ai/dsh-tool-web'
            config:
              fetch: true
              searchTimeoutMs: 60000
          - id: tool-plugin-manager
            name: '@deepseek-ai/dsh-plugin-manager/tools'
            disabled: true