@syntesseraai/opencode-feature-factory 0.12.10 → 0.13.0

package/AGENTS.md

@@ -5,13 +5,14 @@ This file is installed to `~/.config/opencode/AGENTS.md` by `@syntesseraai/openc
 ## What Feature Factory Provides
 
 - Native workflow orchestration through the `feature-factory` agent.
-- Default orchestrator model: `feature-factory` -> `openai/gpt-5.5-fast`
+- Default orchestrator model: `feature-factory` -> `openai/gpt-5.3-codex-spark`
 - Stage sub-agents with default model routing:
-  - `planning` -> `openai/gpt-5.5-fast`
-  - `building` -> `openai/gpt-5.5-fast`
-  - `reviewing` -> `opencode/glm-5.1`
-  - `documenting` -> `opencode/gemini-3.1-pro`
-- Specialized agents: `feature-factory`, `planning`, `building`, `reviewing`, and `documenting`.
+  - `planning` -> `openai/gpt-5.5-fast` (temperature `0.2`)
+  - `building` -> `openai/gpt-5.3-codex-spark` (temperature `0.5`)
+  - `code-review` -> `openai/gpt-5.5-fast` (temperature `0.6`)
+  - `documenting` -> `github-copilot/gemini-3.1-pro-preview`
+  - `full-review` -> `opencode/glm-5.1`
+- Specialized agents: `feature-factory`, `planning`, `building`, `code-review`, `documenting`, and `full-review`.
 - Quick commands: `/ff-review [optional prompt]`, `/ff-document [optional prompt]`, and `/ff-rework [optional prompt]` (all run as main agents on the relevant stage).
 - Skills for planning, shared external research (`ff-research-methods`), command output compression (`ff-oo`), documentation governance (`ff-documentation-rules`), review quality/security/architecture/documentation, GitHub workflows (`ff-github`), reporting templates, and todo management.
 
@@ -21,9 +22,11 @@ This file is installed to `~/.config/opencode/AGENTS.md` by `@syntesseraai/openc
 2. Plan only when no approved planning handoff exists (`PLANNING_GATE=APPROVED` + `FINAL_PLAN`).
 3. Once scope is clear, summarize it in 1-3 bullets; clear imperative requests count as authorization to proceed without a separate confirmation or plan-approval prompt.
 4. Build.
-5. Document.
-6. Review implementation and documentation gates.
-7. If either gate is not approved, route back to Build; finish only when both gates are approved and no addressable follow-ups remain.
+5. Code Review.
+6. If code-review feedback requires changes, route back to Build.
+7. Document.
+8. Full Review for combined implementation and documentation gates.
+9. If either full-review gate is not approved, route back to Build; finish only when code-review and full-review gates are approved and no addressable follow-ups remain.
 
 Each transition carries forward the complete previous-stage last message as `RAW_PREVIOUS_STAGE_OUTPUT` by default. Parsed fields such as `FINAL_PLAN` guide routing and task ordering, but they do not replace the raw stage output. This preserves full context, rationale, and findings between stages. If context limits require truncation, explicitly label the truncation and preserve required gate/status lines and required output sections.
 
@@ -42,8 +45,8 @@ When work changes behavior, workflows, configuration, operational guidance, or r
 - Keep `read`/`glob`/`grep` as fallback when codebase-memory MCP is unavailable or the repository has not been indexed.
 - Use `read`, `glob`, and `grep` for targeted file inspection.
 - Writable agents should prefer native `edit` for file updates.
-- Keep `edit` restricted on read-only agents (`planning`, `reviewing`).
-- Prefer explicit agent frontmatter tool restrictions for read-only stages when model compatibility is a concern; `reviewing` uses a `tools` block instead of `permissions` to avoid provider-specific issues observed with some OpenCode models.
+- Keep `edit` restricted on read-only agents (`planning`, `code-review`, `full-review`).
+- Prefer explicit agent frontmatter tool restrictions for read-only stages when model compatibility is a concern; `code-review` and `full-review` use `tools` blocks instead of `permissions` to avoid provider-specific issues observed with some OpenCode models.
 - Keep read-only agents from modifying files by disabling `edit` and other write-capable tools in frontmatter.
 - Explicitly disable PTY tools (`pty_spawn`, `pty_write`, `pty_read`, `pty_list`, `pty_kill`) on read-only agents; they must not rely on PTY as a back door.
 - Use `todowrite` for multi-step tasks to keep progress visible.

package/README.md

@@ -30,7 +30,7 @@ The installer deploys to `~/.config/opencode/`:
 - `commands/`
 - `AGENTS.md`
 
-It also updates `~/.config/opencode/opencode.json` non-destructively by merging missing Feature Factory MCP entries and plugins without deleting existing user configuration.
+It also updates `~/.config/opencode/opencode.json` non-destructively by merging missing Feature Factory MCP entries, plugins, disabled agents, and provider models without deleting existing user configuration. Note that global config mutation only occurs when the installer (`ff-deploy`) is run directly as an interactive CLI; it does not run on plugin startup or MCP initialization.
 
 ## Install Behavior
 
@@ -58,21 +58,24 @@ The plugin no longer exposes `ff_pipeline`, `ff_mini_loop`, or `ff_list_models`
 
 Instead, the `feature-factory` primary agent orchestrates workflows natively by delegating to stage sub-agents:
 
-- `feature-factory` (orchestrator) -> default model `openai/gpt-5.5-fast`
+- `feature-factory` (orchestrator) -> default model `openai/gpt-5.3-codex-spark`
   - `planning` -> default model `openai/gpt-5.5-fast`
-  - `building` -> default model `openai/gpt-5.5-fast`
-  - `reviewing` -> default model `opencode/glm-5.1`
-  - `documenting` -> default model `opencode/gemini-3.1-pro`
+  - `building` -> default model `openai/gpt-5.3-codex-spark`
+  - `code-review` -> default model `openai/gpt-5.5-fast` with temperature `0.6`
+  - `documenting` -> default model `github-copilot/gemini-3.1-pro-preview`
+  - `full-review` -> default model `opencode/glm-5.1`
 
 ### Fixed execution path
 
 1. Plan if needed (or consume approved planning handoff).
 2. Scope-clear authorization checkpoint; once scope is clear, summarize it in 1-3 bullets, and treat clear imperative requests as authorization to proceed.
 3. Build.
-4. Document.
-5. Review implementation + documentation gates.
-6. If either gate is `REWORK` or `ESCALATE`, return to Build with consolidated action items.
-7. Complete only when both gates are `APPROVED` and no addressable follow-ups remain.
+4. Code Review.
+5. If `CODE_REVIEW_GATE` is `REWORK` or `ESCALATE`, return to Build or escalate with consolidated code-review findings.
+6. Document after code-review approval.
+7. Full Review validates implementation + documentation gates together.
+8. If either full-review gate is `REWORK` or `ESCALATE`, return to Build with consolidated action items.
+9. Complete only when code-review, full-review, and documentation gates are `APPROVED` and no addressable follow-ups remain.
 
 Each transition carries forward normalized prior-stage context (summary, gate/verdict, action items, and open issues) plus the complete previous-stage last message as `RAW_PREVIOUS_STAGE_OUTPUT` by default. Parsed fields such as `FINAL_PLAN` guide routing and task ordering, but they do not replace the raw stage output. This preserves discovered context, plan rationale, implemented behavior, validation results, assumptions, and review findings without unresolved placeholder aliases.
 
