@plainconceptsplatform/agent-harness 2.0.0

package/src/presets/agents-content.json

@@ -0,0 +1,53 @@
+{
+  "platform": {
+    "none": {
+      "devopsSkills": "- Selected platform: `none` (from onboarding platform step).\n- Do NOT load `pc-userstory` or `pc-ops-ship`.\n- Work only from direct user instructions in the main conversation or from local OpenSpec artifacts.\n- Ignore GitHub/Azure DevOps URL inference unless the user explicitly reconfigures onboarding later.",
+      "devopsMode": "This project does not use GitHub or Azure DevOps integration. Do not read work items, create PRs, or process PR feedback. Operate only from direct user instructions and local repository context.",
+      "workflow": "When the user gives a task directly in the conversation, **I own the full lifecycle**. I work from the user request and local repository context. I may use OpenSpec when structured planning helps, but I do not depend on issue links or PR workflows.\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- User describes a feature, bug, or refactor directly → clarify if needed → optionally load the `pc-plan-propose` skill → implement in the main session or `pc-plan-apply` as appropriate\n- `implement the plan` / `implement` / `start` / `go` → load the `pc-plan-apply` skill against the current OpenSpec change when one exists\n- `just do it` / `quick fix` / `raw conversation` → work directly in the main session without PR or work-item automation\n\n**GitHub Issue URLs, Azure DevOps work item URLs, and PR URLs are NOT automatic triggers in this mode.** Only use platform-specific flows if onboarding is later reconfigured for GitHub or Azure DevOps.",
+      "pipeline": "```\nlead (main session)\n  → pc-plan-propose (propose + enrich tasks)\n        ↓\n  [confirm when scope needs it]\n        ↓\n*-engineer specialists (parallel via pc-plan-apply)\n  → implement assigned tasks (parallel waves)\n        ↓\nlead verifies and reports to user\n```\n\n### Phase 1, Clarify & Plan\n\n```\n1. Understand the task from the conversation and local repo context.\n2. If the work benefits from explicit specs/tasks, load the pc-plan-propose skill.\n   Enrich tasks.md: assign each task its best matching engineer (the engineer's tier sets the model) plus depends_on and touches.\n3. Show the plan or intended scope when non-trivial.\n4. If the request is small, implement directly in the main session.\n```\n\n### Phase 2, Implement\n\n```\n0. Run /quota before spawning, when available.\n1. If using OpenSpec tasks, load the pc-plan-apply skill.\n   - Classify cost tier, confirm if ≥4 tasks.\n   - Lead discovers engineers, builds dependency- and file-disjoint waves, and spawns each wave as parallel subagents.\n   - Each subagent implements its assigned tasks and returns; the lead commits each group and marks tasks done.\n2. If task is small, implement directly in the main session.\n3. Verify with tests/build/lint.\n```\n\nThere is no PR shipping phase in `none` mode. Report completion directly to the user.",
+      "skillsGuide": "No platform skills installed (platform: none). Work from direct user instructions and local OpenSpec artifacts only."
+    },
+    "azure": {
+      "devopsSkills": "- Selected platform: `azure` (from onboarding platform step).\n- Load Azure DevOps skills: `pc-userstory`, `pc-ops-ship`.\n- Use URL-based platform inference only if onboarding metadata is missing or ambiguous.",
+      "devopsMode": "This project uses platform-integrated workflow modes described below.",
+      "workflow": "When the user provides a work item URL or says \"implement the plan\" or \"I've added comments to the PR\", **I own the full lifecycle**. I load the appropriate userstory skill and coordinate implementation as native subagent waves via the `pc-plan-apply` skill.\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- User pastes or mentions an Azure DevOps URL → load `pc-userstory` skill → parse work item → load the `pc-plan-propose` skill → confirm with user → load the `pc-plan-apply` skill → ship\n- `implement the plan` / `implement` / `start` / `go` → load the `pc-plan-apply` skill → ship\n- `I've added comments to the PR` → read PR comments → fix → update PR\n- Any Azure DevOps PR URL in a feedback/fix request (e.g. \"check comments\", \"fix PR feedback\") → run PR Feedback Loop\n\n**An Azure DevOps URL in the user's message is a strong trigger: follow the pipeline unless the user explicitly asks for analysis or context only.**",
+      "pipeline": "```\nlead (main session)\n  → pc-plan-propose (parse work item + propose + enrich tasks)\n        ↓\n  [confirm with user]\n        ↓\n*-engineer specialists (parallel via pc-plan-apply)\n  → implement assigned tasks (parallel waves)\n        ↓\nlead loads the pc-ops-ship skill → commit + push + create PR\n```\n\n### Phase 1, Parse & Propose\n\n```\n1. If a work item URL is provided, load @pc-userstory skill.\n2. Load the pc-plan-propose skill → fetches work item, generates proposal.md, specs/, tasks.md, enriches tasks with agent + dependencies.\n3. Show the plan: change name, total tasks, task list with agent assignments.\n4. STOP. Ask user: \"Ready to implement? (yes/no)\", DO NOT proceed until confirmed.\n```\n\n### Phase 2, Implement\n\n```\n0. Run /quota to check remaining budget before spawning.\n1. Load the pc-plan-apply skill.\n   - Classify cost tier, announce scope, ask user to confirm if ≥4 tasks.\n   - Lead discovers available engineers from .opencode/agents/*.md, prefers matching custom engineers.\n   - Lead builds dependency- and file-disjoint waves, then spawns each wave as parallel subagents (by agent name; each engineer carries its own model).\n   - Each subagent implements its assigned tasks and returns; the lead commits each group and marks tasks done in tasks.md.\n2. Verify with tests/build/lint according to task scope.\n3. Run /quota after all waves complete.\n```\n\n### Phase 3, Ship\n\n```\n1. Load the pc-ops-ship skill to create the PR.\n2. Done: report PR URL to user.\n```\n\n### Handling PR Feedback\n\n```\nWhen user says \"I've added comments to the PR\" or shares a PR URL:\n1. Triage feedback: read and classify the PR comments via the repo platform CLI (the /ops-review flow).\n2. Fix items by loading the pc-plan-apply skill for the required tasks.\n3. Load the pc-ops-ship skill again to push updates and reply to PR threads.\n```",
+      "skillsGuide": "Platform skills (Azure DevOps):\n- `@pc-userstory`: load when an Azure DevOps work item URL is detected. Fetches the work item via `az` CLI and creates an OpenSpec change. NEVER use browser tools for Azure DevOps operations.\n- `pc-ops-ship`: load in ship mode to create a PR and link the work item, or in feedback mode to read and classify PR review comments."
+    },
+    "github": {
+      "devopsSkills": "- Selected platform: `github` (from onboarding platform step).\n- Load GitHub skills: `pc-userstory`, `pc-ops-ship`.\n- Use URL-based platform inference only if onboarding metadata is missing or ambiguous.",
+      "devopsMode": "This project uses platform-integrated workflow modes described below.",
+      "workflow": "When the user provides a work item URL or says \"implement the plan\" or \"I've added comments to the PR\", **I own the full lifecycle**. I load the appropriate userstory skill and coordinate implementation as native subagent waves via the `pc-plan-apply` skill.\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- User pastes or mentions a GitHub Issue URL → load `pc-userstory` skill → parse issue → load the `pc-plan-propose` skill → confirm with user → load the `pc-plan-apply` skill → ship\n- `implement the plan` / `implement` / `start` / `go` → load the `pc-plan-apply` skill → ship\n- `I've added comments to the PR` → read PR comments → fix → update PR\n- Any GitHub PR URL in a feedback/fix request (e.g. \"check comments\", \"fix PR feedback\") → run PR Feedback Loop\n\n**A GitHub URL in the user's message is a strong trigger: follow the pipeline unless the user explicitly asks for analysis or context only.**",
+      "pipeline": "```\nlead (main session)\n  → pc-plan-propose (parse work item + propose + enrich tasks)\n        ↓\n  [confirm with user]\n        ↓\n*-engineer specialists (parallel via pc-plan-apply)\n  → implement assigned tasks (parallel waves)\n        ↓\nlead loads the pc-ops-ship skill → commit + push + create PR\n```\n\n### Phase 1, Parse & Propose\n\n```\n1. If a work item URL is provided, load @pc-userstory skill.\n2. Load the pc-plan-propose skill → fetches work item, generates proposal.md, specs/, tasks.md, enriches tasks with agent + dependencies.\n3. Show the plan: change name, total tasks, task list with agent assignments.\n4. STOP. Ask user: \"Ready to implement? (yes/no)\", DO NOT proceed until confirmed.\n```\n\n### Phase 2, Implement\n\n```\n0. Run /quota to check remaining budget before spawning.\n1. Load the pc-plan-apply skill.\n   - Classify cost tier, announce scope, ask user to confirm if ≥4 tasks.\n   - Lead discovers available engineers from .opencode/agents/*.md, prefers matching custom engineers.\n   - Lead builds dependency- and file-disjoint waves, then spawns each wave as parallel subagents (by agent name; each engineer carries its own model).\n   - Each subagent implements its assigned tasks and returns; the lead commits each group and marks tasks done in tasks.md.\n2. Verify with tests/build/lint according to task scope.\n3. Run /quota after all waves complete.\n```\n\n### Phase 3, Ship\n\n```\n1. Load the pc-ops-ship skill to create the PR.\n2. Done: report PR URL to user.\n```\n\n### Handling PR Feedback\n\n```\nWhen user says \"I've added comments to the PR\" or shares a PR URL:\n1. Triage feedback: read and classify the PR comments via the repo platform CLI (the /ops-review flow).\n2. Fix items by loading the pc-plan-apply skill for the required tasks.\n3. Load the pc-ops-ship skill again to push updates and reply to PR threads.\n```",
+      "skillsGuide": "Platform skills (GitHub):\n- `@pc-userstory`: load when a GitHub Issue URL is detected. Fetches the issue via `gh` CLI and creates an OpenSpec change. NEVER use webfetch to access GitHub URLs.\n- `pc-ops-ship`: load in ship mode to create a PR with screenshots, or in feedback mode to read and classify PR review comments."
+    },
+    "mixed": {
+      "default": {
+        "workflow": "This project uses a mixed-platform setup: the backlog (work items) and the repo (PRs) live on different platforms. Check `.opencode/harness.json` → `platform.backlog` and `platform.repo`.\n\nWhen the user provides a work item URL or says \"implement the plan\" or \"I've added comments to the PR\", **I own the full lifecycle**: parse the work item with `@pc-userstory` (backlog platform CLI), plan via the `pc-plan-propose` skill, confirm with the user, implement via the `pc-plan-apply` skill, ship via the `pc-ops-ship` skill (repo platform CLI).\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- A backlog work-item URL or issue key → load `pc-userstory` → parse → load the `pc-plan-propose` skill → confirm with user → load the `pc-plan-apply` skill → ship\n- `implement the plan` / `implement` / `start` / `go` → load the `pc-plan-apply` skill → ship\n- A PR/MR URL or \"I've added comments to the PR\" → read the PR comments via the repo platform CLI → run the PR Feedback Loop\n\nNever mix the CLIs: work items always go through the backlog platform CLI, PRs/MRs always through the repo platform CLI.",
+        "pipeline": "{repo}",
+        "skillsGuide": "Mixed platform setup: the two platform skills target different hosts:\n- `@pc-userstory` → fetches work items from the backlog platform. Load when a work-item URL or issue key is provided.\n- `pc-ops-ship` → creates PRs/MRs and triages review feedback on the repo platform. Load in ship mode or PR-feedback mode."
+      }
+    },
+    "jira": {
+      "devopsSkills": "- Selected backlog platform: `jira` (from onboarding platform step).\n- Jira is a BACKLOG-ONLY platform. Work items are fetched via `acli jira` CLI.\n- PRs and code review use the repo platform (GitHub or Azure DevOps) configured separately.\n- Load `pc-userstory` skill when a Jira URL is provided.\n- Load `pc-ops-ship` skill from the repo platform for PR operations.",
+      "devopsMode": "This project uses Jira for backlog/work items and a separate repo platform (GitHub or Azure DevOps) for code. Fetch work items via `acli jira` CLI. Create PRs via the repo platform CLI. Do NOT use browser tools for Jira operations.",
+      "workflow": "When the user provides a Jira URL or mentions a Jira issue key, **I own the full lifecycle**. I load `pc-userstory` skill to parse the Jira issue via `acli jira workitem view`, then load the `pc-plan-propose` skill to create the plan.\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- User pastes or mentions a Jira URL (atlassian.net/browse/PROJ-123) -> load `pc-userstory` skill -> fetch via `acli jira` -> load the `pc-plan-propose` skill -> confirm -> load the `pc-plan-apply` skill -> ship\n- User mentions a Jira issue key (e.g. \"PROJ-123\") -> same flow\n- `implement the plan` / `implement` / `start` / `go` -> load the `pc-plan-apply` skill -> ship\n- PR feedback -> use the repo platform CLI (gh or az) for PR operations\n\n**A Jira URL or issue key in the user's message is a strong trigger: follow the pipeline unless the user explicitly asks for analysis or context only.**\n\nFor PR creation and code review, use the repo platform (configured as `platform.repo`). Jira has no PR capability.",
+      "pipeline": "```\nlead (main session)\n  -> fetch Jira work item (acli jira workitem view)\n  -> pc-plan-propose (propose + enrich tasks)\n        |\n  [confirm when scope needs it]\n        |\n*-engineer specialists (parallel via pc-plan-apply)\n  -> implement assigned tasks (parallel waves)\n        |\nlead verifies, creates PR via repo platform (gh or az)\n  -> transition Jira work item to Done (acli jira workitem transition)\n```\n\n### Phase 1, Fetch & Plan\n\n```\n1. Fetch the Jira work item via acli jira workitem view --key KEY.\n2. Load the pc-plan-propose skill to create the OpenSpec change from the work item.\n3. Confirm with the user.\n```\n\n### Phase 2, Implement & Ship\n\n```\n1. Load the pc-plan-apply skill to implement via parallel subagent waves.\n2. Create PR via repo platform CLI (gh pr create or az repos pr create).\n3. Transition Jira work item: acli jira workitem transition --key KEY --status \"Done\"\n```",
+      "skillsGuide": "### Backlog Platform: Jira\n- `pc-userstory` -> fetches Jira work items via `acli jira` CLI. Load when a Jira URL or issue key is provided.\n\n### Repo Platform\n- PR skills are loaded based on `platform.repo` (GitHub or Azure DevOps)."
+    },
+    "gitlab": {
+      "devopsSkills": "- Selected repo platform: `gitlab` (from onboarding platform step).\n- GitLab is a REPO-ONLY platform. MRs and code review via `glab` CLI.\n- Backlog/work items use the backlog platform (GitHub / Azure / Jira) configured separately.\n- Load `pc-ops-ship` skill for GitLab MR operations.",
+      "devopsMode": "This project uses GitLab for code repository and merge requests, with a separate backlog platform for work items. Create MRs via `glab mr create` CLI. Fetch work items via the backlog platform CLI. Do NOT use browser tools for GitLab operations.",
+      "workflow": "When the user provides a GitLab MR URL or says \"implement the plan\", **I own the full lifecycle**. I load the appropriate userstory skill (from backlog platform) and `pc-ops-ship` skill (for GitLab MRs).\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- User pastes or mentions a backlog work item URL -> load `pc-userstory` skill -> fetch via backlog CLI -> load the `pc-plan-propose` skill -> confirm -> load the `pc-plan-apply` skill -> ship\n- `implement the plan` / `implement` / `start` / `go` -> load the `pc-plan-apply` skill -> ship\n- User says \"I've added comments to the MR\" -> read MR comments via `glab mr note list` -> triage feedback\n- Any GitLab MR URL in a feedback/fix request -> run MR Feedback Loop via `glab` CLI\n\n**A GitLab MR URL in the user's message is a strong trigger: follow the pipeline unless the user explicitly asks for analysis or context only.**\n\nFor work item fetching, use the backlog platform (configured as `platform.backlog`). GitLab has no backlog integration.",
+      "pipeline": "```\nlead (main session)\n  -> fetch work item (backlog platform CLI: gh / az / acli)\n  -> pc-plan-propose (propose + enrich tasks)\n        |\n  [confirm when scope needs it]\n        |\n*-engineer specialists (parallel via pc-plan-apply)\n  -> implement assigned tasks (parallel waves)\n        |\nlead verifies, creates MR via GitLab (glab mr create)\n```\n\n### Phase 1, Fetch & Plan\n\n```\n1. Fetch the work item via backlog platform CLI.\n2. Load the pc-plan-propose skill to create the OpenSpec change.\n3. Confirm with the user.\n```\n\n### Phase 2, Implement & Ship\n\n```\n1. Load the pc-plan-apply skill to implement via parallel subagent waves.\n2. Create MR via glab mr create.\n3. Archive change after MR is merged.\n```",
+      "skillsGuide": "### Repo Platform: GitLab\n- `pc-ops-ship` -> creates GitLab merge requests via `glab` CLI. Load when shipping a branch or processing MR feedback.\n\n### Backlog Platform\n- Work item skills are loaded based on `platform.backlog` (GitHub / Azure / Jira)."
+    },
+    "browser": {
+      "devopsSkills": "- Selected backlog platform: `browser` (from onboarding platform step).\n- No CLI integration for the backlog system. Work items are fetched via opencode-browser plugin.\n- The `pc-userstory` skill navigates to work item URLs the user provides and reads page content.\n- PRs and code review use the repo platform (GitHub / Azure DevOps / GitLab) configured separately.",
+      "devopsMode": "This project uses browser automation for backlog/work items (no CLI) and a separate repo platform for code. Work items are read from web pages using the opencode-browser plugin. Create PRs via the repo platform CLI. The browser navigation exception ONLY applies to work item URLs the user explicitly provides.",
+      "workflow": "When the user provides a work item URL from any backlog tool (Azure DevOps, Linear, Trello, etc.), **I own the full lifecycle**. I load `pc-userstory` skill to navigate to the URL via browser and read the page content.\n\nTrigger patterns, I recognize ALL of these, exact wording does not matter:\n- User pastes any URL to a work item/ticket/issue -> load `pc-userstory` skill -> navigate via browser -> read page text + snapshot -> parse work item -> load the `pc-plan-propose` skill -> confirm -> load the `pc-plan-apply` skill -> ship\n- `implement the plan` / `implement` / `start` / `go` -> load the `pc-plan-apply` skill -> ship\n- PR feedback -> use the repo platform CLI (gh, az, or glab) for PR operations\n\n**Any work item URL in the user's message is a trigger, regardless of the backlog tool it points to.**\n\nFor PR creation and code review, use the repo platform (configured as `platform.repo`). Browser is backlog-only: it has no PR capability.",
+      "pipeline": "```\nlead (main session)\n  -> open work item URL in browser (browser_open_tab)\n  -> read page content (browser_query mode=page_text + browser_snapshot)\n  -> parse work item fields from page text\n  -> pc-plan-propose (propose + enrich tasks)\n        |\n  [confirm when scope needs it]\n        |\n*-engineer specialists (parallel via pc-plan-apply)\n  -> implement assigned tasks (parallel waves)\n        |\nlead verifies, creates PR via repo platform (gh / az / glab)\n```\n\n### Phase 1, Fetch & Plan\n\n```\n1. User provides a work item URL.\n2. Navigate to the URL via browser_open_tab.\n3. Read page text via browser_query mode=page_text.\n4. Take accessibility snapshot via browser_snapshot.\n5. Parse title, description, acceptance criteria from the page.\n6. Load the pc-plan-propose skill to create the OpenSpec change.\n7. Confirm with the user.\n```\n\n### Phase 2, Implement & Ship\n\n```\n1. Load the pc-plan-apply skill to implement via parallel subagent waves.\n2. Create PR via repo platform CLI (gh pr create, az repos pr create, or glab mr create).\n3. Archive change after PR is merged.\n```",
+      "skillsGuide": "### Backlog Platform: Others (Browser)\n- `pc-userstory` -> navigates to work item URLs via browser plugin, reads page content, creates OpenSpec changes. Load when a URL the user provides does not match GitHub/Azure/Jira CLI platforms.\n\n### Repo Platform\n- PR skills are loaded based on `platform.repo` (GitHub / Azure DevOps / GitLab)."
+    }
+  }
+}

