@syntesseraai/opencode-feature-factory 0.6.6 → 0.6.8

package/README.md

@@ -46,6 +46,7 @@ It also updates `~/.config/opencode/opencode.json` non-destructively by merging
 - `/pipeline/planning/run`, `/pipeline/planning/run-opus`, `/pipeline/planning/run-gemini`, `/pipeline/planning/run-codex`, `/pipeline/planning/synthesize`, `/pipeline/planning/gate`
 - `/pipeline/building/run`, `/pipeline/building/breakdown`, `/pipeline/building/validate-batch`, `/pipeline/building/implement-batch`
 - `/pipeline/reviewing/run`, `/pipeline/reviewing/triage`, `/pipeline/reviewing/run-opus`, `/pipeline/reviewing/run-gemini`, `/pipeline/reviewing/run-codex`, `/pipeline/reviewing/synthesize`, `/pipeline/reviewing/gate`
+- `/pipeline/documentation/run`, `/pipeline/documentation/run-codex`, `/pipeline/documentation/run-gemini`, `/pipeline/documentation/gate`
 - `/pipeline/complete`
 
 ## Model Split
@@ -55,11 +56,14 @@ It also updates `~/.config/opencode/opencode.json` non-destructively by merging
 - Implementation: Codex only
 - Review (with architecture validation): Codex, Gemini, and Opus
 - Rework path: `/pipeline/reviewing/run` re-enters implementation via `/pipeline/building/implement-batch` when gate status is `REWORK`
+- Documentation stage: Codex updates documentation, Gemini reviews docs, and ChatGPT 5.4 supervises a bounded loop until approved
+- Documentation stage skill usage: Codex loads `ff-context-tracking`, `ff-todo-management`, `ff-mini-plan`; Gemini loads `ff-report-templates` and `ff-severity-classification`
 
 ## Quality Gates
 
 - Planning approval: `>=75%` consensus.
 - Review approval: `>=95%` confidence and zero unresolved issues.
+- Documentation approval: Gemini verdict `APPROVED` with zero unresolved documentation issues.
 - Planning loop confirmation: after 5 unsuccessful planning iterations, pipeline asks user whether to continue.
 
 ## Related Docs

package/agents/pipeline.md

@@ -51,6 +51,7 @@ Do not keep orchestration logic in this file. The workflow lives in:
 - `/pipeline/planning/*`
 - `/pipeline/building/*`
 - `/pipeline/reviewing/*`
+- `/pipeline/documentation/*`
 - `/pipeline/complete`
 
 ## Required Intake Flow
@@ -76,6 +77,7 @@ When confirmed, execute:
 - Enforce quality gates from command files:
   - Planning approval: `>=75%` consensus.
   - Review approval: `>=95%` confidence and zero unresolved issues.
+  - Documentation approval: Gemini must return `APPROVED` with zero unresolved documentation issues.
 
 ## Progress Updates
 
@@ -92,4 +94,5 @@ When `/pipeline/complete` finishes, return a concise execution summary with:
 - accepted plan
 - implemented task groups
 - review outcomes
+- documentation outcomes
 - assumptions made

package/bin/ff-deploy.js

@@ -51,6 +51,40 @@ const DEFAULT_MCP_SERVERS = {
   },
 };
 