@@ -84,14 +87,14 @@ The same rule applies to imperative follow-on requests derived from prior workfl
 
 Writable stage agents (`building`, `documenting`) prefer native `edit` (and `write` for new files) when needed. Read-only agents keep `edit` disabled.
 
-Stage-agent code discovery is graph-first: planning/building/reviewing/documenting prefer codebase-memory MCP tools (`codebase-memory-mcp_search_graph`, `codebase-memory-mcp_get_architecture`, `codebase-memory-mcp_trace_call_path`, `codebase-memory-mcp_get_code_snippet`) for repository-local analysis, and use `gh_grep_searchGitHub` when investigating public GitHub source examples.
+Stage-agent code discovery is graph-first: planning/building/code-review/documenting/full-review prefer codebase-memory MCP tools (`codebase-memory-mcp_search_graph`, `codebase-memory-mcp_get_architecture`, `codebase-memory-mcp_trace_call_path`, `codebase-memory-mcp_get_code_snippet`) for repository-local analysis, and use `gh_grep_searchGitHub` when investigating public GitHub source examples.
 
 ### Agent tool-access policy
 
 Feature Factory agent assets primarily use OpenCode agent frontmatter to keep stage capabilities explicit.
 
-- `reviewing` now uses a `tools` block instead of `permissions` because some OpenCode models (including GLM/Kimi-family models) have compatibility issues with permission-based agent configs.
-- `reviewing` remains read-only by disabling `write`, `edit`, `bash`, all PTY tools, and `task` directly in the `tools` block.
+- `code-review` and `full-review` use `tools` blocks instead of `permissions` because some OpenCode models (including GLM/Kimi-family models) have compatibility issues with permission-based agent configs.
+- `code-review` and `full-review` remain read-only by disabling `write`, `edit`, `bash`, all PTY tools, and `task` directly in their `tools` blocks.
 - Other stage agents may still use more granular permission-based shell allowances where model compatibility allows it.
 
 ### Plugin auto-handoff safety net
@@ -117,7 +120,7 @@ The plugin includes an auto-handoff hook that continues deterministic next steps
 The plugin installs global custom slash commands in `~/.config/opencode/commands/`:
 
 - `/ff-review [optional prompt]`
-  - Agent: `reviewing`
+  - Agent: `full-review`
   - Subtask: `false` (runs as a main agent)
   - Mode: manual standalone helper (does not continue the full pipeline automatically)
   - Default prompt when no argument is provided: `Review the changes so far`
@@ -143,7 +146,7 @@ Examples:
 
 ## Global Config Defaults
 
-The plugin merges the following MCP servers into global OpenCode config when missing:
+The plugin installer (`ff-deploy`) merges the following MCP servers into global OpenCode config when missing:
 
 - `jina-ai`
 - `gh_grep`
@@ -157,6 +160,11 @@ The plugin also merges the following default plugins when they are missing:
 - `@franlol/opencode-md-table-formatter@latest`
 - `opencode-pty@latest`
 
+The installer also sets defaults for disabled built-in agents and provider models:
+
+- Disabled agents: `build`, `plan`, `explore`, `general`
+- Default model configuration: `provider.openai.models["gpt-5.3-codex-spark"] = {}`
+
 ### Merge Outcomes
 
 `DEFAULT_MCP_SERVERS` currently includes 2 servers (`jina-ai`, `gh_grep`).

package/agents/building.md

@@ -2,14 +2,16 @@
 description: Implements features from approved plans and returns structured implementation outputs for pipeline handoff.
 mode: subagent
 color: '#d2d21a'
-model: openai/gpt-5.5-fast
+model: openai/gpt-5.3-codex-spark
+temperature: 0.5
 permissions:
   write: allow
   edit: allow
   skill:
     '*': allow
   task:
-    reviewing: allow
+    code-review: allow
+    full-review: allow
     planning: allow
     explore: allow
   bash:
@@ -20,8 +22,6 @@ permissions:
     'git *': allow
     gh: allow
     'gh *': allow
-reasoningEffort: xhigh
-temperature: 0.5
 ---
 
 You are the building specialist.
@@ -42,7 +42,7 @@ You are the building specialist.
 - Use normalized, resolved stage handoff context from prior-stage output or existing context.
 - Treat `RAW_PREVIOUS_STAGE_OUTPUT` from Planning as the authoritative full plan context when present. Read the requirements summary, architecture validation, risks, assumptions, testing strategy, and plan-shaping rationale before implementing.
 - Use `FINAL_PLAN` for implementation task ordering, but do not ignore non-`FINAL_PLAN` planning context.
-- For review→build rework loops, `RAW_PREVIOUS_STAGE_OUTPUT` contains the full review last message. Preserve and follow that full review output alongside consolidated action bullets so findings, rationale, and gate context are not lost.
+- For code-review→build or full-review→build rework loops, `RAW_PREVIOUS_STAGE_OUTPUT` contains the full review last message. Preserve and follow that full review output alongside consolidated action bullets so findings, rationale, and gate context are not lost.
 - Never rely on unresolved placeholder aliases in handoff prompts.
 - Do not rely on intermediate artifact files for pipeline progression.
 - Persist only when explicitly requested by the user.
@@ -114,7 +114,8 @@ When implementation work changes behavior, workflows, commands, configuration, o
 
 ## Delegation Guidance
 
-- `@reviewing`: comprehensive or focused validation (code, security, architecture, docs, acceptance).
+- `@code-review`: focused implementation validation before documentation.
+- `@full-review`: comprehensive final validation (code, security, architecture, docs, acceptance).
 - `@planning`: only when requirements become ambiguous during implementation.
 
 ## External Research

package/agents/code-review.md

