arkgate 3.8.3 → 3.9.0

package/bin/lib/install-migrate.mjs

@@ -21,11 +21,15 @@ import {
 } from './codex-home.mjs';
 import {
   PREFERRED_MCP_BIN,
+  antigravityHooks,
   claudeSettings,
   codexHooks,
   codexProjectConfig,
   grokHooks,
   grokProjectConfig,
+  mergeAntigravityArkHook,
+  mergeOpencodeArkMcp,
+  opencodeProjectConfig,
 } from './hook-templates.mjs';
 import {
   hasCheckArchitectureScript,
@@ -60,6 +64,7 @@ import {
 import { detectDeployPathQuality } from './deploy-path.mjs';
 import {
   stripMcpServerArgs,
+  stripOpencodeMcpCommand,
   COMMAND_GATE_TEXT_FILES,
   COMMAND_GATE_JSON_FILES,
   PREFERRED_CHECK_BIN,
@@ -175,6 +180,14 @@ export function buildManagedAssetCatalog({ root, tools, compact = false, skillsO
       add('.grok/config.toml', grokProjectConfig(root));
       add('.grok/hooks/ark-write-gate.json', grokHooks(root));
     }
+    if (selectedTools.has('antigravity')) {
+      add('.agents/hooks.json', antigravityHooks(root));
+      // Still useful for Gemini CLI / legacy Gemini consumers sharing the tree.
+      add('GEMINI.md', instructionRule(root));
+    }
+    if (selectedTools.has('opencode')) {
+      add('opencode.json', opencodeProjectConfig(root), 'gate', 'json-merge');
+    }
     if (selectedTools.has('windsurf')) add('.windsurf/rules/ark.md', instructionRule(root));
     if (selectedTools.has('cline')) add('.clinerules/ark.md', instructionRule(root));
     if (selectedTools.has('copilot')) {
@@ -238,6 +251,27 @@ export function runMigrateCommands(root) {
     } catch {
       continue;
     }
+    // OpenCode: mcp.ark.command is a single argv array (type: local), not mcpServers.ark.args.
+    if (rel === 'opencode.json') {
+      const ark = json?.mcp?.ark;
+      if (!ark || typeof ark !== 'object' || !Array.isArray(ark.command)) continue;
+      const argv = ark.command.filter((entry) => typeof entry === 'string');
+      if (argv.length === 0) continue;
+      // Drop runners + any ark* bin names; keep only server flags (e.g. --root .).
+      const binArgs = stripOpencodeMcpCommand(argv);
+      const parts = execCommandParts(root, PREFERRED_MCP_BIN, binArgs);
+      const preferredArgv = [parts.command, ...parts.args];
+      if (JSON.stringify(argv) === JSON.stringify(preferredArgv)) continue;
+      json.mcp.ark = {
+        ...ark,
+        type: ark.type ?? 'local',
+        command: preferredArgv,
+        enabled: ark.enabled !== false,
+      };
+      fs.writeFileSync(full, `${JSON.stringify(json, null, 2)}\n`);
+      changed.push(rel);
+      continue;
+    }
     const ark = json?.mcpServers?.ark;
     if (!ark) continue;
     const binArgs = stripMcpServerArgs(ark.args);
@@ -316,6 +350,14 @@ export function runInstallAgentGates(args) {
           ? 'no active host detected'
         : 'default set — no agent config dirs found';
   console.log(`Agent gates for: ${[...tools].sort().join(', ')} (${toolSource})`);
+  // Progressive disclosure (3.9.0): compact = router; skills-only = expert pack.
+  if (!args.json) {
+    const host = [...tools][0];
+    const later = host ? ` --tools ${host}` : '';
+    if (args.compact) console.log(`Profile: compact router. Expert skills later: ${arkCommand(root, 'ark-check', `--install-agent-gates --skills-only${later} --force`)}`);
+    else if (args.skillsOnly) console.log('Profile: expert skill pack only (refreshes /ark-*; leaves customized gates).');
+    else console.log('Profile: full agent gates. Compact-only onboarding: ark start.');
+  }
   // --skills-only refreshes just the canonical /ark-* skills, which are safe to
   // overwrite (they track the package). The gate/instruction files (AGENTS.md,
   // settings.json, CI workflow, rules) are the ones users customize, so a plain
@@ -367,6 +409,43 @@ export function runInstallAgentGates(args) {
       if (merged === existing) return { relativePath, status: 'skipped' };
       return writeTemplate(root, relativePath, merged, true);
     }
+    if (relativePath === 'opencode.json') {
+      const fullPath = path.join(root, relativePath);
+      let existing = '';
+      try {
+        existing = fs.readFileSync(fullPath, 'utf8');
+      } catch {
+        // Missing project config → write the generated Ark MCP block.
+      }
+      if (!existing) {
+        return writeTemplate(root, relativePath, content, true);
+      }
+      const merged = mergeOpencodeArkMcp(existing, content);
+      if (merged == null) {
+        return { relativePath, status: 'skipped-non-ark' };
+      }
+      if (merged === existing) return { relativePath, status: 'skipped' };
+      return writeTemplate(root, relativePath, merged, true);
+    }
+    if (relativePath === '.agents/hooks.json') {
+      const fullPath = path.join(root, relativePath);
+      let existing = '';
+      try {
+        existing = fs.readFileSync(fullPath, 'utf8');
+      } catch {
+        // Missing hooks file → write generated ark-write-gate map.
+      }
+      if (!existing) {
+        return writeTemplate(root, relativePath, content, true);
+      }
+      const merged = mergeAntigravityArkHook(existing, content);
+      if (merged == null) {
+        return { relativePath, status: 'skipped-non-ark' };
+      }
+      if (merged === existing) return { relativePath, status: 'skipped' };
+      // Upsert ark-write-gate without requiring --force; never wipe sibling named hooks.
+      return writeTemplate(root, relativePath, merged, true);
+    }
     return writeTemplate(
       root,
       relativePath,
@@ -516,6 +595,19 @@ export function runInstallAgentGates(args) {
     console.log('  3. Add the package.json alias if you want `run check:architecture`:');
     console.log(`     ${checkArchitectureScriptSnippet(root)}`);
   }
+  if (tools.has('antigravity') && !args.compact) {
+    console.log('');
+    console.log('  Antigravity: PreToolUse deny is hard for listed write tools when hooks are trusted.');
+    console.log('    - Install path: `.agents/hooks.json` (+ GEMINI.md for legacy Gemini consumers).');
+    console.log('    - Trust project hooks in the host; pair with required CI --strict-merge.');
+  }
+  if (tools.has('opencode') && !args.compact) {
+    console.log('');
+    console.log('  OpenCode write path (honest):');
+    console.log('    - Local: advisory MCP in opencode.json (optional experimental plugin only).');
+    console.log('    - Hard merge backstop: CI --strict-merge + required status check.');
+    console.log('    - Not equivalent to Claude/Grok/Antigravity PreToolUse hard-write.');
+  }
   if ((tools.has('codex') || args.codexHome)) {
     console.log('');
     if (codexMcp && codexMcp.status !== 'failed') {

package/bin/lib/managed-upgrade.mjs

@@ -110,6 +110,8 @@ const HOST_SIGNALS = {
   cursor: ['.cursor/mcp.json', '.cursor/rules/ark.mdc', '.cursor/commands/ark-upgrade.md'],
   codex: ['.codex/hooks.json', '.codex/config.toml', '.agents/skills/ark-upgrade/SKILL.md'],
   grok: ['.grok/config.toml', '.grok/hooks/ark-write-gate.json', '.grok/skills/ark-upgrade/SKILL.md'],
+  antigravity: ['.agents/hooks.json', '.agents/skills/ark-upgrade/SKILL.md'],
+  opencode: ['opencode.json', '.opencode/skills/ark-upgrade/SKILL.md'],
   windsurf: ['.windsurf/rules/ark.md', '.windsurf/workflows/ark-upgrade.md'],
   cline: ['.clinerules/ark.md', '.clinerules/workflows/ark-upgrade.md'],
   copilot: ['.github/copilot-instructions.md', '.github/prompts/ark-upgrade.prompt.md'],

package/bin/lib/mcp-adoption.mjs

@@ -25,8 +25,9 @@ export const COMMAND_GATE_TEXT_FILES = [
   '.clinerules/ark.md', '.github/copilot-instructions.md', '.kiro/steering/ark.md',
   '.roo/rules/ark.md', '.continue/rules/ark.md', 'GEMINI.md', 'package.json',
   '.grok/hooks/ark-write-gate.json', '.grok/config.toml', '.codex/config.toml',
+  '.agents/hooks.json',
 ];
-export const COMMAND_GATE_JSON_FILES = ['.mcp.json', '.cursor/mcp.json'];
+export const COMMAND_GATE_JSON_FILES = ['.mcp.json', '.cursor/mcp.json', 'opencode.json'];
 // Primary CLI names (product) + one-major aliases. migrate-commands must strip ALL of these
 // before re-emitting a single preferred bin — otherwise a partial rename leaves
 // args: ["ark-mcp", "arkgate-mcp", ...] which breaks stdio MCP hosts.
@@ -61,6 +62,34 @@ export function stripMcpServerArgs(args) {
   return kept.length > 0 ? kept : ['--root', '.', '--config', 'ark.config.json'];
 }
 
+/**
+ * OpenCode `mcp.ark.command` is a full argv (runner + bin + flags).
+ * Strip runners and any ark* bin names so migrate can re-emit preferred command+args.
+ */
+export function stripOpencodeMcpCommand(command) {
+  if (!Array.isArray(command) || command.length === 0) {
+    return ['--root', '.', '--config', 'ark.config.json'];
+  }
+  const runners = new Set(['npx', 'yarn', 'pnpm', 'node', 'bun']);
+  const kept = [];
+  for (const entry of command) {
+    if (typeof entry !== 'string') continue;
+    const base = path.basename(entry.replace(/\\/g, '/'));
+    if (
+      runners.has(base) ||
+      MCP_RUNNER_ARGV.has(entry) ||
+      ARK_MCP_BINS.has(base) ||
+      ARK_MCP_BINS.has(entry) ||
+      ARK_CHECK_BINS.has(base) ||
+      ARK_CLI_BINS.has(base)
+    ) {
+      continue;
+    }
+    kept.push(entry);
+  }
+  return kept.length > 0 ? kept : ['--root', '.', '--config', 'ark.config.json'];
+}
+
 /** True when mcpServers.ark.args list more than one Ark MCP bin (broken dual rename). */
 export function mcpArgsHaveDuplicateBins(args) {
   if (!Array.isArray(args)) return false;
@@ -77,6 +106,12 @@ export function brokenMcpGateFiles(root) {
     } catch {
       continue;
     }
+    // OpenCode uses mcp.ark.command[] (single argv); Claude/Cursor use mcpServers.ark.args.
+    if (rel === 'opencode.json') {
+      const command = json?.mcp?.ark?.command;
+      if (Array.isArray(command) && mcpArgsHaveDuplicateBins(command)) bad.push(rel);
+      continue;
+    }
     const ark = json?.mcpServers?.ark;
     if (ark && mcpArgsHaveDuplicateBins(ark.args)) bad.push(rel);
   }
@@ -159,9 +194,32 @@ export function collectAdoptionGaps(root, config, coverage) {
         ],
         toolsFlag: 'codex',
       },
+      {
+        host: 'antigravity',
+        dir: '.agents',
+        skill: (n) => path.join(root, '.agents', 'skills', n, 'SKILL.md'),
+        extras: [['.agents/hooks.json', 'write-gate hook']],
+        toolsFlag: 'antigravity',
+        // Only when hooks.json is present — `.agents/skills` alone is Codex scope.
+        presentIf: () => fs.existsSync(path.join(root, '.agents', 'hooks.json')),
+      },
+      {
+        host: 'opencode',
+        dir: '.opencode',
+        skill: (n) => path.join(root, '.opencode', 'skills', n, 'SKILL.md'),
+        extras: [['opencode.json', 'project MCP config']],
+        toolsFlag: 'opencode',
+        presentIf: () =>
+          fs.existsSync(path.join(root, 'opencode.json')) ||
+          fs.existsSync(path.join(root, '.opencode')),
+      },
     ];
     for (const h of hostChecks) {
-      if (!fs.existsSync(path.join(root, h.dir))) continue;
+      const present =
+        typeof h.presentIf === 'function'
+          ? h.presentIf()
+          : fs.existsSync(path.join(root, h.dir));
+      if (!present) continue;
       const missingSkills = skillNames.filter((n) => !fs.existsSync(h.skill(n)));
       const missingExtras = h.extras.filter(([rel]) => !fs.existsSync(path.join(root, rel)));
       const complete = missingSkills.length === 0 && missingExtras.length === 0;

package/bin/lib/post-green-path.mjs

@@ -17,11 +17,11 @@ export const POST_GREEN_PRIMARY_SKILL = '/ark-explore';
  * Chained: explore shape-focus then autopilot only to apply B with user OK.
  */
 export const POST_GREEN_PRIMARY_ACTION =
-  'Clarify for AI (Shape): /ark-explore shape-focus → dual-plan B, then /ark-autopilot only to apply B with your OK — never empty plan A = done; patternBets never mechanical-safe';
+  'Shape residual (design-weak): edges are clean, design is not finished. Map with /ark-explore shape-focus → dual-plan B; apply B only via /ark-autopilot with your OK. Empty plan A is not done; pattern bets are never mechanical-safe.';
 
 /** Short label for tables / metrics. */
 export const POST_GREEN_PRIMARY_SHORT =
-  '/ark-explore shape-focus → /ark-autopilot (apply B with OK)  # clarify for AI';
+  '/ark-explore shape-focus → /ark-autopilot (apply B with OK)  # Shape residual';
 
 /**
  * @param {{ designWeak?: boolean } | null | undefined} designFitness

package/bin/lib/skill-install.mjs

@@ -8,18 +8,28 @@ import { arkCommand } from '../ark-shared.mjs';
 import { codexPromptsDir, codexSkillsDir } from './codex-home.mjs';
 import { __packageRoot, isCompactRouterAgentsContent, readJson } from './gate-files.mjs';
 
+/** Alias map so --tools agy installs the antigravity profile. */
+const TOOL_ALIASES = Object.freeze({
+  agy: 'antigravity',
+});
+
+function normalizeToolId(value) {
+  const id = String(value).trim().toLowerCase();
+  return TOOL_ALIASES[id] ?? id;
+}
+
 export function normalizeToolsList(tools) {
   if (tools == null) return [];
   if (Array.isArray(tools)) {
     return tools
       .flatMap((t) => String(t).split(','))
-      .map((t) => t.trim().toLowerCase())
+      .map(normalizeToolId)
       .filter(Boolean);
   }
   if (typeof tools === 'string') {
     return tools
       .split(',')
-      .map((t) => t.trim().toLowerCase())
+      .map(normalizeToolId)
       .filter(Boolean);
   }
   return [];
@@ -77,6 +87,25 @@ export function detectActiveAgentHost(env = process.env) {
   ) {
     return 'codex';
   }
+  // Google Antigravity / agy CLI
+  if (
+    envTruthy(env.ANTIGRAVITY) ||
+    envTruthy(env.AGY) ||
+    env.ANTIGRAVITY_WORKSPACE ||
+    env.AGY_WORKSPACE ||
+    /antigravity/i.test(String(env.TERM_PROGRAM ?? ''))
+  ) {
+    return 'antigravity';
+  }
+  // OpenCode
+  if (
+    envTruthy(env.OPENCODE) ||
+    env.OPENCODE_SESSION_ID ||
+    env.OPENCODE_CONFIG ||
+    envTruthy(env.OPENCODE_CLI)
+  ) {
+    return 'opencode';
+  }
   return null;
 }
 
@@ -101,6 +130,15 @@ export function resolveTools(args) {
   if (fs.existsSync(path.join(root, '.cursor'))) detected.add('cursor');
   if (fs.existsSync(path.join(root, '.codex'))) detected.add('codex');
   if (fs.existsSync(path.join(root, '.grok'))) detected.add('grok');
+  // Antigravity project hooks (distinct from Codex-only `.agents/skills`).
+  if (fs.existsSync(path.join(root, '.agents', 'hooks.json'))) detected.add('antigravity');
+  if (
+    fs.existsSync(path.join(root, 'opencode.json')) ||
+    fs.existsSync(path.join(root, 'opencode.jsonc')) ||
+    fs.existsSync(path.join(root, '.opencode'))
+  ) {
+    detected.add('opencode');
+  }
   if (fs.existsSync(path.join(root, '.windsurf'))) detected.add('windsurf');
   // .clinerules can also be a single FILE (older Cline convention); only a directory
   // can receive .clinerules/ark.md, so a file must not trigger detection.
@@ -136,6 +174,8 @@ export const KNOWN_TOOLS = [
   'cursor',
   'codex',
   'grok',
+  'antigravity',
+  'opencode',
   'windsurf',
   'cline',
   'copilot',
@@ -161,6 +201,10 @@ export const SKILL_TOOL_TARGETS = {
   codex: (name) => `.agents/skills/${name}/SKILL.md`,
   // Grok Build: project skills at .grok/skills/<name>/SKILL.md (slash-invocable).
   grok: (name) => `.grok/skills/${name}/SKILL.md`,
+  // Antigravity loads Agent Skills from `.agents/skills` (shared path with Codex).
+  antigravity: (name) => `.agents/skills/${name}/SKILL.md`,
+  // OpenCode project skills under `.opencode/skills`.
+  opencode: (name) => `.opencode/skills/${name}/SKILL.md`,
   windsurf: (name) => `.windsurf/workflows/${name}.md`,
   cline: (name) => `.clinerules/workflows/${name}.md`,
   copilot: (name) => `.github/prompts/${name}.prompt.md`,

package/bin/lib/start-preview.mjs

@@ -5,7 +5,14 @@ import os from 'node:os';
 import path from 'node:path';
 import { arkCommand, buildArchitectureRecommendation } from '../ark-shared.mjs';
 import { compactAgentInstructions, instructionRule, mcpJson } from './ci-and-commands.mjs';
-import { claudeSettings, codexHooks, grokHooks, grokProjectConfig } from './hook-templates.mjs';
+import {
+  antigravityHooks,
+  claudeSettings,
+  codexHooks,
+  grokHooks,
+  grokProjectConfig,
+  opencodeProjectConfig,
+} from './hook-templates.mjs';
 
 const COMPACT_HOST_TEMPLATES = {
   claude: (root) => [
@@ -16,8 +23,13 @@ const COMPACT_HOST_TEMPLATES = {
     ['.grok/config.toml', grokProjectConfig(root)],
     ['.grok/hooks/ark-write-gate.json', grokHooks(root)],
   ],
+  antigravity: (root) => [
+    ['.agents/hooks.json', antigravityHooks(root)],
+    ['.mcp.json', mcpJson(root)],
+  ],
   cursor: (root) => [['.cursor/mcp.json', mcpJson(root)]],
   codex: (root) => [['.codex/hooks.json', codexHooks(root)]],
+  opencode: (root) => [['opencode.json', opencodeProjectConfig(root)]],
   windsurf: (root) => [['.windsurf/rules/ark.md', instructionRule(root)]],
   cline: (root) => [['.clinerules/ark.md', instructionRule(root)]],
   copilot: (root) => [['.github/copilot-instructions.md', instructionRule(root)]],

package/bin/lib/write-path-capabilities.mjs

@@ -194,9 +194,11 @@ function commandArkMcpInvocation(command) {
 }
 
 function requiredWriteOperations(relativePath) {
-  return relativePath.startsWith('.grok/')
-    ? ['write', 'search_replace']
-    : ['Write', 'Edit', 'MultiEdit'];
+  if (relativePath.startsWith('.grok/')) return ['write', 'search_replace'];
+  if (relativePath === '.agents/hooks.json' || relativePath.startsWith('.agents/')) {
+    return ['write_to_file', 'replace_file_content', 'multi_replace_file_content'];
+  }
+  return ['Write', 'Edit', 'MultiEdit'];
 }
 
 function matcherOperations(relativePath, matcher) {
@@ -248,25 +250,39 @@ function tomlArkMcpIsValid(text) {
   return primary.length === 1 && tomlMcpBlockIsValid(primary[0].block);
 }
 
+function collectPreToolUseGroups(parsed) {
+  // Claude/Grok/Codex: { hooks: { PreToolUse: [...] } }
+  if (Array.isArray(parsed?.hooks?.PreToolUse)) return parsed.hooks.PreToolUse;
+  // Antigravity: { "named-hook": { PreToolUse: [...] }, ... }
+  if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+    const groups = [];
+    for (const value of Object.values(parsed)) {
+      if (value && typeof value === 'object' && Array.isArray(value.PreToolUse)) {
+        groups.push(...value.PreToolUse);
+      }
+    }
+    return groups;
+  }
+  return [];
+}
+
 function hookEvidence(root, relativePath) {
   const text = readText(path.join(root, relativePath));
   let hooks = [];
   try {
-    const groups = JSON.parse(text)?.hooks?.PreToolUse;
-    if (Array.isArray(groups)) {
-      hooks = groups.flatMap((group) =>
-        Array.isArray(group?.hooks)
-          ? group.hooks
-              .filter((hook) => !hook?.type || hook.type === 'command')
-              .map((hook) => ({
-                hook,
-                invocation: commandArkMcpInvocation(hook?.command),
-                operations: matcherOperations(relativePath, group.matcher),
-              }))
-              .filter((entry) => entry.invocation)
-          : []
-      );
-    }
+    const groups = collectPreToolUseGroups(JSON.parse(text));
+    hooks = groups.flatMap((group) =>
+      Array.isArray(group?.hooks)
+        ? group.hooks
+            .filter((hook) => !hook?.type || hook.type === 'command')
+            .map((hook) => ({
+              hook,
+              invocation: commandArkMcpInvocation(hook?.command),
+              operations: matcherOperations(relativePath, group.matcher),
+            }))
+            .filter((entry) => entry.invocation)
+        : []
+    );
   } catch {
     hooks = [];
   }
@@ -290,6 +306,29 @@ function hookEvidence(root, relativePath) {
   };
 }
 
+/** OpenCode local MCP: `{ mcp: { ark: { type: "local", command: [...] } } }`. */
+function opencodeMcpIsValid(text) {
+  try {
+    const server = JSON.parse(text)?.mcp?.ark;
+    if (!server || typeof server !== 'object') return false;
+    if (server.type != null && server.type !== 'local') return false;
+    if (!Array.isArray(server.command) || server.command.length === 0) return false;
+    if (!server.command.every((value) => typeof value === 'string')) return false;
+    const [command, ...args] = server.command;
+    return mcpServerRunsArk({ command, args });
+  } catch {
+    return false;
+  }
+}
+
+function opencodeMcpEvidence(root) {
+  for (const relativePath of ['opencode.json', 'opencode.jsonc']) {
+    const text = readText(path.join(root, relativePath));
+    if (text && opencodeMcpIsValid(text)) return [relativePath];
+  }
+  return [];
+}
+
 function mcpEvidence(root, relativePath) {
   const text = readText(path.join(root, relativePath));
   const valid = relativePath.endsWith('.toml')
@@ -338,6 +377,7 @@ export function detectWritePathInventory(root) {
   const merge = ci.failClosed ? ci.arkWorkflowFiles : [];
   const claudeHook = hookEvidence(root, '.claude/settings.json');
   const grokHook = hookEvidence(root, '.grok/hooks/ark-write-gate.json');
+  const antigravityHook = hookEvidence(root, '.agents/hooks.json');
   const hosts = {
     claude: hostRecord(
       claudeHook.hard,
@@ -351,12 +391,21 @@ export function detectWritePathInventory(root) {
       grokHook.repair,
       merge
     ),
+    antigravity: hostRecord(
+      antigravityHook.hard,
+      // Shared project MCP (.mcp.json) is the common advisory surface; hooks own hard write.
+      mcpEvidence(root, '.mcp.json'),
+      antigravityHook.repair,
+      merge
+    ),
     cursor: hostRecord([], mcpEvidence(root, '.cursor/mcp.json'), [], merge),
     // Codex 0.123+ emits PreToolUse for the native apply_patch handler, but some
     // Code Mode hosts execute deferred nested writes without dispatching that
     // project hook. Keep the installed hook as best-effort protection; do not
     // report a hard boundary that cannot be verified for every write surface.
     codex: hostRecord([], codexMcpEvidence(root), [], merge),
+    // OpenCode: MCP only (plugin hooks are incomplete / subagent-bypassable).
+    opencode: hostRecord([], opencodeMcpEvidence(root), [], merge),
   };
 
   const evidence = emptyEvidence();

package/bin/lib/write-path-detect.mjs

@@ -11,7 +11,7 @@ import { buildWritePathCapabilityModel } from './write-path-capabilities.mjs';
 
 function installToolsForHost(activeHost) {
   return activeHost === 'unknown'
-    ? 'claude,grok,cursor,codex'
+    ? 'claude,grok,antigravity,cursor,codex,opencode'
     : activeHost;
 }
 
@@ -109,22 +109,26 @@ export function detectWritePathCapabilities(root, explicitHost, attempt) {
       ),
     };
   } else if (mode === 'mcp-only') {
-    const codexHonesty =
+    const honesty =
       activeHost === 'codex'
         ? 'Codex local write is advisory (MCP + best-effort hooks.json — not a hard boundary; ' +
           'not equivalent to Claude/Grok PreToolUse hard-write + repair). ' +
           'The hard merge backstop is CI --strict-merge plus a required status check.'
-        : `Active host ${activeHost} has advisory prepare-write/autoPatch tools, ` +
-          'but no hard write boundary; CI can report failure, while merge blocking requires provider policy.';
+        : activeHost === 'opencode'
+          ? 'OpenCode local write is advisory (MCP + optional experimental plugin — not a hard boundary; ' +
+            'not equivalent to Claude/Grok/Antigravity PreToolUse hard-write). ' +
+            'The hard merge backstop is CI --strict-merge plus a required status check.'
+          : `Active host ${activeHost} has advisory prepare-write/autoPatch tools, ` +
+            'but no hard write boundary; CI can report failure, while merge blocking requires provider policy.';
     gap = {
       id: 'write-path-mcp-only',
       severity: 'info',
       host: activeHost,
-      message: codexHonesty,
+      message: honesty,
       fix:
-        activeHost === 'codex'
+        activeHost === 'codex' || activeHost === 'opencode'
           ? 'Keep CI on --strict-merge and require the ark-check status on the default branch; ' +
-            `refresh Codex MCP/skills with ${arkCommand(root, 'ark-check', '--install-agent-gates --tools codex')}`
+            `refresh ${activeHost} MCP/skills with ${arkCommand(root, 'ark-check', `--install-agent-gates --tools ${activeHost}`)}`
           : arkCommand(root, 'ark-check', `--install-agent-gates --tools ${tools}`),
     };
   }