package/src/presets/browser.json

@@ -0,0 +1,22 @@
+{
+  "installer": {
+    "command": "npx",
+    "args": ["@different-ai/opencode-browser@4.6.1", "install"]
+  },
+  "output": {
+    "showAfter": "To load the extension",
+    "hideAfter": "Press Enter when"
+  },
+  "locationChoices": {
+    "local": "2",
+    "global": "1"
+  },
+  "autoAnswers": [
+    { "trigger": "Press Enter when", "response": "" },
+    { "trigger": "Choose config location", "response": "__LOCATION__" },
+    { "trigger": "Add plugin automatically?", "response": "y" },
+    { "trigger": "Create one?", "response": "y" },
+    { "trigger": "Add browser-automation skill", "response": "n" },
+    { "trigger": "Check broker", "response": "n" }
+  ]
+}

package/src/presets/clean.json

@@ -0,0 +1,21 @@
+{
+  "preserve": ["DESIGN.md", "ARCHITECTURE.md", "openspec"],
+  "detectFiles": [
+    "AGENTS.md",
+    "CLAUDE.md",
+    "ARCHITECTURE.md",
+    "DESIGN.md",
+    ".cursorrules",
+    ".clinerules",
+    ".windsurfrules",
+    ".github/copilot-instructions.md",
+    "copilot-instructions.md",
+    ".aider.conf.yml",
+    ".aider",
+    ".opencode",
+    ".agents"
+  ],
+  "directoryTargets": [".opencode", ".agents"],
+  "preserveSubfolders": ["skills"],
+  "selectionMessage": "Select AI config files to remove:"
+}