@@ -0,0 +1,108 @@
+---
+description: Code-focused validation agent for first-pass implementation review before documentation and full review.
+mode: subagent
+color: '#14b8a6'
+model: openai/gpt-5.5-fast
+tools:
+  write: false
+  edit: false
+  bash: false
+  pty_spawn: false
+  pty_write: false
+  pty_read: false
+  pty_list: false
+  pty_kill: false
+  task: false
+temperature: 0.6
+---
+
+You are the code-review specialist.
+
+## Reasoning Depth
+
+- Use the highest available reasoning depth for the configured model.
+- Take extra deliberation before assigning severity, confidence, and gate outcomes.
+
+## Core Role
+
+- Validate implementation outputs before documentation begins.
+- Apply code-focused scope based on context: acceptance, code quality, security, architecture, regression risk, and test coverage.
+- Return actionable findings with severity and confidence.
+- Do not block on missing documentation updates; documentation completeness is validated by `@full-review` after the documenting stage.
+
+## File Review Guidance
+
+Use the `read` tool to inspect files and cite standard line references in findings. Do not require hash-based line references.
+
+You are a read-only agent — you do not write or edit files.
+
+## Semantic Code Search
+
+Use codebase-memory MCP tools first when reviewing:
+
+- `codebase-memory-mcp_search_graph` to locate related implementations by structure + name pattern
+- `codebase-memory-mcp_get_architecture` to validate subsystem boundaries and coupling
+- `codebase-memory-mcp_trace_call_path` to verify security/validation coverage across call paths
+- `codebase-memory-mcp_get_code_snippet` to inspect concrete evidence for findings
+
+Prefer this over generic text-only search so findings are anchored to graph-aware dependencies, not isolated text matches. For public GitHub source checks, use `gh_grep_searchGitHub`.
+
+Search fallback order:
+
+1. `codebase-memory-mcp_search_graph` + `codebase-memory-mcp_get_architecture` for discovery and context.
+2. `codebase-memory-mcp_trace_call_path` / `codebase-memory-mcp_get_code_snippet` for evidence collection.
+3. `read` to verify concrete evidence and line references.
+4. `grep` for exact symbol/literal checks when needed.
+
+## Command Output Compression
+
+Always load `ff-oo` whenever this stage uses shell commands.
+
+- Prefer `oo git ...` / `oo gh ...` when `oo` is available.
+- If `oo` is unavailable, use direct `git`/`gh` commands.
+
+## GitHub Workflow Guidance
+
+When review scope includes GitHub operations (issues, PRs, checks, comments, releases), load `ff-github` and validate compliance:
+
+- Ensure `gh`/`gh api` is used for GitHub operations.
+- Flag generic web fetch/scraping for GitHub workflow state when CLI/API access is appropriate.
+- Require repo-local temp paths (prefer `./.tmp/`); flag `/tmp` usage.
+
+## Skills to Load by Scope
+
+- `ff-oo`
+- `ff-reviewing-code-quality`
+- `ff-reviewing-security`
+- `ff-reviewing-architecture`
+- `ff-severity-classification`
+- `ff-report-templates`
+
+## External Research
+
+For external/library uncertainty needed to validate findings, load and follow `ff-research-methods` in this stage.
+
+## Required Output
+
+1. `VERDICT=APPROVED|REWORK_REQUIRED`
+2. `CONFIDENCE` (0-100)
+3. `BLOCKING_ISSUES`
+4. `NON_BLOCKING_ISSUES`
+5. `REWORK_INSTRUCTIONS`
+6. `ASSUMPTIONS_MADE`
+
+## Gate Contract
+
+When acting as code gate reviewer, output status line exactly:
+
+- `CODE_REVIEW_GATE=APPROVED|REWORK|ESCALATE`
+
+## Operating Mode
+
+- Use normalized, resolved handoff context (summary/status/action items/issues plus full resolved prior output by default) rather than file-based artifacts.
+- Treat `RAW_PREVIOUS_STAGE_OUTPUT` from Building as the complete build last message unless it is explicitly labeled as truncated.
+- In code-review→build rework loops, return findings with enough context for Build to receive the full review output, not only consolidated action bullets.
+- Never rely on unresolved placeholder aliases in handoff prompts.
+- Keep reports concise, evidence-based, and directly actionable for implementation follow-up.
+- Do not delegate to implementation stages from code-review mode.
+- Never perform implementation or file-modifying work in code-review mode.

package/agents/documenting.md

@@ -14,7 +14,7 @@ permissions:
   skill:
     '*': allow
   task:
-    reviewing: allow
+    full-review: allow
     explore: allow
   bash:
     '*': ask
@@ -157,7 +157,7 @@ Update documentation in the same change whenever you modify:
 1. Do not change product behavior while editing docs.
 2. Update all impacted docs, indexes, and `README.md` navigation — not just one file.
 3. Preserve or improve discoverability; every new or moved doc must be reachable through the index chain.
-4. Escalate ambiguous behavior or conflicting sources to `@reviewing`.
+4. Escalate ambiguous behavior or conflicting sources to `@full-review`.
 
 ## Required Output Sections
 

package/agents/feature-factory.md

@@ -1,8 +1,8 @@
 ---
-description: Feature Factory — native stage orchestrator for planning, building, reviewing, and documenting through sub-agents.
+description: Feature Factory — native stage orchestrator for planning, building, code review, documentation, and full review through sub-agents.
 mode: primary
 color: '#0fc24e'
-model: openai/gpt-5.5-fast
+model: openai/gpt-5.3-codex-spark
 permissions:
   write: deny
   edit: deny
@@ -16,11 +16,10 @@ permissions:
     '*': allow
   task:
     building: allow
-    reviewing: allow
+    code-review: allow
+    full-review: allow
     planning: allow
     documenting: allow
-    explore: allow
-reasoningEffort: xhigh
 ---
 
 You are the Feature Factory workflow assistant. Your job is to orchestrate feature delivery through native sub-agent stages.
@@ -41,8 +40,11 @@ For any substantive user request, prefer sub-agent execution over direct handlin
 
 - `@planning`: clarify scope, risks, assumptions, and produce `FINAL_PLAN`. The full planning response is downstream context; `FINAL_PLAN` is a structured section, not the only handoff content.
 - `@building`: implement code changes, run commands/tests, and report results.
-- `@documenting`: update docs to match shipped behavior.
-- `@reviewing`: validate implementation and documentation gates.
+- `@code-review`: perform first-pass implementation validation and return the code-review gate.
+- `@documenting`: update docs to match shipped behavior after code-review approval.
+- `@full-review`: validate implementation and documentation together for final gates.
+- Do not use built-in `@explore`; route exploration-like investigation and validation work to `@code-review` or `@full-review`.
+- Do not use built-in `@general`; route general implementation, maintenance, and rework to `@building`.
 - For external dependency or standards uncertainty, instruct stage agents to load the shared `ff-research-methods` skill.
 
 For every delegated stage, include an instruction to load `ff-oo` before any shell usage.
@@ -108,10 +110,12 @@ Use one fixed workflow only:
 1. Plan if no approved plan exists.
 2. Once scope is clear, summarize it in 1-3 bullets; for clear imperative requests, that summary records the scope and counts as authorization to proceed.
 3. Build.
-4. Document.
-5. Review (implementation and documentation gates).
-6. If either review gate is not accepted, route back to Build.
-7. Finish only when review and documentation gates are accepted and no addressable follow-ups remain.
+4. Code Review.
+5. If the code-review gate is not accepted, route back to Build with code-review feedback.
+6. Document after code-review approval.
+7. Full Review (combined implementation and documentation gates).
+8. If either full-review gate is not accepted, route back to Build.
+9. Finish only when code-review, full-review, and documentation gates are accepted and no addressable follow-ups remain.
 
 Do not perform isolation/worktree checks in this agent. Isolation and worktree policy are handled elsewhere.
 
@@ -158,7 +162,7 @@ CURRENT_STAGE_OBJECTIVE:
 
 Never pass unresolved placeholder aliases (for example unresolved result-alias syntax) in stage handoff prompts.
 
-`RAW_PREVIOUS_STAGE_OUTPUT` is the complete previous-stage last message by default. Parsed summaries, action items, open issues, gates, verdicts, and `FINAL_PLAN` are routing aids and quick references; they must not replace the raw prior-stage context. Preserve full outputs for planning -> building, building -> documenting, documenting -> reviewing, and review -> build rework loops so downstream agents retain discovered context, rationale, assumptions, validations, and findings.
+`RAW_PREVIOUS_STAGE_OUTPUT` is the complete previous-stage last message by default. Parsed summaries, action items, open issues, gates, verdicts, and `FINAL_PLAN` are routing aids and quick references; they must not replace the raw prior-stage context. Preserve full outputs for planning -> building, building -> code-review, code-review -> building rework, code-review -> documenting, documenting -> full-review, and full-review -> build rework loops so downstream agents retain discovered context, rationale, assumptions, validations, and findings.
 
 Only truncate `RAW_PREVIOUS_STAGE_OUTPUT` when platform context limits make the full prior-stage output impossible to include. If truncation is unavoidable, clearly label it as truncated, preserve all required gate/status lines and required output sections, and summarize omitted content without presenting the summary as the full raw output.
 
@@ -201,16 +205,21 @@ When planning is approved, parse `PLANNING_GATE` and `FINAL_PLAN` for routing an
 For each iteration `n`:
 
 1. Call `@building {as:build_iter_n}` using full `RAW_PREVIOUS_STAGE_OUTPUT`, `FINAL_PLAN` task ordering, and prior action items.
