arkgate 3.8.3 → 3.9.0

package/bin/ark-mcp-runtime.mjs

@@ -177,13 +177,90 @@ function isResolvedAnalysisInput(relativePath, args, compilerInputs = new Set())
   return /(?:^|\/)configs?\/[^/]+\.jsonc?$/i.test(relative);
 }
 
+/**
+ * Map Google Antigravity write tools (PascalCase args) onto Claude Write/Edit/MultiEdit.
+ * @returns {{ toolName: string, toolInput: object }|null}
+ */
+function mapAntigravityToolCall(toolCall) {
+  if (!toolCall || typeof toolCall !== 'object') return null;
+  const name = toolCall.name ?? '';
+  const args = toolCall.args && typeof toolCall.args === 'object' ? toolCall.args : {};
+  const filePath = args.TargetFile ?? args.targetFile ?? args.file_path ?? args.path;
+  if (name === 'write_to_file') {
+    return {
+      toolName: 'Write',
+      toolInput: {
+        file_path: filePath,
+        content: args.CodeContent ?? args.codeContent ?? args.content ?? '',
+      },
+      operation: 'write_to_file',
+    };
+  }
+  if (name === 'replace_file_content') {
+    return {
+      toolName: 'Edit',
+      toolInput: {
+        file_path: filePath,
+        old_string: args.TargetContent ?? args.targetContent ?? args.old_string ?? '',
+        new_string: args.ReplacementContent ?? args.replacementContent ?? args.new_string ?? '',
+        replace_all: Boolean(args.AllowMultiple ?? args.allowMultiple),
+      },
+      operation: 'replace_file_content',
+    };
+  }
+  if (name === 'multi_replace_file_content') {
+    const chunks = Array.isArray(args.ReplacementChunks)
+      ? args.ReplacementChunks
+      : Array.isArray(args.replacementChunks)
+        ? args.replacementChunks
+        : [];
+    return {
+      toolName: 'MultiEdit',
+      toolInput: {
+        file_path: filePath,
+        edits: chunks.map((chunk) => ({
+          old_string: chunk?.TargetContent ?? chunk?.targetContent ?? chunk?.old_string ?? '',
+          new_string:
+            chunk?.ReplacementContent ?? chunk?.replacementContent ?? chunk?.new_string ?? '',
+          replace_all: Boolean(chunk?.AllowMultiple ?? chunk?.allowMultiple),
+        })),
+      },
+      operation: 'multi_replace_file_content',
+    };
+  }
+  return {
+    toolName: name,
+    toolInput: { ...args, file_path: filePath },
+    operation: name,
+  };
+}
+
 /**
  * Normalize agent PreToolUse payloads.
  * Claude Code: { tool_name, tool_input: { file_path, content | old_string/new_string } }
  * Grok Build:  { toolName, toolInput:  { file_path, content | old_string/new_string } }
  *              (aliases Write/Edit/MultiEdit → write/search_replace; matcher keeps both)
+ * Antigravity: { toolCall: { name, args: { TargetFile, CodeContent, … } } }
  */
 function normalizeHookPayload(payload, grokHookEvent = Boolean(process.env.GROK_HOOK_EVENT)) {
+  const antigravityStyle =
+    payload != null && typeof payload === 'object' && 'toolCall' in payload;
+  if (antigravityStyle) {
+    const mapped = mapAntigravityToolCall(payload.toolCall);
+    const filePath =
+      mapped?.toolInput?.file_path ??
+      mapped?.toolInput?.filePath ??
+      mapped?.toolInput?.path ??
+      mapped?.toolInput?.target_file;
+    return {
+      toolName: mapped?.toolName ?? '',
+      toolInput: { ...(mapped?.toolInput ?? {}), file_path: filePath },
+      grokStyle: true, // decision JSON on stdout (deny)
+      antigravityStyle: true,
+      operation: mapped?.operation ?? mapped?.toolName ?? null,
+    };
+  }
+
   const rawName = payload?.tool_name ?? payload?.toolName ?? '';
   const toolInput = payload?.tool_input ?? payload?.toolInput ?? {};
   const nameMap = {
@@ -194,6 +271,9 @@ function normalizeHookPayload(payload, grokHookEvent = Boolean(process.env.GROK_
     MultiEdit: 'MultiEdit',
     ApplyPatch: 'ApplyPatch',
     apply_patch: 'ApplyPatch',
+    write_to_file: 'Write',
+    replace_file_content: 'Edit',
+    multi_replace_file_content: 'MultiEdit',
   };
   const toolName = nameMap[rawName] ?? rawName;
   const filePath =
@@ -205,6 +285,8 @@ function normalizeHookPayload(payload, grokHookEvent = Boolean(process.env.GROK_
     grokStyle:
       grokHookEvent ||
       (payload != null && typeof payload === 'object' && 'toolName' in payload),
+    antigravityStyle: false,
+    operation: null,
   };
 }
 
@@ -409,8 +491,14 @@ function processHookOutput() {
   };
 }
 
+/** Antigravity PreToolUse requires stdout `decision` on every response (allow included). */
+function emitAntigravityAllow(output, antigravityStyle) {
+  if (!antigravityStyle) return;
+  output.stdout(`${JSON.stringify({ decision: 'allow' })}\n`);
+}
+
 function runHookPayload(payload, gate, config, args, ts, attemptContext, output = processHookOutput()) {
-  const { toolName, toolInput, grokStyle } = normalizeHookPayload(
+  const { toolName, toolInput, grokStyle, antigravityStyle, operation } = normalizeHookPayload(
     payload,
     attemptContext?.grokHookEvent ?? Boolean(process.env.GROK_HOOK_EVENT)
   );
@@ -419,7 +507,10 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
     const parsedPatch = codexPatchWrites(patch, args.root);
     // Codex ApplyPatch is only preflighted when Ark can reconstruct every file operation.
     // An incomplete reconstruction must not be mislabeled as atomic or hard enforcement.
-    if (!parsedPatch.complete) return;
+    if (!parsedPatch.complete) {
+      emitAntigravityAllow(output, antigravityStyle);
+      return;
+    }
     const patchWrites = parsedPatch.writes;
     const sourceWrites = patchWrites.filter((change) =>
       isGovernableSourceFile(path.basename(String(change.path)))
@@ -482,7 +573,10 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
             .join(', ')}; source-only virtual preflight cannot model those contents.`
         );
       }
-      if (changes.length === 0) return;
+      if (changes.length === 0) {
+        emitAntigravityAllow(output, antigravityStyle);
+        return;
+      }
       result = prepareChangeFromRoot({
         root: args.root,
         config,
@@ -537,7 +631,10 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
     const designDelta = args.failOnNewSmells
       ? evaluateWriteDesignDelta({ root: args.root, config, changes, ts })
       : null;
-    if (result.valid && (designDelta?.valid ?? true)) return;
+    if (result.valid && (designDelta?.valid ?? true)) {
+      emitAntigravityAllow(output, antigravityStyle);
+      return;
+    }
     const message = [
       `Ark architecture gate blocked this complete ${toolName} (${changes.length} governed file(s)):`,
       ...result.diagnostics.map(
@@ -567,16 +664,27 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
     return;
   }
   const filePath = toolInput.file_path;
-  if (!['Write', 'Edit', 'MultiEdit'].includes(toolName)) return;
+  if (!['Write', 'Edit', 'MultiEdit'].includes(toolName)) {
+    // Non-file tools: fail-open. Antigravity still needs an explicit allow decision.
+    emitAntigravityAllow(output, antigravityStyle);
+    return;
+  }
   if (typeof filePath !== 'string' || !SOURCE_FILE.test(filePath) || filePath.endsWith('.d.ts')) {
+    emitAntigravityAllow(output, antigravityStyle);
     return;
   }
   const rel = path.relative(args.root, path.resolve(filePath));
   const segments = rel.split(path.sep);
-  if (segments[0] === '..' || segments.includes('node_modules')) return;
+  if (segments[0] === '..' || segments.includes('node_modules')) {
+    emitAntigravityAllow(output, antigravityStyle);
+    return;
+  }
 
   const source = proposedSource(toolName, toolInput);
-  if (typeof source !== 'string') return;
+  if (typeof source !== 'string') {
+    emitAntigravityAllow(output, antigravityStyle);
+    return;
+  }
 
   const layer = inferLayer(filePath, config, args.root);
   const validateOnce = (src) =>
@@ -611,7 +719,10 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
         ts,
       })
     : null;
-  if (result.valid && (designDelta?.valid ?? true)) return;
+  if (result.valid && (designDelta?.valid ?? true)) {
+    emitAntigravityAllow(output, antigravityStyle);
+    return;
+  }
 
   // Ratchet semantics (same philosophy as ark-check --baseline): an edit is blocked only
   // when it ADDS violations relative to the file's current on-disk state. Otherwise a
@@ -639,7 +750,10 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
     existingCounts.set(key, remaining - 1);
     return false;
   });
-  if (newViolations.length === 0 && (designDelta?.valid ?? true)) return;
+  if (newViolations.length === 0 && (designDelta?.valid ?? true)) {
+    emitAntigravityAllow(output, antigravityStyle);
+    return;
+  }
   const combinedViolations = [...newViolations, ...designDeltaViolations(designDelta)];
   const adapterResult = createAdapterResult({
     valid: false,
@@ -698,9 +812,21 @@ function runHookPayload(payload, gate, config, args, ts, attemptContext, output
       filePath: normalizedRel,
       enforcement: hookEnforcement(
         args.root,
-        attemptContext?.host ?? (grokStyle ? 'grok' : 'claude'),
+        attemptContext?.host ??
+          (antigravityStyle ? 'antigravity' : grokStyle ? 'grok' : 'claude'),
         attemptContext?.operation ??
-          (grokStyle ? (toolName === 'Edit' ? 'search_replace' : 'write') : toolName),
+          operation ??
+          (antigravityStyle
+            ? toolName === 'Edit'
+              ? 'replace_file_content'
+              : toolName === 'MultiEdit'
+                ? 'multi_replace_file_content'
+                : 'write_to_file'
+            : grokStyle
+              ? toolName === 'Edit'
+                ? 'search_replace'
+                : 'write'
+              : toolName),
         toolName === 'Write' || Boolean(attemptContext?.completePatch)
       ),
       ...(layer ? { layer } : {}),

package/bin/lib/agent-gates.mjs

@@ -23,10 +23,14 @@ export {
 
 export {
   PREFERRED_MCP_BIN,
+  antigravityHooks,
   claudeSettings,
   codexProjectConfig,
   grokHooks,
   grokProjectConfig,
+  mergeAntigravityArkHook,
+  mergeOpencodeArkMcp,
+  opencodeProjectConfig,
 } from './hook-templates.mjs';
 
 export { detectWritePathCapabilities } from './write-path-detect.mjs';

package/bin/lib/ci-and-commands.mjs

@@ -128,16 +128,13 @@ export function agentInstructions(root) {
 
 ## Default agent flow (if unsure, do only this)
 
-1. If \`ark.config.json\` is missing: run \`${startCmd}\` once.
-2. For adoption / cleanup / “make architecture sound”: run the **\`/ark-autopilot\`** skill
-   (explore first → dual plan: remediation + pattern bets → safe fixes → gates). Day-zero
-   origin is frozen by \`ark start\`/\`ark init\` (or autopilot if missing) **before** agent docs.
-   Do **not** invent a second architecture curriculum outside the routing table below — when a
-   trigger matches, use that skill; when unsure, stay on autopilot.
-3. Status anytime: \`${doctorCmd}\` (status light + next action — not a mode picker).
-4. After ordinary feature edits: run \`${checkCmd}\`. On violations → **\`/ark-fix\`** (or
-   \`/ark-place\` for new files, \`/ark-contract\` only if the contract itself is wrong).
+1. Status anytime: \`${doctorCmd}\` — **control plane** (one status light, one next action; not a mode picker).
+2. If \`ark.config.json\` is missing: run \`${startCmd}\` once (preview), then \`${startCmd} --apply\`.
+3. Guided end-to-end work (“make architecture sound”): **\`/ark-autopilot\`** — explore → dual plan A (edges) + B (shape) → mechanical-safe fixes; B only with user OK. Day-zero origin is frozen by \`ark start\`/\`ark init\` (or autopilot if missing) **before** agent docs.
+4. After ordinary feature edits: run \`${checkCmd}\`. On violations → **\`/ark-fix\`** (or \`/ark-place\` for new files, \`/ark-contract\` only if the contract itself is wrong).
 
+Do **not** skill-shop the full table for routine work. When unsure, do doctor top action #1 only
+(re-run doctor after). Do **not** jump to \`/ark-autopilot\` unless #1 or a STOP handoff names it.
 Skills are **dual-engine**: deterministic CLI sensors + exploratory read of *this* repo — not JSON-only wrappers.
 When a skill says **STOP — do not continue this skill as complete**, stop and invoke the named handoff skill.
 
@@ -151,14 +148,16 @@ scouts (disjoint path scopes) and merge in the parent. If the host does **not**,
 **fall back to sequential** — one cluster/step at a time. Never parallel-write the same
 files; never weaken the gate via subagents.
 
-## Skill routing (triggers → skill)
+## Skill routing (expert depth — triggers → skill)
 
-Do **not** run overlapping skills for the same job. Pick **one** primary skill from the table.
+**Escapes, not a second curriculum.** Do **not** run overlapping skills for the same job.
+Pick **one** primary skill. Prefer doctor top action #1 when unsure.
 
 | When | Invoke | Not this |
 |------|--------|----------|
-| Unsure / make architecture sound (apply path) | **/ark-autopilot** (default) | explore-only, coverage-only |
-| **Messy / spaghetti / design-weak after green / clarify for AI** | **Single path:** \`/ark-explore\` shape-focus → dual-plan B, then \`/ark-autopilot\` only to apply B with OK | coverage, think, loop-as-done, skill-shopping |
+| Unsure what to do next | **Doctor top action #1** (\`${doctorCmd}\`), then re-run doctor | skill-shopping, defaulting to autopilot |
+| Make architecture sound (guided apply path) | **/ark-autopilot** | explore-only, coverage-only |
+| **Messy / spaghetti / design-weak after green / Shape residual** | **Single path:** \`/ark-explore\` shape-focus → dual-plan B, then \`/ark-autopilot\` only to apply B with OK | coverage, think, loop-as-done, skill-shopping |
 | Map / residual / dual-plan seed only (no apply, already know you want recon) | \`/ark-explore\` | coverage (fitness only) |
 | Greenfield shape / empty tree | \`/ark-architect\` | adopt |
 | Brownfield / wrong contract / false-green | \`/ark-adopt\` then \`/ark-contract\` if globs wrong | architect |
@@ -209,20 +208,28 @@ export function compactAgentInstructions(root, host = null) {
     'ark-check',
     `--install-agent-gates --skills-only --tools ${selectedHost === 'none' ? '<host>' : selectedHost}`
   );
+  // Progressive disclosure: primary path only. Full /ark-* catalog is expert depth
+  // (install via --skills-only). See docs/product-voice.md.
   return `# Ark Enforcement
 
 <!-- arkgate:compact-router host=${selectedHost} -->
 ## Compact router
 
-This project uses the ArkGate package and its \`ark\` MCP resources as its one
-agent router. Before editing TypeScript or JavaScript, read \`ark://manifest\`
-when available; use \`ark_place\` for new files and \`validate_code\` after edits.
-If MCP is unavailable, inspect \`ark.config.json\` and run \`${checkCmd}\`.
+**Primary path (do this):**
 
-For architecture status, run \`${doctorCmd}\`. The selected host is
-\`${selectedHost}\`; its host registration and CI gate are installed alongside
-this file. Full \`/ark-*\` guided workflows are optional and can be added later
-with \`${installSkills}\`.
+1. Status anytime: \`${doctorCmd}\` — one status light, one next action (control plane).
+2. Day to day: read \`ark://manifest\` when MCP is available; place new files with \`ark_place\`; validate after edits; run \`${checkCmd}\`. On a gate deny, fix the architecture — do not weaken the contract.
+3. If MCP is unavailable: inspect \`ark.config.json\` and run \`${checkCmd}\`.
+
+The selected host is \`${selectedHost}\`. Host registration and CI are installed with this file.
+This compact router is enough for normal feature work.
+
+## Expert depth (optional)
+
+Full \`/ark-*\` skills (including guided end-to-end \`/ark-autopilot\`) are **not** the default
+curriculum. Install them only when doctor top action #1 or a STOP handoff names a skill:
+
+\`${installSkills}\`
 `;
 }
 

package/bin/lib/doctor-plan.mjs

@@ -36,6 +36,7 @@ import {
   mergePostGreenTopActions,
   isDoctorHealthyNothingToDo,
 } from './post-green-path.mjs';
+import { doctorWritePathHonestyMessage } from './host-support-matrix.mjs';
 import {
   computePureLayerOptInNudge,
   loadGoldenPattern,
@@ -578,14 +579,20 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
   console.log('');
   console.log(color.bold('Operating mode'));
   // Modes are detected states, not user-picked settings. Plain-language "what you do next".
-  const modeMark = mode === 'enforce' ? ok : mode === 'adapt' ? warn : warn;
+  // Never paint green (ok) under design residual — edges clean ≠ design done (product-voice).
+  const modeMark =
+    mode === 'enforce' && !designFitness.designWeak
+      ? ok
+      : warn;
+  // Status lights are detected states, not user-picked settings (see docs/product-voice.md).
+  // modeTitle alone names the light — bodies must not re-prefix Suggest/Adapt/Enforce.
   const modeHelp = {
     suggest:
-      'Setup — Ark proposes a starting architecture shape. You do not pick this mode; it means the tree is thin or new. Next: accept the shape (ark start / ark init) and add real layers as you grow.',
+      'thin or new tree; the contract is not yet the control plane. You do not pick this light. Next: ark start (preview), then ark start --apply; re-check with --doctor.',
     adapt:
-      'Align — contract and folders still disagree, or coverage is weak / debt is open. You do not pick this mode. Next: classify ungoverned dirs (/ark-contract, /ark-adopt), run the plan (/ark-autopilot or /ark-loop). Gates do not fully protect you yet.',
+      'contract and tree still disagree, or debt is open. Write path does not fully protect you yet. You do not pick this light. Next: do doctor top action #1 (often /ark-adopt, /ark-contract, or /ark-autopilot).',
     enforce:
-      'Guard — contract coverage is honest and checked edges are clean. You do not pick this mode; you arrived here. Next: keep the host-appropriate write path and CI check on; only NEW violations should fail.',
+      'honest coverage and clean checked edges. You arrived here; you never turn Enforce on. Next: keep the host write path and CI check; only NEW violations should fail.',
   };
   const modeTitle =
     mode === 'enforce' && designFitness.designWeak
@@ -595,7 +602,7 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
     modeMark,
     `${modeTitle} — ${
       designFitness.designWeak
-        ? 'Guard on edges is honest, but design smells remain (Shape residual). You do not pick this mode. Next: single path — /ark-explore shape-focus → dual-plan B, then /ark-autopilot only to apply B with your OK. Never empty plan A = done.'
+        ? 'checked edges are honest; design smells remain. Green is not elegant design. You do not pick this light. Next: one Shape door — /ark-explore shape-focus → dual-plan B; apply B only with /ark-autopilot and your OK. Empty plan A is not done.'
         : modeHelp[mode]
     }`
   );
@@ -692,34 +699,25 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
   if (showNewHere) {
     console.log('');
     console.log(color.bold('New here?'));
+    // Suggest residual: start → doctor only (not a competing recommend/architect curriculum).
+    line(ok, `Primary path: ${arkCommand(root, 'ark', 'start')} (preview) → ${arkCommand(root, 'ark', 'start --apply')} → re-run --doctor`);
     if (recommendation) {
-      line(warn, `Suggested application shape: ${recommendation.archetype} — ${recommendation.label} (preset ${recommendation.preset})`);
-      if (recommendation.galleryStarter) {
-        line(ok, `Gallery starter: ${recommendation.galleryStarter}`);
-      }
+      line(warn, `Sensor shape hint (not a second curriculum): ${recommendation.archetype} — ${recommendation.label} (preset ${recommendation.preset})`);
+      if (recommendation.galleryStarter) line(ok, `Gallery starter (optional): ${recommendation.galleryStarter}`);
       if (recommendation.policyPack) {
-        line(ok, `Policy pack: ${arkCommand(root, 'ark-check', `--apply-policy-pack ${recommendation.policyPack}`)}`);
+        line(ok, `Policy pack (optional expert): ${arkCommand(root, 'ark-check', `--apply-policy-pack ${recommendation.policyPack}`)}`);
       }
       if (recommendation.signals?.nestFramework) {
-        line(
-          ok,
-          'Nest modular monolith → prefer hexagonal (or ddd-bounded-contexts if you have src/contexts/*)'
-        );
+        line(ok, 'Nest modular monolith → prefer hexagonal (or ddd-bounded-contexts if you have src/contexts/*)');
       }
       if (recommendation.signals?.monorepoTooling?.length) {
-        line(
-          ok,
-          `Monorepo tooling (${recommendation.signals.monorepoTooling.join(', ')}) → preset monorepo (apps/packages/libs)`
-        );
+        line(ok, `Monorepo tooling (${recommendation.signals.monorepoTooling.join(', ')}) → preset monorepo (apps/packages/libs)`);
       }
     } else {
-      line(warn, 'Low governed coverage or fresh config — pick an application shape before adding code.');
-    }
-    line(ok, `See the plan: ${arkCommand(root, 'ark-check', '--recommend')}`);
-    if (recommendation?.archetype) {
-      line(ok, `Quick setup: ${arkCommand(root, 'ark', `init --archetype ${recommendation.archetype} --yes`)}`);
+      line(warn, 'Low governed coverage or fresh config — finish start, then re-run doctor before adding layers of code.');
     }
-    actions.unshift('run ark-check --recommend or /ark-architect to choose your application shape');
+    line(ok, `Optional sensor detail: ${arkCommand(root, 'ark-check', '--recommend')}`);
+    actions.unshift('finish ark start (preview + --apply), then re-run --doctor');
   }
 
   console.log('');
@@ -731,8 +729,10 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
         warn,
         'No active violations — coverage is still thin, so green is not yet honest enforcement'
       );
+    } else if (designFitness.designWeak) {
+      line(warn, 'None on checked edges — edges match the contract; design residual remains (ENFORCE · design-weak). Not healthy finished.');
     } else {
-      line(ok, 'None — the code matches the contract');
+      line(ok, 'None — the code matches the contract on checked edges');
     }
   } else {
     const typeNote = summary.typeOnlyCount > 0 ? ` (${summary.valueCount} value · ${summary.typeOnlyCount} type-only)` : '';
@@ -770,6 +770,8 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
   line(' ', `Active host: ${writePath.activeHost}`);
   line(' ', `Supported profile: ${writePath.supportSummary}`);
   line(wpMark, `Mode: ${writePath.mode} — ${writePathLabels[writePath.mode] || writePath.mode}`);
+  const honestyLine = doctorWritePathHonestyMessage(writePath.activeHost, capabilities['hard-write']);
+  if (honestyLine) line(warn, honestyLine);
   if (writePath.sessionNote) {
     line(warn, writePath.sessionNote);
   }
@@ -932,18 +934,25 @@ export function runDoctor(root, config, files, rules, violations, asJson, option
   const uniqueActions = mergePostGreenTopActions(actions, postGreenPath);
   if (isDoctorHealthyNothingToDo(designFitness, uniqueActions)) {
     console.log(color.green('✔ Healthy — nothing to do.'));
+    console.log(color.dim('  Contract edges and design residual are clear. Keep write path + CI.'));
   } else {
     if (designFitness.designWeak && uniqueActions.length === 0 && postGreenPath) {
       uniqueActions.push(postGreenPath.action);
     }
-    console.log(color.bold(`Top actions (${uniqueActions.length}):`));
-    uniqueActions.forEach((action, index) => console.log(`  ${index + 1}. ${action}`));
+    console.log(color.bold(`Primary next action`));
+    console.log(`  1. ${uniqueActions[0]}`);
+    if (uniqueActions.length > 1) {
+      console.log(color.bold(`Also (${uniqueActions.length - 1}):`));
+      uniqueActions.slice(1).forEach((action, index) => console.log(`  ${index + 2}. ${action}`));
+    }
     if (postGreenPath) {
       console.log(
         color.dim(
-          '  (post-green path is primary when ENFORCE · design-weak — do not skill-shop explore vs coverage vs think)'
+          '  Shape residual is the primary door under ENFORCE · design-weak — do not skill-shop explore vs coverage vs think.'
         )
       );
+    } else {
+      console.log(color.dim('  Doctor is the control plane: do #1 first, then re-run --doctor.'));
     }
   }
 }

package/bin/lib/hook-templates.mjs

@@ -1,15 +1,19 @@
 // Generated from hook-templates.source.mjs — run npm run generate:packaged-tooling.
-import{execCommandParts as i,execRunner as a}from"../ark-shared.mjs";const r="arkgate-mcp";function g(e){const o=a(e);return`${JSON.stringify({hooks:{SessionStart:[{hooks:[{type:"command",command:`${o} ${r} --session-context --root "$CLAUDE_PROJECT_DIR" --config ark.config.json`}]}],PreToolUse:[{matcher:"Write|Edit|MultiEdit",hooks:[{type:"command",command:`${o} ${r} --hook --hook-repair --fail-on-new-smells --root "$CLAUDE_PROJECT_DIR" --config ark.config.json`}]}]}},null,2)}
-`}function l(e){const o=a(e),n="${CODEX_PROJECT_DIR:-${PWD:-.}}";return`${JSON.stringify({hooks:{SessionStart:[{hooks:[{type:"command",timeout:30,command:`${o} ${r} --session-context --root "${n}" --config ark.config.json`}]}],PreToolUse:[{matcher:"ApplyPatch|apply_patch|Write|Edit|MultiEdit",hooks:[{type:"command",timeout:30,command:`${o} ${r} --hook --hook-repair --fail-on-new-smells --root "${n}" --config ark.config.json`}]}]}},null,2)}
-`}function p(e){const{command:o,args:n}=i(e,r,["--root",".","--config","ark.config.json"]),t=c=>c.replace(/\\/g,"\\\\").replace(/"/g,'\\"'),s=n.map(c=>`"${t(c)}"`).join(", ");return`# Generated by ark-check --install-agent-gates (Codex project scope).
+import{execCommandParts as i,execRunner as s}from"../ark-shared.mjs";const c="arkgate-mcp";function l(e){const r=s(e);return`${JSON.stringify({hooks:{SessionStart:[{hooks:[{type:"command",command:`${r} ${c} --session-context --root "$CLAUDE_PROJECT_DIR" --config ark.config.json`}]}],PreToolUse:[{matcher:"Write|Edit|MultiEdit",hooks:[{type:"command",command:`${r} ${c} --hook --hook-repair --fail-on-new-smells --root "$CLAUDE_PROJECT_DIR" --config ark.config.json`}]}]}},null,2)}
+`}function p(e){const r=s(e),o="${CODEX_PROJECT_DIR:-${PWD:-.}}";return`${JSON.stringify({hooks:{SessionStart:[{hooks:[{type:"command",timeout:30,command:`${r} ${c} --session-context --root "${o}" --config ark.config.json`}]}],PreToolUse:[{matcher:"ApplyPatch|apply_patch|Write|Edit|MultiEdit",hooks:[{type:"command",timeout:30,command:`${r} ${c} --hook --hook-repair --fail-on-new-smells --root "${o}" --config ark.config.json`}]}]}},null,2)}
+`}function g(e){const{command:r,args:o}=i(e,c,["--root",".","--config","ark.config.json"]),t=a=>a.replace(/\\/g,"\\\\").replace(/"/g,'\\"'),n=o.map(a=>`"${t(a)}"`).join(", ");return`# Generated by ark-check --install-agent-gates (Codex project scope).
 # Restart Codex after changes; MCP servers are loaded when the project session starts.
 [mcp_servers.ark]
-command = "${t(o)}"
-args = [${s}]
-`}function k(e){const{command:o,args:n}=i(e,r,["--root",".","--config","ark.config.json"]),t=n.map(s=>`"${s.replace(/\\/g,"\\\\").replace(/"/g,'\\"')}"`).join(", ");return`# Generated by ark-check --install-agent-gates (Grok Build project scope).
+command = "${t(r)}"
+args = [${n}]
+`}function f(e){const{command:r,args:o}=i(e,c,["--root",".","--config","ark.config.json"]),t=o.map(n=>`"${n.replace(/\\/g,"\\\\").replace(/"/g,'\\"')}"`).join(", ");return`# Generated by ark-check --install-agent-gates (Grok Build project scope).
 # Restart Grok (or /mcps \u2192 refresh) after changes. Also loads repo-root .mcp.json.
 [mcp_servers.ark]
-command = "${o.replace(/\\/g,"\\\\").replace(/"/g,'\\"')}"
+command = "${r.replace(/\\/g,"\\\\").replace(/"/g,'\\"')}"
 args = [${t}]