package/src/presets/models.json

@@ -0,0 +1,68 @@
+{
+  "costTiers": [
+    { "max": 1, "label": "[$]" },
+    { "max": 10, "label": "[$$]" },
+    { "label": "[$$$]" }
+  ],
+  "providers": [
+    { "value": "opencode", "name": "OpenCode Zen" },
+    { "value": "opencode-go", "name": "OpenCode Go" },
+    { "value": "github-copilot", "name": "GitHub Copilot" },
+    { "value": "anthropic", "name": "Anthropic" },
+    { "value": "google",   "name": "Google" },
+    { "value": "openai",   "name": "OpenAI" },
+    { "value": "deepseek", "name": "DeepSeek" },
+    { "value": "",         "name": "Other (show all)" }
+  ],
+  "roles": {
+    "plan": {
+      "prompt": "Plan model:",
+      "info": [
+        "PLAN: main session: reads issues, writes proposals, coordinates the agent team.",
+        "Needs to be strong. A weak model here will silently skip steps and break the workflow."
+      ],
+      "suggestions": {
+        "opencode":        "opencode/claude-sonnet-4",
+        "opencode-go":     null,
+        "github-copilot":  "github-copilot/claude-sonnet-4.5",
+        "anthropic":       "anthropic/claude-sonnet-4-5",
+        "google":          "google/gemini-2.5-pro",
+        "openai":          "openai/o3",
+        "deepseek":        null
+      }
+    },
+    "build": {
+      "prompt": "Build model:",
+      "info": [
+        "BUILD: engineers: implements code, runs tests, commits.",
+        "Code quality matters here. DeepSeek V4 is outstanding value. Claude Sonnet is the gold standard."
+      ],
+      "suggestions": {
+        "opencode":        "opencode/deepseek-v4-flash",
+        "opencode-go":     "opencode-go/deepseek-v4-pro",
+        "github-copilot":  "github-copilot/claude-sonnet-4.5",
+        "anthropic":       "anthropic/claude-sonnet-4-5",
+        "google":          "google/gemini-2.5-flash",
+        "openai":          "openai/gpt-4.1",
+        "deepseek":        "deepseek/deepseek-v4-pro"
+      },
+      "agents": ["fullstack-engineer"]
+    },
+    "fast": {
+      "prompt": "Fast model:",
+      "info": [
+        "FAST: light commands: /pc-pullrequest, /pc-explore, /pc-archive, status checks.",
+        "No heavy reasoning needed. Cheap and fast is the right call here."
+      ],
+      "suggestions": {
+        "opencode":        "opencode/glm-4.7",
+        "opencode-go":     "opencode-go/qwen3.6-plus",
+        "github-copilot":  "github-copilot/gpt-5.4-nano",
+        "anthropic":       "anthropic/claude-haiku-4-5",
+        "google":          "google/gemini-2.0-flash",
+        "openai":          "openai/gpt-4o-mini",
+        "deepseek":        null
+      }
+    }
+  }
+}