+const DEFAULT_PLUGINS = [
+  '@syntesseraai/opencode-feature-factory@latest',
+  '@nick-vi/opencode-type-inject@latest',
+  '@franlol/opencode-md-table-formatter@latest',
+  '@spoons-and-mirrors/subtask2@latest',
+  'opencode-pty@latest',
+  '@angdrew/opencode-hashline-plugin@latest',
+];
+
+function getPackageBaseName(plugin) {
+  if (plugin.startsWith('@')) {
+    const slashIndex = plugin.indexOf('/');
+    if (slashIndex !== -1) {
+      const versionAt = plugin.indexOf('@', slashIndex + 1);
+      if (versionAt !== -1) {
+        return plugin.substring(0, versionAt);
+      }
+    }
+    return plugin;
+  }
+
+  const atIndex = plugin.indexOf('@');
+  if (atIndex !== -1) {
+    return plugin.substring(0, atIndex);
+  }
+
+  return plugin;
+}
+
+function hasPlugin(existing, plugin) {
+  const baseName = getPackageBaseName(plugin);
+  return existing.some((entry) => getPackageBaseName(entry) === baseName);
+}
+
 async function ensureDir(dir) {
   try {
     await fs.mkdir(dir, { recursive: true });
@@ -127,11 +161,30 @@ async function updateMCPConfig() {
   try {
     // Read existing config if it exists
     let existingConfig = {};
+    let hasExistingConfigFile = false;
     try {
       const configContent = await fs.readFile(GLOBAL_CONFIG_FILE, 'utf8');
+      hasExistingConfigFile = true;
       existingConfig = JSON.parse(configContent);
-    } catch {
-      // No existing config, will create new
+      if (!existingConfig || typeof existingConfig !== 'object' || Array.isArray(existingConfig)) {
+        if (isInteractive) {
+          console.warn('\n⚠️  Existing opencode.json is not a JSON object. Skipping update.');
+        }
+        return;
+      }
+    } catch (error) {
+      if (error && error.code === 'ENOENT') {
+        // No existing config, will create new
+      } else if (error instanceof SyntaxError) {
+        if (isInteractive) {
+          console.warn(
+            '\n⚠️  Existing opencode.json is invalid JSON. Skipping update to avoid overwriting user config.'
+          );
+        }
+        return;
+      } else {
+        throw error;
+      }
     }
 
     // Check which MCP servers need to be added
@@ -157,15 +210,33 @@ async function updateMCPConfig() {
       }
     }
 
-    if (serversAdded === 0) {
+    const existingPlugins = Array.isArray(existingConfig.plugin)
+      ? existingConfig.plugin.filter((entry) => typeof entry === 'string')
+      : [];
+    const pluginsToAdd = [];
+
+    for (const plugin of DEFAULT_PLUGINS) {
+      if (hasPlugin(existingPlugins, plugin)) {
+        if (isInteractive) {
+          console.log(`  ⏭️  ${plugin}: already exists, skipping`);
+        }
+      } else {
+        pluginsToAdd.push(plugin);
+        if (isInteractive) {
+          console.log(`  ✅ ${plugin}: will be added`);
+        }
+      }
+    }
+
+    if (serversAdded === 0 && pluginsToAdd.length === 0) {
       if (isInteractive) {
-        console.log('\n✅ All MCP servers already configured. No changes needed.');
+        console.log('\n✅ Required MCP servers and plugins already configured. No changes needed.');
       }
       return;
     }
 
     // Backup existing config if it exists
-    if (existingConfig && Object.keys(existingConfig).length > 0) {
+    if (hasExistingConfigFile && existingConfig && Object.keys(existingConfig).length > 0) {
       const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
       const backupFile = `${GLOBAL_CONFIG_FILE}.backup.${timestamp}`;
       await fs.writeFile(backupFile, JSON.stringify(existingConfig, null, 2));
@@ -181,6 +252,7 @@ async function updateMCPConfig() {
         ...existingMcp,
         ...serversToAdd,
       },
+      plugin: [...existingPlugins, ...pluginsToAdd],
     };
 
     // Write updated config
@@ -188,11 +260,13 @@ async function updateMCPConfig() {
     await fs.writeFile(GLOBAL_CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
 
     if (isInteractive) {
-      console.log(`\n✅ Added ${serversAdded} MCP server(s) to: ${GLOBAL_CONFIG_FILE}`);
+      console.log(`\n✅ Updated OpenCode config: ${GLOBAL_CONFIG_FILE}`);
+      console.log(`   Added ${serversAdded} MCP server(s)`);
+      console.log(`   Added ${pluginsToAdd.length} plugin(s)`);
       if (serversSkipped > 0) {
         console.log(`   Skipped ${serversSkipped} existing server(s)`);
       }
-      console.log('\n📝 Note: Restart OpenCode to load new MCP configuration');
+      console.log('\n📝 Note: Restart OpenCode to load new configuration');
     }
   } catch (error) {
     if (isInteractive) {

package/commands/pipeline/documentation/gate.md

@@ -0,0 +1,19 @@
+---
+description: Apply documentation approval gate
+subtask: true
+model: openai/gpt-5.4
+---
+
+Read the latest Gemini documentation review and apply gate exactly:
+
+Skill requirements:
+
+- ChatGPT gate supervisor must load `ff-context-tracking` before persisting gate decisions.
+
+- APPROVED when verdict is `APPROVED` and unresolved documentation issues count is `0`
+- REWORK when verdict is `REWORK_REQUIRED` and iteration < 5
+- ESCALATE when iteration == 5 and still not approved
+
+Persist gate decision in pipeline context and output one status line:
+
+`DOCUMENTATION_GATE=APPROVED|REWORK|ESCALATE`

package/commands/pipeline/documentation/run-codex.md

@@ -0,0 +1,23 @@
+---
+description: Codex documentation implementation pass
+subtask: true
+agent: ff-building-codex
+model: openai/gpt-5.3-codex
+---
+
+Document the approved code changes and update repository documentation.
+
+Before writing docs, load these skills:
+
+- `ff-context-tracking`
+- `ff-todo-management`
+- `ff-mini-plan`
+
+Requirements:
+
+1. Use the latest approved review outputs and implementation artifacts as source of truth.
+2. Update all affected docs so behavior and operational steps match shipped code.
+3. If this is a rework iteration, incorporate Gemini feedback from the previous documentation review.
+4. Summarize what docs were changed and why.
+
+Persist to `.feature-factory/agents/ff-documentation-codex-{UUID}-T{N}-iter{I}.md`.

package/commands/pipeline/documentation/run-gemini.md

@@ -0,0 +1,21 @@
+---
+description: Gemini documentation review
+subtask: true
+agent: ff-reviewing-gemini
+---
+
+Review the latest Codex documentation pass for completeness, correctness, and repository doc consistency.
+
+Before reviewing docs, load these skills:
+
+- `ff-report-templates`
+- `ff-severity-classification`
+
+Required output:
+
+1. verdict `APPROVED` or `REWORK_REQUIRED`
+2. unresolved documentation issues (if any)
+3. explicit rework instructions
+4. confidence score (0-100)
+
+Persist to `.feature-factory/agents/ff-documentation-gemini-{UUID}-T{N}-iter{I}.md`.

package/commands/pipeline/documentation/run.md

@@ -0,0 +1,27 @@
+---
+description: Run documentation loop after review approval
+subtask: true
+model: openai/gpt-5.4
+loop:
+  max: 5
+  until: documentation updates are approved by Gemini with zero unresolved documentation issues
+return:
+  - /pipeline/documentation/run-codex
+  - /pipeline/documentation/run-gemini
+  - /pipeline/documentation/gate
+  - If `DOCUMENTATION_GATE=REWORK`, continue loop with Gemini feedback for the next Codex pass.
+---
+
+Execute the documentation stage for the current approved implementation.
+
+Skill requirements:
+
+1. ChatGPT supervisor must load `ff-context-tracking` to track loop state and artifact lineage.
+2. ChatGPT supervisor must load `ff-todo-management` to track documentation actions and rework items per iteration.
+3. Gemini reviewer should use `ff-severity-classification` when reporting documentation issues.
+
+Stop criteria:
+
+- approve when Gemini confirms documentation is complete, accurate, and repository docs are updated
+- continue loop while unresolved documentation issues exist and iteration < 5
+- escalate to user when iteration reaches 5 without approval

package/commands/pipeline/start.md

@@ -6,6 +6,7 @@ return:
   - /pipeline/planning/run {loop:5 && until:planning gate is APPROVED or planning gate is BLOCKED and waiting for user confirmation}
   - If planning is BLOCKED or loop max was reached, stop and ask the user whether to continue planning iterations. Otherwise continue.
   - /pipeline/building/run
+  - /pipeline/documentation/run
   - /pipeline/complete
 ---
 
@@ -18,4 +19,4 @@ Execution requirements:
 1. Create a pipeline UUID and persist orchestrator state in `.feature-factory/agents/pipeline-{UUID}.md` via `ff-agents-update`.
 2. Keep all phase artifacts in `.feature-factory/plans/` and `.feature-factory/reviews/`.
 3. Use command chaining, parallel fan-out, and loop gates from the `/pipeline/...` command tree.
-4. Do not skip planning and review gates.
+4. Do not skip planning, review, and documentation gates.

package/dist/agent-config.js

@@ -1,8 +1,4 @@
-import { readJsonFile } from './quality-gate-config.js';
-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');
+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
@@ -42,50 +38,20 @@ export function mergeAgentConfigs(existing, defaults) {
  * @param $ - Bun shell instance
  */
 export async function updateAgentConfig($) {
-    // Read existing global config
-    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
-    // Get existing agent configs from global config
-    const existingAgentConfigs = (globalJson?.agent ?? {});
-    // Merge with default agent configs
-    const updatedAgentConfigs = mergeAgentConfigs(existingAgentConfigs, DEFAULT_DISABLED_AGENTS);
-    // Check if any changes are needed
-    const hasChanges = Object.keys(DEFAULT_DISABLED_AGENTS).some((agentName) => !existingAgentConfigs[agentName]);
-    if (!hasChanges) {
-        // All default agent configs already exist, no need to update
-        return;
-    }
-    // Prepare updated global config
-    const updatedGlobalConfig = {
-        ...(globalJson ?? {}),
-        agent: updatedAgentConfigs,
-    };
-    // Ensure global config directory exists
-    try {
-        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
-    }
-    catch {
-        // Directory might already exist, ignore
-    }
-    // Backup existing global config if it exists and has content
-    if (globalJson && Object.keys(globalJson).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(globalJson, null, 2);
-            await $ `echo ${backupContent} > ${backupPath}`.quiet();
-        }
-        catch (error) {
-            // Backup failed, but continue anyway
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    // Write updated config to global opencode.json
-    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
-    try {
-        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
-    }
-    catch (error) {
-        // Silently fail - don't block if we can't write the config
-        console.warn('[feature-factory] Could not update agent config:', error);
-    }
+    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/mcp-config.js

@@ -1,8 +1,4 @@
-import { readJsonFile } from './quality-gate-config.js';
-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');
+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.
@@ -54,50 +50,20 @@ export function mergeMCPServers(existing, defaults) {
  * @param $ - Bun shell instance
  */
 export async function updateMCPConfig($) {
-    // Read existing global config
-    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
-    // Get existing MCP servers from global config
-    const existingMcpServers = (globalJson?.mcp ?? {});
-    // Merge with default MCP servers
-    const updatedMcpServers = mergeMCPServers(existingMcpServers, DEFAULT_MCP_SERVERS);
-    // Check if any changes are needed
-    const hasChanges = Object.keys(DEFAULT_MCP_SERVERS).some((serverName) => !existingMcpServers[serverName]);
-    if (!hasChanges) {
-        // All default servers already exist, no need to update
-        return;
-    }
-    // Prepare updated global config
-    const updatedGlobalConfig = {
-        ...(globalJson ?? {}),
-        mcp: updatedMcpServers,
-    };
-    // Ensure global config directory exists
-    try {
-        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
-    }
-    catch {
-        // Directory might already exist, ignore
-    }
-    // Backup existing global config if it exists and has content
-    if (globalJson && Object.keys(globalJson).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(globalJson, null, 2);
-            await $ `echo ${backupContent} > ${backupPath}`.quiet();
-        }
-        catch (error) {
-            // Backup failed, but continue anyway
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    // Write updated config to global opencode.json
-    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
-    try {
-        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
-    }
-    catch (error) {
-        // Silently fail - don't block if we can't write the config
-        console.warn('[feature-factory] Could not update MCP config:', error);
-    }
+    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/opencode-global-config.d.ts

@@ -0,0 +1,9 @@
+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

@@ -0,0 +1,79 @@
+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);
+    }
+}

package/dist/plugin-config.js

@@ -1,8 +1,4 @@
-import { readJsonFile } from './quality-gate-config.js';
-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');
+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
@@ -88,53 +84,20 @@ export function mergePlugins(existing, defaults) {
  * @param $ - Bun shell instance
  */
 export async function updatePluginConfig($) {
-    // Read existing global config
-    const globalJson = await readJsonFile($, GLOBAL_OPENCODE_CONFIG_PATH);
-    // Get existing plugins from global config
-    const existingPlugins = Array.isArray(globalJson?.plugin)
-        ? globalJson.plugin
-        : undefined;
-    // Check if any changes are needed (by base name)
-    const existingArray = existingPlugins ?? [];
-    const hasChanges = DEFAULT_PLUGINS.some((plugin) => !hasPlugin(existingArray, plugin));
-    if (!hasChanges) {
-        // All default plugins already present (possibly with pinned versions)
-        return;
-    }
-    // Merge with default plugins
-    const updatedPlugins = mergePlugins(existingPlugins, DEFAULT_PLUGINS);
-    // Prepare updated global config
-    const updatedGlobalConfig = {
-        ...(globalJson ?? {}),
-        plugin: updatedPlugins,
-    };
-    // Ensure global config directory exists
-    try {
-        await $ `mkdir -p ${GLOBAL_OPENCODE_DIR}`.quiet();
-    }
-    catch {
-        // Directory might already exist, ignore
-    }
-    // Backup existing global config if it exists and has content
-    if (globalJson && Object.keys(globalJson).length > 0) {
-        try {
-            const timestamp = new Date().toISOString().split('T')[0].replace(/-/g, '');
-            const backupPath = `${GLOBAL_OPENCODE_CONFIG_PATH}.backup.${timestamp}`;
-            const backupContent = JSON.stringify(globalJson, null, 2);
-            await $ `echo ${backupContent} > ${backupPath}`.quiet();
-        }
-        catch (error) {
-            // Backup failed, but continue anyway
-            console.warn('[feature-factory] Could not create backup:', error);
-        }
-    }
-    // Write updated config to global opencode.json
-    const configContent = JSON.stringify(updatedGlobalConfig, null, 2);
-    try {
-        await $ `echo ${configContent} > ${GLOBAL_OPENCODE_CONFIG_PATH}`.quiet();
-    }
-    catch (error) {
-        // Silently fail - don't block if we can't write the config
-        console.warn('[feature-factory] Could not update plugin config:', error);
-    }
+    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.6.6",
+  "version": "0.6.8",
   "type": "module",
   "description": "OpenCode plugin for Feature Factory agents - provides sub-agents and skills for validation, review, security, and architecture assessment",
   "license": "MIT",