-`}function d(e){const o=a(e),n="${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}";return`${JSON.stringify({hooks:{SessionStart:[{hooks:[{type:"command",timeout:30,command:`${o} ${r} --session-context --root "${n}" --config ark.config.json`}]}],PreToolUse:[{matcher:"Write|Edit|MultiEdit|write|search_replace",hooks:[{type:"command",timeout:30,command:`${o} ${r} --hook --hook-repair --fail-on-new-smells --root "${n}" --config ark.config.json`}]}]}},null,2)}
-`}export{r as PREFERRED_MCP_BIN,g as claudeSettings,l as codexHooks,p as codexProjectConfig,d as grokHooks,k as grokProjectConfig};
+`}function u(e){const r=s(e),o="${GROK_WORKSPACE_ROOT:-${CLAUDE_PROJECT_DIR:-.}}";return`${JSON.stringify({hooks:{SessionStart:[{hooks:[{type:"command",timeout:30,command:`${r} ${c} --session-context --root "${o}" --config ark.config.json`}]}],PreToolUse:[{matcher:"Write|Edit|MultiEdit|write|search_replace",hooks:[{type:"command",timeout:30,command:`${r} ${c} --hook --hook-repair --fail-on-new-smells --root "${o}" --config ark.config.json`}]}]}},null,2)}
+`}function k(e){const r=s(e);return`${JSON.stringify({"ark-write-gate":{PreToolUse:[{matcher:"write_to_file|replace_file_content|multi_replace_file_content",hooks:[{type:"command",timeout:30,command:`${r} ${c} --hook --hook-repair --fail-on-new-smells --root "\${PWD:-.}" --config ark.config.json`}]}]}},null,2)}
+`}function d(e){const{command:r,args:o}=i(e,c,["--root",".","--config","ark.config.json"]);return`${JSON.stringify({$schema:"https://opencode.ai/config.json",mcp:{ark:{type:"local",command:[r,...o],enabled:!0}}},null,2)}
+`}function $(e,r){let o,t;try{o=e&&e.trim()?JSON.parse(e):{},t=JSON.parse(r)}catch{return null}if(!o||typeof o!="object"||Array.isArray(o)||!t||typeof t!="object"||Array.isArray(t))return null;const n=t["ark-write-gate"];if(!n||typeof n!="object")return null;const a={...o,"ark-write-gate":n};return`${JSON.stringify(a,null,2)}
+`}function h(e,r){let o,t;try{o=e&&e.trim()?JSON.parse(e):{},t=JSON.parse(r)}catch{return null}if(!o||typeof o!="object"||Array.isArray(o))return null;const n={...o};!n.$schema&&t.$schema&&(n.$schema=t.$schema);const a=o.mcp&&typeof o.mcp=="object"&&!Array.isArray(o.mcp)?{...o.mcp}:{};return a.ark=t.mcp.ark,n.mcp=a,`${JSON.stringify(n,null,2)}
+`}export{c as PREFERRED_MCP_BIN,k as antigravityHooks,l as claudeSettings,p as codexHooks,g as codexProjectConfig,u as grokHooks,f as grokProjectConfig,$ as mergeAntigravityArkHook,h as mergeOpencodeArkMcp,d as opencodeProjectConfig};