package/src/presets/openspec.json

@@ -0,0 +1 @@
+{}

package/src/presets/optimization.json

@@ -0,0 +1,37 @@
+{
+  "message": "Enable tools:",
+  "info": "Choose which optimization tools to enable (recommended: all).",
+  "timeoutMs": 30000,
+  "choices": [
+    {
+      "name": "RTK check (recommended)",
+      "value": "rtk",
+      "checked": true
+    },
+    {
+      "name": "opencode-quota plugin (recommended)",
+      "value": "quota",
+      "checked": true
+    },
+    {
+      "name": "Simple English concise mode (recommended)",
+      "value": "simpleEnglish",
+      "checked": true
+    },
+    {
+      "name": "codegraph semantic index (recommended)",
+      "value": "codegraph",
+      "checked": true
+    },
+    {
+      "name": "agentmemory local memory server",
+      "value": "memory",
+      "checked": true
+    },
+    {
+      "name": "humanizer skill (removes AI writing patterns)",
+      "value": "humanizer",
+      "checked": true
+    }
+  ]
+}

package/src/presets/platforms.json

@@ -0,0 +1,76 @@
+[
+  {
+    "value": "github",
+    "name": "GitHub",
+    "cli": {
+      "command": "gh",
+      "displayName": "GitHub CLI (gh)",
+      "installUrl": "https://cli.github.com",
+      "authCheck": {
+        "args": ["auth", "status"],
+        "notAuthenticatedMessage": "GitHub CLI not authenticated. Run:",
+        "commands": ["gh auth login"]
+      }
+    }
+  },
+  {
+    "value": "azure",
+    "name": "Azure DevOps",
+    "cli": {
+      "command": "az",
+      "displayName": "Azure CLI (az)",
+      "installUrl": "https://learn.microsoft.com/en-us/cli/azure/install-azure-cli",
+      "extensionCheck": {
+        "args": ["extension", "list", "--query", "[?name=='azure-devops']", "-o", "tsv"],
+        "expectedOutput": "azure-devops",
+        "missingMessage": "azure-devops extension not found. Run:",
+        "errorMessage": "Could not check azure-devops extension. Run:",
+        "commands": [
+          "az extension add --name azure-devops",
+          "az config set extension.dynamic_install_allow_preview=true",
+          "az login",
+          "az devops login --organization https://dev.azure.com/<your-org>"
+        ]
+      }
+    }
+  },
+  {
+    "value": "jira",
+    "name": "Jira (Atlassian)",
+    "backlogOnly": true,
+    "cli": {
+      "command": "acli",
+      "displayName": "Atlassian CLI (acli)",
+      "installUrl": "https://developer.atlassian.com/cloud/acli/guides/install-acli/",
+      "authCheck": {
+        "args": ["jira", "auth", "status"],
+        "notAuthenticatedMessage": "Atlassian CLI not authenticated. Run:",
+        "commands": ["acli jira auth login --site <yoursite>.atlassian.net --email <email> --token"]
+      }
+    }
+  },
+  {
+    "value": "gitlab",
+    "name": "GitLab",
+    "repoOnly": true,
+    "cli": {
+      "command": "glab",
+      "displayName": "GitLab CLI (glab)",
+      "installUrl": "https://gitlab.com/gitlab-org/cli/#installation",
+      "authCheck": {
+        "args": ["auth", "status"],
+        "notAuthenticatedMessage": "GitLab CLI not authenticated. Run:",
+        "commands": ["glab auth login"]
+      }
+    }
+  },
+  {
+    "value": "browser",
+    "name": "Others (Browser)",
+    "backlogOnly": true
+  },
+  {
+    "value": "none",
+    "name": "None"
+  }
+]