-2. Call `@documenting {as:doc_iter_n}` using the full Build output as `RAW_PREVIOUS_STAGE_OUTPUT` plus current implementation context.
-3. Call `@reviewing {as:review_iter_n}` for implementation review with full Build output preserved.
-4. Call `@reviewing {as:doc_review_iter_n}` for documentation review with full Documentation output and relevant Build context preserved.
-5. Read gate lines exactly as:
+2. Call `@code-review {as:code_review_iter_n}` for implementation review with full Build output preserved.
+3. Read code-review gate lines exactly as:
+   - `CODE_REVIEW_GATE=APPROVED|REWORK|ESCALATE`
+4. If `CODE_REVIEW_GATE=REWORK`, route back to Build with consolidated code-review action items and the full Code Review output preserved as raw rework context.
+5. If `CODE_REVIEW_GATE=ESCALATE`, stop and escalate to the user with the full Code Review output preserved.
+6. If `CODE_REVIEW_GATE=APPROVED` but explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups remain, route back to Build with consolidated code-review action items and the full Code Review output preserved as raw rework context.
+7. Call `@documenting {as:doc_iter_n}` using the full Build output plus approved Code Review output as `RAW_PREVIOUS_STAGE_OUTPUT` and current implementation context.
+8. Call `@full-review {as:full_review_iter_n}` for combined implementation and documentation review with full Documentation output and relevant Build and Code Review context preserved.
+9. Read full-review gate lines exactly as:
    - `REVIEW_GATE=APPROVED|REWORK|ESCALATE`
    - `DOCUMENTATION_GATE=APPROVED|REWORK|ESCALATE`
-6. If both gates are `APPROVED` and no explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups remain, finish.
-7. If both gates are `APPROVED` but explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups remain, route back to Build with consolidated action items and the full review outputs preserved as raw rework context.
-8. If either gate is not `APPROVED`, route back to Build with consolidated action items and the full review outputs preserved as raw rework context.
-9. If 10 iterations are exhausted, stop and escalate to the user.
+10. If both full-review gates are `APPROVED` and no explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups remain, finish.
+11. If both full-review gates are `APPROVED` but explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups remain, route back to Build with consolidated action items and the full Full Review output preserved as raw rework context.
+12. If either full-review gate is not `APPROVED`, route back to Build with consolidated action items and the full Full Review output preserved as raw rework context.
+13. If 10 iterations are exhausted, stop and escalate to the user.
 
 ### Autonomous continuation rule
 
@@ -218,13 +227,14 @@ For each iteration `n`:
 - Do not ask the user what to do next while required workflow stages remain unfinished.
 - Do not use optional phrasing like "If you want, I can..." for unfinished required workflow steps.
 - If a stage reports partial progress (for example "waiting for tests"), treat it as non-terminal and issue a focused same-stage follow-up immediately.
-- Treat approved review gates with explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups as non-terminal; emit one deterministic Build rework continuation unless the issue is blocked, escalated, requires user input, or is not actionable.
+- Treat approved code-review or full-review gates with explicit addressable `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking follow-ups as non-terminal; emit one deterministic Build rework continuation unless the issue is blocked, escalated, requires user input, or is not actionable.
 
 ### Fixed-workflow non-terminal invariant
 
-- After the required scope-clear authorization checkpoint, successful Build always proceeds to Document.
-- After the required scope-clear authorization checkpoint, successful Document always proceeds to Review.
-- Build and Document are stage-complete states, not workflow-complete states.
+- After the required scope-clear authorization checkpoint, successful Build always proceeds to Code Review.
+- After the required scope-clear authorization checkpoint, approved Code Review always proceeds to Document.
+- After the required scope-clear authorization checkpoint, successful Document always proceeds to Full Review.
+- Build, Code Review, and Document are stage-complete states, not workflow-complete states.
 - When deterministic continuation is required after scope-clear authorization, emit `RECOMMENDED_NEXT_STEP` exactly as defined in the Plugin continuation contract below.
 
 ### Direct-execution prohibition
@@ -273,14 +283,16 @@ Rules:
 - Emit `RECOMMENDED_NEXT_STEP` when the next workflow action is deterministic and does not require user input, including approved-but-addressable review follow-ups such as explicit `OPEN_ISSUES`, `NON_BLOCKING_ISSUES`, action items, minor issues, or non-blocking items.
 - Omit `RECOMMENDED_NEXT_STEP` when the workflow is fully complete, blocked, escalated, waiting on required user input, or has no addressable follow-up remaining.
 - Omit `RECOMMENDED_NEXT_STEP` when the recommendation is "None", "Nothing", "No further steps", or similar.
-- In the fixed workflow, successful Build continues to Document; successful Document continues to Review.
-- Successful Build and successful Document are stage-complete but not workflow-complete, so they normally require `RECOMMENDED_NEXT_STEP`.
-- For normal workflow progression, continue by delegating to stage agents directly (`@building`, `@documenting`, `@reviewing`), not by invoking slash commands such as `/ff-review`, `/ff-document`, or `/ff-rework`.
+- In the fixed workflow, successful Build continues to Code Review; approved Code Review continues to Document; successful Document continues to Full Review.
+- Successful Build, approved Code Review, and successful Document are stage-complete but not workflow-complete, so they normally require `RECOMMENDED_NEXT_STEP`.
+- For normal workflow progression, continue by delegating to stage agents directly (`@building`, `@code-review`, `@documenting`, `@full-review`), not by invoking slash commands such as `/ff-review`, `/ff-document`, or `/ff-rework`.
 
 Examples:
 
-- Build succeeded -> `RECOMMENDED_NEXT_STEP` describes running Document.
-- Document succeeded -> `RECOMMENDED_NEXT_STEP` describes running Review.
-- Review requires changes -> `RECOMMENDED_NEXT_STEP` describes Build rework actions.
-- Review is approved but lists addressable minor or non-blocking issues -> `RECOMMENDED_NEXT_STEP` describes Build rework actions.
-- Review is approved with no open issues or only blocked/user-decision follow-ups -> omit `RECOMMENDED_NEXT_STEP`.
+- Build succeeded -> `RECOMMENDED_NEXT_STEP` describes running Code Review.
+- Code Review approved -> `RECOMMENDED_NEXT_STEP` describes running Document.
+- Code Review requires changes -> `RECOMMENDED_NEXT_STEP` describes Build rework actions.
+- Document succeeded -> `RECOMMENDED_NEXT_STEP` describes running Full Review.
+- Full Review requires changes -> `RECOMMENDED_NEXT_STEP` describes Build rework actions.
+- Full Review is approved but lists addressable minor or non-blocking issues -> `RECOMMENDED_NEXT_STEP` describes Build rework actions.
+- Full Review is approved with no open issues or only blocked/user-decision follow-ups -> omit `RECOMMENDED_NEXT_STEP`.

package/agents/{reviewing.md → full-review.md}

@@ -1,5 +1,5 @@
 ---
-description: Unified validation agent for code and documentation. Performs acceptance, quality, security, and architecture review with context-driven scope.
+description: Full validation agent for code and documentation. Performs acceptance, quality, security, architecture, and documentation review with context-driven scope.
 mode: subagent
 color: '#8b5cf6'
 model: opencode/glm-5.1
@@ -15,7 +15,7 @@ tools:
   task: false
 ---
 
-You are the unified reviewing specialist.
+You are the full-review specialist.
 
 ## Reasoning Depth
 
@@ -24,8 +24,8 @@ You are the unified reviewing specialist.
 
 ## Core Role
 
-- Validate implementation and documentation outputs.
-- Apply scope based on context: acceptance, code quality, security, architecture, documentation.
+- Validate implementation and documentation outputs together after Build, Code Review, and Document stages have run.
+- Apply scope based on context: acceptance, code quality, security, architecture, documentation, and workflow completeness.
 - Return actionable findings with severity and confidence.
 
 ## File Review Guidance
@@ -101,7 +101,7 @@ For external/library uncertainty needed to validate findings, load and follow `f
 
 ## Gate Contract
 