package/bin/lib/host-support-matrix.mjs

@@ -38,6 +38,16 @@ export const HOST_SUPPORT_MATRIX = Object.freeze({
     true,
     true
   ),
+  // Google Antigravity: official PreToolUse deny is a hard block. Claim hard only when
+  // installed + trusted and the listed write tools are covered by the adapter.
+  antigravity: hostProfile(
+    'Google Antigravity',
+    '.agents/hooks.json',
+    'PreToolUse `write_to_file` / `replace_file_content` / `multi_replace_file_content`',
+    ['write_to_file', 'replace_file_content', 'multi_replace_file_content'],
+    true,
+    true
+  ),
   cursor: hostProfile('Cursor', null, null, [], false, false),
   codex: hostProfile(
     'OpenAI Codex',
@@ -47,6 +57,16 @@ export const HOST_SUPPORT_MATRIX = Object.freeze({
     false,
     false
   ),
+  // OpenCode: first-class MCP + permissions; plugin tool.execute.before is incomplete
+  // (subagent holes). Never claim hard write.
+  opencode: hostProfile(
+    'OpenCode',
+    null,
+    'Advisory MCP + optional experimental plugin (`tool.execute.before`); not a hard boundary',
+    [],
+    false,
+    false
+  ),
 });
 
 export const HOST_SUPPORT_HOSTS = Object.freeze(Object.keys(HOST_SUPPORT_MATRIX));
@@ -70,18 +90,58 @@ export function renderHostSupportMatrixMarkdown() {
   const rows = HOST_SUPPORT_HOSTS.map((host) => {
     const profile = HOST_SUPPORT_MATRIX[host];
     const capabilities = profile.capabilities;
-    const local = capabilities['hard-write']
-      ? `Hard block for ${profile.hookSurface}`
-      : 'No hard hook; MCP/rules are advisory';
+    // Fail-closed honesty: Cursor/Codex/OpenCode never claim hard write; CI is required-status.
+    // hookSurface already includes "PreToolUse …" — do not prefix PreToolUse again.
+    let local;
+    if (capabilities['hard-write']) {
+      local = `**Hard** block for listed ops (${profile.hookSurface}) when installed + trusted`;
+    } else if (host === 'codex') {
+      local =
+        '**Advisory / best-effort** at write (not equivalent to Claude/Grok hard block)';
+    } else if (host === 'opencode') {
+      local =
+        '**Advisory / best-effort** at write (MCP + optional plugin; not a hard boundary)';
+    } else {
+      local = '**Advisory only** at write (no hard hook)';
+    }
     const repair = capabilities['repair-payload']
       ? 'Emitted on hook deny; host must re-inject'
       : 'No hard-boundary payload';
-    return `| ${profile.label} | ${local} | Advisory; the agent must call it | Available \`arkgate-check --strict-merge\` check | ${repair} |`;
+    const merge = capabilities['hard-write']
+      ? '**Required status** = hard merge boundary (`arkgate-check --strict-merge`)'
+      : '**Required status** = hard merge boundary (same CI)';
+    return `| ${profile.label} | ${local} | Advisory; the agent must call it | ${merge} | ${repair} |`;
   }).join('\n');
 
   return `| Host | Local write boundary | MCP validation | CI / merge path | Repair payload |
 |------|----------------------|----------------|-----------------|----------------|
 ${rows}
 
+**Read the CI column:** for every host, the repository-wide hard guarantee is a **required**
+merge check — not “CI file present.” Cursor/Codex/OpenCode never get a fake hard write claim.
+
 This table describes the supported profile **after its files are installed and the host loads/trusts them**. A hard local boundary covers only the listed hook operations; alternate tools, direct filesystem writes, and human edits still rely on CI. MCP validation is advisory because the agent must call it. The CI check blocks a merge only when the repository makes that status required. Repair payloads never write code silently: the host must re-inject the candidate and ArkGate revalidates it. Run \`arkgate-check --doctor\` for the evidence actually detected in the current repository.`;
 }
+
+/**
+ * Doctor human one-liner for active-host write honesty (fail-closed).
+ * @returns {string|null}
+ */
+export function doctorWritePathHonestyMessage(activeHost, hardWriteActive) {
+  const host = typeof activeHost === 'string' ? activeHost.trim().toLowerCase() : '';
+  if (host === 'cursor') {
+    return 'Cursor: write path is advisory (MCP/rules; no hard PreToolUse). Required CI status (arkgate-check --strict-merge) is the hard merge boundary.';
+  }
+  if (host === 'codex') {
+    return 'Codex: write path is advisory / best-effort at write (not Claude/Grok hard). Required CI status (arkgate-check --strict-merge) is the hard merge boundary.';
+  }
+  if (host === 'opencode') {
+    return 'OpenCode: write path is advisory / best-effort (MCP + optional plugin; not Claude/Grok/Antigravity hard). Required CI status (arkgate-check --strict-merge) is the hard merge boundary.';
+  }
+  if ((host === 'claude' || host === 'grok' || host === 'antigravity') && !hardWriteActive) {
+    const label =
+      host === 'claude' ? 'Claude' : host === 'grok' ? 'Grok' : 'Antigravity';
+    return `${label}: hard PreToolUse is supported for listed ops when installed + trusted; without runtime-observed hook evidence, hard is unverified. Required CI remains the merge hard boundary.`;
+  }
+  return null;
+}