package/src/presets/quota.json

@@ -0,0 +1,16 @@
+{
+  "plugin": "@slkiser/opencode-quota@4.2.0",
+  "prompt": {
+    "message": "Install opencode-quota with recommended defaults?",
+    "default": true,
+    "timeoutMs": 20000
+  },
+  "defaults": {
+    "enabledProviders": "auto",
+    "formatStyle": "singleWindow",
+    "percentDisplayMode": "used",
+    "showSessionTokens": true,
+    "enableToast": false,
+    "tuiCommandDisplay": "inline"
+  }
+}

package/src/presets/source.json

@@ -0,0 +1,23 @@
+{
+  "message": "Source code location:",
+  "default": "current",
+  "choices": [
+    {
+      "name": "Current folder (default)",
+      "value": "current",
+      "description": "Use this repository only"
+    },
+    {
+      "name": "Select folders in parent (../)",
+      "value": "parent",
+      "description": "Use when this repo only contains agent config"
+    },
+    {
+      "name": "Select child folders (./*/)",
+      "value": "children",
+      "description": "Use when source code lives in subdirectories of this repo"
+    }
+  ],
+  "parentSelectionMessage": "Select source folders from parent directory:",
+  "childrenSelectionMessage": "Select child folders to include as source:"
+}

package/src/steps/browser/index.js