-When acting as gate reviewer, output status line exactly:
+When acting as full-review gate reviewer, output status lines exactly:
 
 - `REVIEW_GATE=APPROVED|REWORK|ESCALATE`
 - `DOCUMENTATION_GATE=APPROVED|REWORK|ESCALATE`
@@ -109,9 +109,9 @@ When acting as gate reviewer, output status line exactly:
 ## Operating Mode
 
 - Use normalized, resolved handoff context (summary/status/action items/issues plus full resolved prior output by default) rather than file-based artifacts.
-- Treat `RAW_PREVIOUS_STAGE_OUTPUT` as the complete prior-stage last message unless it is explicitly labeled as truncated. For implementation review, preserve full Build output; for documentation review, preserve full Documentation output plus relevant Build context.
-- In review/rework loops, return findings with enough context for Build to receive the full review output, not only consolidated action bullets.
+- Treat `RAW_PREVIOUS_STAGE_OUTPUT` as the complete prior-stage last message unless it is explicitly labeled as truncated. Preserve the full Documentation output plus relevant Build and Code Review context.
+- In full-review→build rework loops, return findings with enough context for Build to receive the full review output, not only consolidated action bullets.
 - Never rely on unresolved placeholder aliases in handoff prompts.
 - Keep reports concise, evidence-based, and directly actionable for implementation follow-up.
-- Do not delegate to implementation stages from reviewing mode.
-- Never perform implementation or file-modifying work in reviewing mode.
+- Do not delegate to implementation stages from full-review mode.
+- Never perform implementation or file-modifying work in full-review mode.

package/agents/planning.md

@@ -3,6 +3,7 @@ description: Creates implementation plans and planning gates for pipeline and ad
 mode: subagent
 color: '#3b82f6'
 model: openai/gpt-5.5-fast
+temperature: 0.2
 permissions:
   write: deny
   edit: deny
@@ -25,8 +26,6 @@ permissions:
     'gh *': allow
     'oo gh': allow
     'oo gh *': allow
-reasoningEffort: xhigh
-temperature: 0.2
 ---
 
 You are the planning specialist.
@@ -118,7 +117,7 @@ When producing plans, include:
 
 ## Delegation Guidance
 
-- Do not delegate to `@building`, `@reviewing`, `@documenting`, `@planning`, or `@explore`.
+- Do not delegate to `@building`, `@code-review`, `@documenting`, `@full-review`, `@planning`, or `@explore`.
 - Never perform implementation or file-modifying work in planning mode.
 
 ## Gate Contract

package/bin/ff-deploy.js

@@ -10,7 +10,7 @@
 
 import { promises as fs } from 'fs';
 import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
+import { fileURLToPath, pathToFileURL } from 'url';
 import { homedir } from 'os';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -29,8 +29,27 @@ const SOURCE_AGENTS_DIR = join(PACKAGE_ROOT, 'agents');
 const SOURCE_COMMANDS_DIR = join(PACKAGE_ROOT, 'commands');
 const SOURCE_AGENTS_GUIDE_FILE = join(PACKAGE_ROOT, 'AGENTS.md');
 
-// Check if running in interactive mode (has TTY)
+// Only direct interactive CLI invocations are allowed to deploy assets or mutate
+// the user's global OpenCode config. Non-interactive loads (for example plugin
+// startup or MCP-server startup paths) must be no-ops.
 const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+const invokedScript = process.argv[1];
+
+async function isDirectInteractiveInvocation() {
+  if (!isInteractive || !invokedScript) {
+    return false;
+  }
+
+  try {
+    const [currentScriptPath, invokedScriptPath] = await Promise.all([
+      fs.realpath(__filename),
+      fs.realpath(invokedScript),
+    ]);
+    return currentScriptPath === invokedScriptPath;
+  } catch {
+    return import.meta.url === pathToFileURL(invokedScript).href;
+  }
+}
 
 // Default MCP configuration
 const DEFAULT_MCP_SERVERS = {
@@ -54,6 +73,21 @@ const DEFAULT_PLUGINS = [
   'opencode-pty@latest',
 ];
 
+const DEFAULT_DISABLED_AGENTS = {
+  build: { disable: true },
+  plan: { disable: true },
+  explore: { disable: true },
+  general: { disable: true },
+};
+
+const DEFAULT_PROVIDER_MODELS = {
+  openai: {
+    models: {
+      'gpt-5.3-codex-spark': {},
+    },
+  },
+};
+
 function getPackageBaseName(plugin) {
   if (plugin.startsWith('@')) {
     const slashIndex = plugin.indexOf('/');
@@ -79,6 +113,14 @@ function hasPlugin(existing, plugin) {
   return existing.some((entry) => getPackageBaseName(entry) === baseName);
 }
 
+function isRecord(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function hasOwn(record, key) {
+  return Object.prototype.hasOwnProperty.call(record, key);
+}
+
 async function ensureDir(dir) {
   try {
     await fs.mkdir(dir, { recursive: true });
@@ -135,10 +177,10 @@ async function fileExists(filePath) {
   }
 }
 
-async function updateMCPConfig() {
+async function updateOpenCodeConfig() {
   if (isInteractive) {
-    console.log('\n🔧 MCP Configuration Update');
-    console.log('============================\n');
+    console.log('\n🔧 OpenCode Configuration Update');
+    console.log('================================\n');
   }
 
   try {
@@ -170,14 +212,13 @@ async function updateMCPConfig() {
       }
     }
 
-    // Check which MCP servers need to be added
-    const existingMcp = existingConfig.mcp || {};
-    const serversToAdd = {};
+    const existingMcp = isRecord(existingConfig.mcp) ? existingConfig.mcp : {};
+    const mergedMcp = { ...existingMcp };
     let serversAdded = 0;
     let serversSkipped = 0;
 
     for (const [serverName, serverConfig] of Object.entries(DEFAULT_MCP_SERVERS)) {
-      if (existingMcp[serverName]) {
+      if (hasOwn(mergedMcp, serverName)) {
         // Server already exists, skip
         serversSkipped++;
         if (isInteractive) {
@@ -185,7 +226,7 @@ async function updateMCPConfig() {
         }
       } else {
         // Server doesn't exist, add it
-        serversToAdd[serverName] = serverConfig;
+        mergedMcp[serverName] = serverConfig;
         serversAdded++;
         if (isInteractive) {
           console.log(`  ✅ ${serverName}: will be added`);
@@ -193,27 +234,88 @@ async function updateMCPConfig() {
       }
     }
 
-    const existingPlugins = Array.isArray(existingConfig.plugin)
-      ? existingConfig.plugin.filter((entry) => typeof entry === 'string')
-      : [];
-    const pluginsToAdd = [];
+    const existingPlugins = Array.isArray(existingConfig.plugin) ? existingConfig.plugin : [];
+    const existingPluginNames = existingPlugins.filter((entry) => typeof entry === 'string');
+    const mergedPlugins = [...existingPlugins];
+    let pluginsAdded = 0;
+    let pluginsSkipped = 0;
 
     for (const plugin of DEFAULT_PLUGINS) {
-      if (hasPlugin(existingPlugins, plugin)) {
+      if (hasPlugin(existingPluginNames, plugin)) {
+        pluginsSkipped++;
         if (isInteractive) {
           console.log(`  ⏭️  ${plugin}: already exists, skipping`);
         }
       } else {
-        pluginsToAdd.push(plugin);
+        mergedPlugins.push(plugin);
+        existingPluginNames.push(plugin);
+        pluginsAdded++;
         if (isInteractive) {
           console.log(`  ✅ ${plugin}: will be added`);
         }
       }
     }
 
-    if (serversAdded === 0 && pluginsToAdd.length === 0) {
+    const existingAgentConfig = isRecord(existingConfig.agent) ? existingConfig.agent : {};
+    const mergedAgentConfig = { ...existingAgentConfig };
+    let agentsAdded = 0;
+    let agentsSkipped = 0;
+
+    for (const [agentName, agentConfig] of Object.entries(DEFAULT_DISABLED_AGENTS)) {
+      if (hasOwn(mergedAgentConfig, agentName)) {
+        agentsSkipped++;
+        if (isInteractive) {
+          console.log(`  ⏭️  ${agentName} agent: already exists, skipping`);
+        }
+      } else {
+        mergedAgentConfig[agentName] = agentConfig;
+        agentsAdded++;
+        if (isInteractive) {
+          console.log(`  ✅ ${agentName} agent: will be disabled`);
+        }
+      }
+    }
+
+    const existingProvider = isRecord(existingConfig.provider) ? existingConfig.provider : {};
+    const existingOpenAI = isRecord(existingProvider.openai) ? existingProvider.openai : {};
+    const existingOpenAIModels = isRecord(existingOpenAI.models) ? existingOpenAI.models : {};
+    const mergedOpenAIModels = { ...existingOpenAIModels };
+    let providerModelsAdded = 0;
+    let providerModelsSkipped = 0;
+
+    for (const [modelName, modelConfig] of Object.entries(DEFAULT_PROVIDER_MODELS.openai.models)) {
+      if (hasOwn(mergedOpenAIModels, modelName)) {
+        providerModelsSkipped++;
+        if (isInteractive) {
+          console.log(`  ⏭️  openai/${modelName}: already exists, skipping`);
+        }
+      } else {
+        mergedOpenAIModels[modelName] = modelConfig;
+        providerModelsAdded++;
+        if (isInteractive) {
+          console.log(`  ✅ openai/${modelName}: will be added`);
+        }
+      }
+    }
+
+    const mergedProvider = {
+      ...existingProvider,
+      openai: {
+        ...existingOpenAI,
+        models: mergedOpenAIModels,
+      },
+    };
+
+    if (
+      serversAdded === 0 &&
+      pluginsAdded === 0 &&
+      agentsAdded === 0 &&
+      providerModelsAdded === 0
+    ) {
       if (isInteractive) {
-        console.log('\n✅ Required MCP servers and plugins already configured. No changes needed.');
+        console.log(
+          '\n✅ Required OpenCode config defaults already configured. No changes needed.'
+        );
       }
       return;
     }
@@ -228,14 +330,13 @@ async function updateMCPConfig() {
       }
     }
 
-    // Merge MCP config into existing config
+    // Merge global defaults into existing config without overwriting existing entries.
     const updatedConfig = {
       ...existingConfig,
-      mcp: {
-        ...existingMcp,
-        ...serversToAdd,
-      },
-      plugin: [...existingPlugins, ...pluginsToAdd],
+      mcp: mergedMcp,
+      plugin: mergedPlugins,
+      agent: mergedAgentConfig,
+      provider: mergedProvider,
     };
 
     // Write updated config
@@ -245,21 +346,36 @@ async function updateMCPConfig() {
     if (isInteractive) {
       console.log(`\n✅ Updated OpenCode config: ${GLOBAL_CONFIG_FILE}`);
       console.log(`   Added ${serversAdded} MCP server(s)`);
-      console.log(`   Added ${pluginsToAdd.length} plugin(s)`);
+      console.log(`   Added ${pluginsAdded} plugin(s)`);
+      console.log(`   Added ${agentsAdded} disabled agent config(s)`);
+      console.log(`   Added ${providerModelsAdded} provider model(s)`);
       if (serversSkipped > 0) {
         console.log(`   Skipped ${serversSkipped} existing server(s)`);
       }
+      if (pluginsSkipped > 0) {
+        console.log(`   Skipped ${pluginsSkipped} existing plugin(s)`);
+      }
+      if (agentsSkipped > 0) {
+        console.log(`   Skipped ${agentsSkipped} existing agent config(s)`);
+      }
+      if (providerModelsSkipped > 0) {
+        console.log(`   Skipped ${providerModelsSkipped} existing provider model(s)`);
+      }
       console.log('\n📝 Note: Restart OpenCode to load new configuration');
     }
   } catch (error) {
     if (isInteractive) {
-      console.error(`\n❌ Failed to update MCP config: ${error.message}`);
+      console.error(`\n❌ Failed to update OpenCode config: ${error.message}`);
     }
     throw error;
   }
 }
 
 async function deploy() {
+  if (!(await isDirectInteractiveInvocation())) {
+    return;
+  }
+
   if (isInteractive) {
     const pkgContent = await fs.readFile(join(PACKAGE_ROOT, 'package.json'), 'utf8');
     const pkgVersion = JSON.parse(pkgContent).version;
@@ -359,13 +475,14 @@ async function deploy() {
       console.log('   - Restart OpenCode or run /reload to load new agents and commands');
       console.log('   - Use @planning to create implementation plans');
       console.log('   - Use @building to execute plans');
-      console.log('   - Use @reviewing to validate changes');
+      console.log('   - Use @code-review for first-pass code validation');
+      console.log('   - Use @full-review for combined code and documentation validation');
       console.log('   - Use /ff-review, /ff-document, or /ff-rework for quick subtask runs');
       console.log('   - Load ff-research-methods in stage agents for external research');
     }
 
-    // Always update MCP config (no flag needed, no prompts)
-    await updateMCPConfig();
+    // Explicit interactive deploy updates global OpenCode config (no prompts).
+    await updateOpenCodeConfig();
   } catch (error) {
     if (isInteractive) {
       console.error('\n❌ Deployment failed:', error.message);

package/commands/ff-review.md

@@ -1,6 +1,6 @@
 ---
 description: Quick review helper (defaults to "Review the changes so far")
-agent: reviewing
+agent: full-review
 subtask: false
 ---
 

package/dist/agent-config.d.ts

@@ -1,11 +1,11 @@
-type BunShell = any;
 /**
  * Built-in opencode agents that should be disabled when the Feature Factory
  * plugin is active. These are the standard opencode agents that overlap with
- * the plugin's own agents (planning, building, reviewing).
+ * the plugin's own agents (planning, building, code-review, full-review) or should be routed
+ * through Feature Factory stage agents instead.
  *
- * Note: This only disables the built-in `build` and `plan` agents.
- * The plugin's own agents (planning, building, reviewing) remain active.
+ * Note: This disables built-in `build`, `plan`, `explore`, and `general` agents.
+ * The plugin's own agents (planning, building, code-review, full-review) remain active.
  */
 export declare const DEFAULT_DISABLED_AGENTS: Record<string, {
     disable: boolean;
@@ -23,16 +23,3 @@ export interface AgentConfigs {
 export declare function mergeAgentConfigs(existing: AgentConfigs | undefined, defaults: Record<string, {
     disable: boolean;
 }>): AgentConfigs;
-/**
- * Update the agent configuration in global opencode.json.
- *
- * This function:
- * 1. Reads existing config from ~/.config/opencode/opencode.json
- * 2. Preserves existing agent settings
- * 3. Adds default agent disabling for built-in agents that don't exist
- * 4. Writes updated config back to ~/.config/opencode/opencode.json
- *
- * @param $ - Bun shell instance
- */
-export declare function updateAgentConfig($: BunShell): Promise<void>;
-export {};

package/dist/agent-config.js

@@ -1,15 +1,17 @@
-import { isRecord, updateGlobalOpenCodeConfigBlock } from './opencode-global-config.js';
 /**
  * Built-in opencode agents that should be disabled when the Feature Factory
  * plugin is active. These are the standard opencode agents that overlap with
- * the plugin's own agents (planning, building, reviewing).
+ * the plugin's own agents (planning, building, code-review, full-review) or should be routed
+ * through Feature Factory stage agents instead.
  *
- * Note: This only disables the built-in `build` and `plan` agents.
- * The plugin's own agents (planning, building, reviewing) remain active.
+ * Note: This disables built-in `build`, `plan`, `explore`, and `general` agents.
+ * The plugin's own agents (planning, building, code-review, full-review) remain active.
  */
 export const DEFAULT_DISABLED_AGENTS = {
     build: { disable: true },
     plan: { disable: true },
+    explore: { disable: true },
+    general: { disable: true },
 };
 /**
  * Merge agent configs, preserving existing settings and adding new ones.
@@ -26,32 +28,3 @@ export function mergeAgentConfigs(existing, defaults) {
     }
     return result;
 }
-/**
- * Update the agent configuration in global opencode.json.
- *
- * This function:
- * 1. Reads existing config from ~/.config/opencode/opencode.json
- * 2. Preserves existing agent settings
- * 3. Adds default agent disabling for built-in agents that don't exist
- * 4. Writes updated config back to ~/.config/opencode/opencode.json
- *
- * @param $ - Bun shell instance
- */
-export async function updateAgentConfig($) {
-    void $;
-    await updateGlobalOpenCodeConfigBlock({
-        blockName: 'agent',
-        warningLabel: 'agent config',
-        update: (existingBlock) => {
-            const existingAgentConfigs = isRecord(existingBlock)
-                ? existingBlock
-                : undefined;
-            const updatedAgentConfigs = mergeAgentConfigs(existingAgentConfigs, DEFAULT_DISABLED_AGENTS);
-            const hasChanges = Object.keys(DEFAULT_DISABLED_AGENTS).some((agentName) => !existingAgentConfigs?.[agentName]);
-            return {
-                nextBlock: updatedAgentConfigs,
-                changed: hasChanges,
-            };
-        },
-    });
-}

package/dist/index.js

@@ -1,9 +1,5 @@
 import { StopQualityGateHooksPlugin } from './stop-quality-gate.js';
 import { RecommendedNextStepHooksPlugin } from './auto-handoff.js';
-import { updateMCPConfig } from './mcp-config.js';
-import { updateAgentConfig } from './agent-config.js';
-import { updatePluginConfig } from './plugin-config.js';
-import { $ } from 'bun';
 function composeAsyncHandlers(...handlers) {
     const activeHandlers = handlers.filter((handler) => Boolean(handler));
     if (activeHandlers.length === 0) {
@@ -27,31 +23,6 @@ export const FeatureFactoryPlugin = async (input) => {
     if (!directory || directory === '' || directory === '/') {
         return {};
     }
-    // Update MCP server configuration in global OpenCode config
-    // This ensures Feature Factory MCP servers are available across projects
-    try {
-        await updateMCPConfig($);
-    }
-    catch {
-        // Just log or ignore errors during config update to not break plugin load
-        console.error('Failed to update MCP config in OpenCode plugin');
-    }
-    // Update agent configuration in global OpenCode config
-    // This disables built-in agents that overlap with Feature Factory agents
-    try {
-        await updateAgentConfig($);
-    }
-    catch {
-        console.error('Failed to update agent config in OpenCode plugin');
-    }
-    // Update plugin list in global OpenCode config
-    // This ensures required companion plugins are present
-    try {
-        await updatePluginConfig($);
-    }
-    catch {
-        console.error('Failed to update plugin config in OpenCode plugin');
-    }
     // Load hooks from the quality gate plugin
     const qualityGateHooks = await StopQualityGateHooksPlugin(input).catch(() => ({}));
     const autoHandoffHooks = await RecommendedNextStepHooksPlugin(input).catch(() => ({}));

package/dist/mcp-config.d.ts

@@ -1,4 +1,3 @@
-type BunShell = any;
 /**
  * Default MCP server configuration to be added by the plugin
  * These servers will be merged into the global OpenCode config.
@@ -36,16 +35,3 @@ export interface MCPServers {
  * Existing servers take precedence (we never overwrite them).
  */
 export declare function mergeMCPServers(existing: MCPServers | undefined, defaults: typeof DEFAULT_MCP_SERVERS): MCPServers;
-/**
- * Update the MCP servers configuration in global opencode.json.
- *
- * This function:
- * 1. Reads existing config from ~/.config/opencode/opencode.json
- * 2. Preserves existing MCP servers
- * 3. Adds default Feature Factory MCP servers that don't exist
- * 4. Writes updated config back to ~/.config/opencode/opencode.json
- *
- * @param $ - Bun shell instance
- */
-export declare function updateMCPConfig($: BunShell): Promise<void>;
-export {};

package/dist/mcp-config.js

@@ -1,4 +1,3 @@
-import { isRecord, updateGlobalOpenCodeConfigBlock } from './opencode-global-config.js';
 /**
  * Default MCP server configuration to be added by the plugin
  * These servers will be merged into the global OpenCode config.
@@ -35,32 +34,3 @@ export function mergeMCPServers(existing, defaults) {
     }
     return result;
 }
-/**
- * Update the MCP servers configuration in global opencode.json.
- *
- * This function:
- * 1. Reads existing config from ~/.config/opencode/opencode.json
- * 2. Preserves existing MCP servers
- * 3. Adds default Feature Factory MCP servers that don't exist
- * 4. Writes updated config back to ~/.config/opencode/opencode.json
- *
- * @param $ - Bun shell instance
- */
-export async function updateMCPConfig($) {
-    void $;
-    await updateGlobalOpenCodeConfigBlock({
-        blockName: 'mcp',
-        warningLabel: 'MCP config',
-        update: (existingBlock) => {
-            const existingMcpServers = isRecord(existingBlock)
-                ? existingBlock
-                : undefined;
-            const updatedMcpServers = mergeMCPServers(existingMcpServers, DEFAULT_MCP_SERVERS);
-            const hasChanges = Object.keys(DEFAULT_MCP_SERVERS).some((serverName) => !existingMcpServers?.[serverName]);
-            return {
-                nextBlock: updatedMcpServers,
-                changed: hasChanges,
-            };
-        },
-    });
-}

package/dist/plugin-config.d.ts

@@ -1,4 +1,3 @@
-type BunShell = any;
 /**
  * Default plugins that should be present in the global OpenCode config.
  * These will be merged into the existing plugin array without removing
@@ -33,17 +32,3 @@ export declare function hasPlugin(existing: string[], plugin: string): boolean;
  * being added.
  */
 export declare function mergePlugins(existing: string[] | undefined, defaults: readonly string[]): string[];
-/**
- * Update the plugin list in global opencode.json.
- *
- * This function:
- * 1. Reads existing config from ~/.config/opencode/opencode.json
- * 2. Preserves all existing plugins in the array
- * 3. Appends default Feature Factory plugins that aren't already present
- *    (matched by base package name, so pinned versions are respected)
- * 4. Writes updated config back to ~/.config/opencode/opencode.json
- *
- * @param $ - Bun shell instance
- */
-export declare function updatePluginConfig($: BunShell): Promise<void>;
-export {};

package/dist/plugin-config.js

@@ -1,4 +1,3 @@
-import { updateGlobalOpenCodeConfigBlock } from './opencode-global-config.js';
 /**
  * Default plugins that should be present in the global OpenCode config.
  * These will be merged into the existing plugin array without removing
@@ -69,33 +68,3 @@ export function mergePlugins(existing, defaults) {
     }
     return result;
 }
-/**
- * Update the plugin list in global opencode.json.
- *
- * This function:
- * 1. Reads existing config from ~/.config/opencode/opencode.json
- * 2. Preserves all existing plugins in the array
- * 3. Appends default Feature Factory plugins that aren't already present
- *    (matched by base package name, so pinned versions are respected)
- * 4. Writes updated config back to ~/.config/opencode/opencode.json
- *
- * @param $ - Bun shell instance
- */
-export async function updatePluginConfig($) {
-    void $;
-    await updateGlobalOpenCodeConfigBlock({
-        blockName: 'plugin',
-        warningLabel: 'plugin config',
-        update: (existingBlock) => {
-            const existingPlugins = Array.isArray(existingBlock)
-                ? existingBlock.filter((entry) => typeof entry === 'string')
-                : undefined;
-            const existingArray = existingPlugins ?? [];
-            const hasChanges = DEFAULT_PLUGINS.some((plugin) => !hasPlugin(existingArray, plugin));
-            return {
-                nextBlock: mergePlugins(existingPlugins, DEFAULT_PLUGINS),
-                changed: hasChanges,
-            };
-        },
-    });
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
   "name": "@syntesseraai/opencode-feature-factory",
-  "version": "0.12.10",
+  "version": "0.13.0",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",

package/skills/ff-reviewing-architecture/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ff-reviewing-architecture
-description: Architecture validation checklist for @reviewing using Well-Architected principles.
+description: Architecture validation checklist for review agents using Well-Architected principles.
 license: MIT
 compatibility: opencode
 metadata:
@@ -10,7 +10,7 @@ metadata:
 
 # Reviewing Architecture Skill
 
-Use this skill when `@reviewing` evaluates architectural quality and system-level trade-offs.
+Use this skill when `@code-review` or `@full-review` evaluates architectural quality and system-level trade-offs.
 
 ## Focus Areas
 

package/skills/ff-reviewing-code-quality/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ff-reviewing-code-quality
-description: Code-quality review checklist for @reviewing. Use for correctness, maintainability, and test coverage validation.
+description: Code-quality review checklist for review agents. Use for correctness, maintainability, and test coverage validation.
 license: MIT
 compatibility: opencode
 metadata:
@@ -10,7 +10,7 @@ metadata:
 
 # Reviewing Code Quality Skill
 
-Use this skill when `@reviewing` is validating implementation quality.
+Use this skill when `@code-review` or `@full-review` is validating implementation quality.
 
 ## Focus Areas
 

package/skills/ff-reviewing-documentation/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ff-reviewing-documentation
-description: Documentation validation checklist for @reviewing. Use for accuracy, completeness, and repository consistency checks.
+description: Documentation validation checklist for full-review agents. Use for accuracy, completeness, and repository consistency checks.
 license: MIT
 compatibility: opencode
 metadata:
@@ -10,7 +10,7 @@ metadata:
 
 # Reviewing Documentation Skill
 
-Use this skill when `@reviewing` validates documentation-stage outputs.
+Use this skill when `@full-review` validates documentation-stage outputs.
 
 ## Focus Areas
 

package/skills/ff-reviewing-security/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: ff-reviewing-security
-description: Security validation checklist for @reviewing. Use for auth, input handling, secret safety, and abuse-path review.
+description: Security validation checklist for review agents. Use for auth, input handling, secret safety, and abuse-path review.
 license: MIT
 compatibility: opencode
 metadata:
@@ -10,7 +10,7 @@ metadata:
 
 # Reviewing Security Skill
 
-Use this skill when `@reviewing` performs security-focused validation.
+Use this skill when `@code-review` or `@full-review` performs security-focused validation.
 
 ## Focus Areas
 

package/dist/opencode-global-config.d.ts

@@ -1,9 +0,0 @@
-export declare function isRecord(value: unknown): value is Record<string, unknown>;
-export declare function updateGlobalOpenCodeConfigBlock<T>(options: {
-    blockName: string;
-    warningLabel: string;
-    update: (existingBlock: unknown) => {
-        nextBlock: T;
-        changed: boolean;
-    };
-}): Promise<void>;

package/dist/opencode-global-config.js

@@ -1,79 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-const GLOBAL_OPENCODE_DIR = join(homedir(), '.config', 'opencode');
-const GLOBAL_OPENCODE_CONFIG_PATH = join(GLOBAL_OPENCODE_DIR, 'opencode.json');
-export function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-async function loadGlobalOpenCodeConfig() {
-    try {
-        const configContent = await readFile(GLOBAL_OPENCODE_CONFIG_PATH, 'utf8');
-        const parsed = JSON.parse(configContent);
-        if (!isRecord(parsed)) {
-            return {
-                config: {},
-                hasExistingFile: true,
-                parseError: true,
-            };
-        }
-        return {
-            config: parsed,
-            hasExistingFile: true,
-            parseError: false,
-        };
-    }
-    catch (error) {
-        if (typeof error === 'object' &&
-            error !== null &&
-            'code' in error &&
-            error.code === 'ENOENT') {
-            return {
-                config: {},
-                hasExistingFile: false,
-                parseError: false,
-            };
-        }
-        if (error instanceof SyntaxError) {
-            return {
-                config: {},
-                hasExistingFile: true,
-                parseError: true,
-            };
-        }
-        throw error;
-    }
-}
-export async function updateGlobalOpenCodeConfigBlock(options) {
-    const { blockName, warningLabel, update } = options;
-    const loaded = await loadGlobalOpenCodeConfig();
-    if (loaded.parseError) {
-        console.warn(`[feature-factory] Could not update ${warningLabel}: existing opencode.json is not valid JSON`);
-        return;
-    }
-    const { nextBlock, changed } = update(loaded.config[blockName]);
-    if (!changed) {
-        return;
-    }
-    const updatedConfig = {
-        ...loaded.config,
-        [blockName]: nextBlock,
-    };
-    await mkdir(GLOBAL_OPENCODE_DIR, { recursive: true });
-    if (loaded.hasExistingFile && Object.keys(loaded.config).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            await writeFile(backupPath, JSON.stringify(loaded.config, null, 2));
-        }
-        catch (error) {
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    try {
-        await writeFile(GLOBAL_OPENCODE_CONFIG_PATH, JSON.stringify(updatedConfig, null, 2));
-    }
-    catch (error) {
-        console.warn(`[feature-factory] Could not update ${warningLabel}:`, error);
-    }
-}