@@ -0,0 +1,91 @@
+import { execa } from 'execa'
+import fse from 'fs-extra'
+import { code, header, info, success, warn, error } from '../../utils/exec.js'
+import os from 'os'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const BROWSER_PRESET_PATH = path.resolve(__dirname, '../../presets/browser.json')
+const browserPreset = await fse.readJson(BROWSER_PRESET_PATH)
+
+export async function installBrowser(ctx = {}) {
+  header('Step 9, Installing opencode-browser')
+
+  const installScope = ctx.installScope || 'local'
+  const locationAnswer = browserPreset.locationChoices?.[installScope] ?? browserPreset.locationChoices?.local ?? '2'
+
+  const pendingTriggers = browserPreset.autoAnswers.map(a => ({
+    ...a,
+    response: a.response === '__LOCATION__' ? locationAnswer : a.response,
+  }))
+
+  let extensionPathShown = false
+
+  try {
+    const child = execa(browserPreset.installer.command, browserPreset.installer.args, {
+      cwd: os.homedir(),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      reject: false,
+    })
+
+    let show = false
+    const triggers = [...pendingTriggers]
+
+    child.stdout.on('data', (chunk) => {
+      const text = chunk.toString()
+
+      if (text.includes(browserPreset.output.showAfter)) show = true
+      if (text.includes(browserPreset.output.hideAfter)) show = false
+
+      if (show) process.stdout.write(chunk)
+
+      // Detect the extension path from the installer output to show it clearly
+      if (!extensionPathShown) {
+        const pathMatch = text.match(/(C:\\[^\s]+(?:extension|opencode-browser[^\s]*))/i) ||
+                          text.match(/((?:\/|~)[^\s]*(?:extension|opencode-browser[^\s]*))/i)
+        if (pathMatch) {
+          extensionPathShown = true
+        }
+      }
+
+      for (let i = 0; i < triggers.length; i++) {
+        if (text.includes(triggers[i].trigger)) {
+          // When the installer asks to press Enter after loading the extension,
+          // show the manual steps clearly before auto-answering
+          if (triggers[i].trigger === browserPreset.output.hideAfter) {
+            info('')
+            warn('Manual step required: load the browser extension before pressing Enter')
+            code([
+              '1. Open chrome://extensions',
+              '2. Enable Developer mode (top-right toggle)',
+              '3. Click "Load unpacked"',
+              '4. Select the extension folder shown above',
+              '5. Pin the extension: open the Extensions menu (puzzle icon) and click the pin',
+            ])
+            info('Auto-confirming in 5 seconds...')
+          }
+
+          child.stdin.write(`${triggers[i].response}\n`)
+          triggers.splice(i, 1)
+          break
+        }
+      }
+    })
+
+    child.stderr.on('data', (chunk) => process.stderr.write(chunk))
+
+    const result = await child
+
+    if (result.exitCode === 0) {
+      success('opencode-browser installed')
+      if (extensionPathShown) {
+        info('If you skipped loading the extension, run: npx @different-ai/opencode-browser@4.6.1 install')
+      }
+    } else {
+      warn('opencode-browser install exited with non-zero code')
+    }
+  } catch (err) {
+    error(`Failed to install opencode-browser: ${err.message}`)
+  }
+}

package/src/steps/clean/index.js

@@ -0,0 +1,120 @@
+import { checkbox } from '@inquirer/prompts'
+import fse from 'fs-extra'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { findAiFiles } from '../../utils/copy.js'
+import { header, info, success, warn } from '../../utils/exec.js'
+import { MARKERS } from '../../utils/terminal.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const CLEAN_PRESET_PATH = path.resolve(__dirname, '../../presets/clean.json')
+const cleanPreset = await fse.readJson(CLEAN_PRESET_PATH)
+
+async function childrenExcludingPreserved(dir) {
+  const results = []
+  if (!await fse.pathExists(dir)) return results
+  const entries = await fse.readdir(dir)
+  for (const entry of entries) {
+    if (cleanPreset.preserveSubfolders.includes(entry)) continue
+    results.push(path.join(dir, entry))
+  }
+  return results
+}
+
+async function isPopulated(filePath) {
+  if (!await fse.pathExists(filePath)) return false
+  const content = await fse.readFile(filePath, 'utf-8')
+  const trimmed = content.trim()
+  if (!trimmed) return false
+  if (trimmed.startsWith('<!-- onboard-prompt')) return false
+  return true
+}
+
+async function hasOpenspecHistory(cwd) {
+  const changesDir = path.join(cwd, 'openspec', 'changes')
+  const archiveDir = path.join(cwd, 'openspec', 'archive')
+  if (await fse.pathExists(changesDir)) {
+    const entries = await fse.readdir(changesDir)
+    if (entries.length > 0) return true
+  }
+  if (await fse.pathExists(archiveDir)) {
+    const entries = await fse.readdir(archiveDir)
+    if (entries.length > 0) return true
+  }
+  return false
+}
+
+export async function cleanAiFiles({ removeLegacyConfig = false } = {}) {
+  header('Step 2, Existing AI config files')
+
+  const cwd = process.cwd()
+  const ctx = {
+    hasDesign: await isPopulated(path.join(cwd, 'DESIGN.md')),
+    hasArchitecture: await isPopulated(path.join(cwd, 'ARCHITECTURE.md')),
+    hasOpenspec: await hasOpenspecHistory(cwd),
+  }
+
+  if (ctx.hasDesign) info('DESIGN.md exists and is populated, keeping it')
+  if (ctx.hasArchitecture) info('ARCHITECTURE.md exists and is populated, keeping it')
+  if (ctx.hasOpenspec) info('openspec/ history exists, keeping it')
+
+  const legacyConfig = path.join(cwd, '.opencode', 'opencode.json')
+  if (removeLegacyConfig && await fse.pathExists(legacyConfig)) {
+    await fse.remove(legacyConfig)
+    info('Removed legacy .opencode/opencode.json')
+  }
+
+  const flatFiles = await findAiFiles(cwd, cleanPreset.detectFiles)
+  const dirTargets = cleanPreset.directoryTargets
+  const dirEntries = []
+  for (const dirName of dirTargets) {
+    const dirPath = path.join(cwd, dirName)
+    const children = await childrenExcludingPreserved(dirPath)
+    if (children.length > 0) {
+      dirEntries.push(...children)
+    } else if (await fse.pathExists(dirPath)) {
+      // Directory exists but all children are preserved (e.g. only skills/):
+      // still offer the directory itself as a removable option.
+      dirEntries.push(dirPath)
+    }
+  }
+
+  const filteredFlat = flatFiles.filter(f => {
+    const rel = path.relative(cwd, f)
+    if (dirTargets.includes(rel)) return false
+    if (cleanPreset.preserve.some(p => rel === p || rel.startsWith(p + path.sep))) return false
+    return true
+  })
+
+  const allToRemove = [...filteredFlat, ...dirEntries]
+
+  if (allToRemove.length === 0) {
+    success('No existing AI config files to remove')
+    return ctx
+  }
+
+  const choices = allToRemove.map(f => ({
+    name: path.relative(cwd, f).replace(/\\/g, '/'),
+    value: f,
+    checked: true,
+  }))
+
+  const selected = await checkbox({
+    message: cleanPreset.selectionMessage,
+    choices,
+  })
+
+  if (!selected || selected.length === 0) {
+    success('No AI config files selected for removal')
+    return ctx
+  }
+
+  warn('Removing selected AI config files:')
+  for (const f of selected) {
+    info(`${MARKERS.EMPTY}${f.replace(cwd + path.sep, '')}`)
+    await fse.remove(f)
+  }
+  success('Removed existing AI config files')
+
+  return ctx
+}