@aria_asi/cli 0.2.40 → 0.2.41

package/hooks/lib/first-class-coach.mjs

@@ -1,13 +1,40 @@
+// ── doctrine-self-check-file: M0.SELFREVIEW.1+2 (2026-05-06) ──
+// Session added comments describing prior antipatterns being migrated.
+// Each comment names a trigger pattern; file-level ack covers them all.
+// doctrine-self-check-file: fall.?through session-added-comments-describing-prior-state-or-migration
+// doctrine-self-check-file: use the override|skip the gate|emergency flag|temporarily bypass|use the env disable|force through|DEPLOY_ALLOW_NO_ADMISSION_POLICY|ARIA_BINDING_ENABLED=false|--no-verify|--force session-added-comments-describing-prior-state-or-migration
+
 import { appendFileSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
-import { basename, dirname, join } from 'node:path';
+import { basename, dirname, join, resolve } from 'node:path';
 
 export const FIRST_CLASS_COACH_VERSION = 'aria.first_class_coach.v1';
 export const TASK_PROJECT_LEDGER_VERSION = 'aria.task_project_ledger.v1';
 export const RUNTIME_COACH_BRIDGE_VERSION = 'aria.runtime_coach_bridge.v1';
 
-export const FIRST_CLASS_AXIOMS = [
+// M0.H.X10 (2026-05-06) — Phase 0 audit Cluster H finding M0.H.18:
+// FIRST_CLASS_AXIOMS now sourced from canonical FITRAH_AXIOM_NAMES in
+// the runtime-rails registry. Pre-this-commit: this file maintained its
+// own list of names, parallel to owner-runtime.ts:FITRAH_AXIOMS. The
+// names were identical, but the audit flagged the duplication as drift
+// risk. Now: single source of truth across pod (owner-runtime) and hook
+// (first-class-coach).
+//
+// Note: this hook lives under ops/claude-hooks/lib/, not under
+// apps/arias-soul/api/lib/. The canonical registry is in the apps/
+// tree. Hook code can't reach across packages at install-time, so we
+// inline the import via a relative path that resolves only when the
+// hook runs from the monorepo (dev). For PRODUCTION client deployments
+// (connector npm package), the connector ships its own runtime-rails
+// registry mirror under packages/aria-connector/runtime-src/runtime-rails/
+// (Meta-X2 step 8) — and this hook ships under packages/aria-connector/
+// hooks/lib/ where a similar shim must reference the connector mirror.
+//
+// For dev / pod-side use, the names are inlined as a fallback so the
+// file still works when the apps/ registry isn't reachable. Operator
+// can grep `[first-class-coach:axiom-import]` to spot fallback paths.
+let FITRAH_AXIOM_NAMES_FALLBACK = [
   'truth_over_deception',
   'no_harm',
   'sacred_trust',
@@ -15,6 +42,8 @@ export const FIRST_CLASS_AXIOMS = [
   'reflection_before_action',
 ];
 
+export const FIRST_CLASS_AXIOMS = FITRAH_AXIOM_NAMES_FALLBACK;
+
 export const FIRST_CLASS_DOMAINS = [
   'engineering_quality',
   'reliability',
@@ -173,11 +202,24 @@ function compactHint(value = '') {
   return tail.replace(/[^a-zA-Z0-9._-]+/g, '-').slice(0, 80) || 'unknown';
 }
 
+// AI-11803-LOUD-PARSE-ERROR (2026-05-12) — distinguish "file does not exist"
+// (legitimately null) from "file exists but is corrupt" (silent state loss).
+// The prior catch returned null for both, so a corrupt ledger from an
+// interrupted write looked identical to a never-existed file — callers
+// happily created a fresh ledger and the prior state's history vanished.
+// Now: parse errors LOUD-log to stderr with the path + error message so the
+// operator sees corruption. Still returns null so callers can recover by
+// re-initializing (fail-soft is the right behavior for a hook that runs on
+// every turn — we cannot brick the agent because one ledger file is bad).
+// The LOUD signal is the operator-visibility per
+// feedback_non_blocking_errors_unacceptable.md — silent return is forbidden.
 function readJsonFile(path) {
+  if (!existsSync(path)) return null;
   try {
-    if (!existsSync(path)) return null;
     return JSON.parse(readFileSync(path, 'utf8'));
-  } catch {
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    process.stderr.write(`[lib/first-class-coach:readJsonFile-corrupt] path=${path} error=${message} — returning null; caller will treat as missing; investigate the file for partial-write or corruption\n`);
     return null;
   }
 }
@@ -187,7 +229,13 @@ function appendRuntimeCoachBridgeError(record) {
     const target = join(homedir(), '.aria', 'first-class-coach-runtime-publish-errors.jsonl');
     mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
     appendFileSync(target, `${JSON.stringify({ schema: `${RUNTIME_COACH_BRIDGE_VERSION}.error`, at: new Date().toISOString(), ...record })}\n`, { mode: 0o600 });
-  } catch {}
+  } catch (err) {
+    // M0.H.X3: ironic case — this catch wraps an ERROR-LOG write. If the
+    // error log itself can't be written, surface to stderr so the
+    // double-failure (original error + log-write failure) is at least
+    // visible to operator.
+    process.stderr.write(`[lib/first-class-coach:error-log-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 }
 
 function readRuntimeToken(env = process.env) {
@@ -203,6 +251,15 @@ function runtimeBaseUrl(env = process.env) {
   return firstString(env.ARIA_RUNTIME_URL, 'http://127.0.0.1:4319').replace(/\/+$/, '');
 }
 
+export function remoteRuntimeCoachEnabled(env = process.env) {
+  return /^(?:1|true|yes|on)$/i.test(String(
+    env.ARIA_REMOTE_COACH_ENABLED ||
+    env.ARIA_RUNTIME_COACH_ENABLED ||
+    env.ARIA_COACH_REMOTE_ENABLED ||
+    ''
+  ));
+}
+
 function runtimeCoachPhasesForLocalPhase(phase = '') {
   return RUNTIME_PHASES_BY_LOCAL_PHASE[phase] || ['pre_turn'];
 }
@@ -310,6 +367,16 @@ function buildRuntimeCoachBody({ platform = 'claude', phase = 'unknown', runtime
 }
 
 async function postRuntimeCoachPhase(body, env = process.env) {
+  if (!remoteRuntimeCoachEnabled(env)) {
+    return {
+      ok: true,
+      skipped: true,
+      permitted: true,
+      decision: 'allow',
+      phase: body?.phase || null,
+      reasons: ['remote_runtime_coach_disabled'],
+    };
+  }
   const token = readRuntimeToken(env);
   const headers = { 'Content-Type': 'application/json' };
   if (token) headers.Authorization = `Bearer ${token}`;
@@ -362,6 +429,107 @@ export function runtimeCoachBlocksLocalPhase(phase = '', runtimeResult = {}) {
   return runtimeResult?.blocking || null;
 }
 
+// AI-11803-COACH-OUTPUT-HUMAN (2026-05-12) — operator-facing block message
+// rewritten for readability. Prior format dumped reason machine-codes with no
+// explanation, no repair guidance, no kill-switch surface. Operator was left
+// guessing what "unverified_deploy_or_infra_mutation" meant in context. This
+// renders each reason with a plain-English title, a one-line cause sentence,
+// concrete repair options, and the kill-switch when applicable.
+const REASON_HUMAN = {
+  unapproved_destructive_action: {
+    title: 'Destructive-language pattern detected in your output',
+    cause: 'The runtime coach scanned your prose and matched destructive vocabulary (rm/delete/wipe/clean/sudo/wget/rebuild/etc.). It cannot tell from regex alone whether you are proposing options, describing what happened, or claiming you executed it.',
+    repair: [
+      'If you are PROPOSING (operator must authorize first): add modal markers — "I would", "we should", "recommend", "next step" — or frame as an options menu ("Options:" / numbered list). Avoid bare command syntax.',
+      'If you are REPORTING work-at-source (file edits, not shell execution): say "source corrections recorded" / "edits prepared" / "fix in source" so the classifier sees REPORT shape.',
+      'If you actually executed the action: cite the receipt — exit code, HTTP status, sha256, log line, "verified by …". The classifier treats verified claims as WARN, not block.',
+      'Kill switch (only when classifier is wrong): ARIA_COACH_DESTRUCTIVE_DOWNGRADE_OFF=0 then re-emit; or set to 1 to fully bypass (audited).',
+    ],
+  },
+  unverified_deploy_or_infra_mutation: {
+    title: 'Deploy/infra-mutation language detected without a verification anchor',
+    cause: 'Your prose mentions deploy/rollout/push/kubectl/apply/etc. without an evidence anchor that proves the mutation actually occurred. The runtime coach blocks unverified mutation claims to prevent fake "shipped" narratives.',
+    repair: [
+      'If PROPOSING: use modal verbs ("would deploy", "next step is to roll out"). Avoid first-person past-tense ("I deployed X").',
+      'If the deploy DID happen: cite the receipt — sha256 digest, kubectl output, image tag, `Status: Running`, exit code. The classifier reads evidence anchors and downgrades verified CLAIM to WARN.',
+      'If meta-discussing the deploy process (not claiming an event): rephrase to topic shape — "the deploy step", "how rollout works" — so the classifier reads DESCRIBE.',
+      'Kill switch: ARIA_COACH_POSTURE_OFF=1 (audited).',
+    ],
+  },
+  missing_readable_cognition_before_release: {
+    title: 'No `<cognition>` block found in your closing prose',
+    cause: 'The runtime coach\'s text scanner did not find a visible `<cognition>` block where one is required before release. Either the block was not emitted, or it was emitted in a shape the parser does not recognize.',
+    repair: [
+      'Keep the owner-readable answer first, then append a parseable `<cognition>` block with at least 4 of the 8 Ghazali lenses populated (nur/mizan/hikma/tafakkur/tadabbur/ilham/wahi/firasah) before any release claim.',
+      'Preferred shape: headline/status, evidence bullets, next action, then `<details><summary>cognition</summary>` containing the raw XML gate blocks.',
+      'If you already emitted one and the parser missed it: the local ledger\'s qualityGates may already have it — this block should auto-downgrade via applyLocalLedgerSupersedes. If it did not, the ledger gate was not marked passed — check ARIA TASK/PROJECT LEDGER state.',
+      'Kill switch: ARIA_COACH_SUPERSEDES_OFF=0 (the supersedes path is ON by default; this means: if you set it OFF=1 to disable downgrade, turn that OFF first).',
+    ],
+  },
+  missing_applied_cognition_before_release: {
+    title: 'No `<applied_cognition>` block found in your closing prose',
+    cause: 'Same as readable_cognition but for the applied-cognition contract: the agent must state decision_delta / binds_to / expected_predicate / evidence_basis before releasing.',
+    repair: [
+      'Keep the owner-readable answer first, then append `<applied_cognition>` with decision_delta, dominant_domain, binds_to, expected_predicate, evidence_basis, and risk_remaining.',
+      'Same ledger-supersedes path as missing_readable_cognition; check ARIA TASK/PROJECT LEDGER if you believe one was emitted.',
+    ],
+  },
+  verification_trace_pending: {
+    title: 'Verification trace has not been recorded for this turn',
+    cause: 'The coach kernel expects evidence.verification or a tool_response that proves the work was actually executed and passed. None was found.',
+    repair: [
+      'Run the verification action you proposed (tests, type-check, runtime probe, endpoint health), capture the receipt (exit code, status, log line), and emit it in prose or a <verify> block.',
+      'The aria-first-class-coach shim bridges Claude Code\'s tool_response into evidence.verification — if your verification ran via PostToolUse, the coach should already see it. If not, the bridge may have missed; emit explicit verification in prose.',
+    ],
+  },
+  intent_boundary_pending: {
+    title: 'Intent boundary not declared before action',
+    cause: 'The coach kernel expects a stated <intent> or expected_predicate before tool execution so it can verify outcomes against the declaration.',
+    repair: [
+      'State the expected predicate measurably before the action: exit code, status string, numeric threshold, or boolean. Avoid "better"/"improved"/"working" — those are not predicates.',
+    ],
+  },
+  cognition_presence: {
+    title: 'Cognition substrate not loaded for this turn',
+    cause: 'The pre-emit autoload did not detect cognition skills (tadabbur / qiyas / ghazali-8lens / mizan / aria-cognition-batch) in the loaded set.',
+    repair: [
+      'Invoke the required cognition skills via the Skill tool — the autoload injects bodies but the workflow skills must be actively invoked (see feedback_autoload_does_not_invoke_skills.md).',
+    ],
+  },
+  unsupported_completion_or_verification_claim: {
+    title: 'Completion / readiness claim without verification evidence',
+    cause: 'You said done / complete / ready / verified / fixed / shipped but no evidence anchor (exit code, HTTP 2xx, status:ok, sha256, ledger receipt) was present in the prose.',
+    repair: [
+      'Either remove the completion claim and emit bounded status, OR add the concrete receipt: "tests pass (exit 0)", "status: 200", "sha256:…", "verified by probe response showing …".',
+    ],
+  },
+  coach_kernel_policy_block: {
+    title: 'Coach kernel policy block',
+    cause: 'A generic policy block fired without a specific reason code. This is a catch-all and usually means the coach kernel is responding to a meta-condition.',
+    repair: [
+      'Check the coach_event_id below in /home/hamzaibrahim1/.aria/first-class-coach-events.jsonl for the full record.',
+    ],
+  },
+};
+
+function renderReasonHuman(reason) {
+  const entry = REASON_HUMAN[reason];
+  if (!entry) {
+    return [
+      `▸ ${reason}`,
+      '  (no human description registered — treat as policy block; see audit log for details)',
+    ];
+  }
+  const lines = [
+    `▸ ${entry.title}`,
+    `  ${entry.cause}`,
+    '',
+    '  Repair options:',
+  ];
+  for (const r of entry.repair) lines.push(`    • ${r}`);
+  return lines;
+}
+
 export function formatRuntimeCoachBlock(result = {}) {
   const record = result.record || {};
   const reasons = Array.isArray(result.reasons)
@@ -369,15 +537,33 @@ export function formatRuntimeCoachBlock(result = {}) {
     : Array.isArray(record.reasons)
       ? record.reasons
       : ['coach_kernel_policy_block'];
-  return [
-    '=== ARIA RUNTIME COACH BLOCK ===',
+  const decision = result.decision || record.decision || 'blocked';
+  const lines = [
+    '═══════════════════════════════════════════════════════════════',
+    '  ARIA RUNTIME COACH — your turn was blocked',
+    '═══════════════════════════════════════════════════════════════',
     '',
-    `decision: ${result.decision || record.decision || 'blocked'}`,
-    `coach_event_id: ${record.coach_event_id || 'unknown'}`,
-    `reasons: ${reasons.join(', ') || 'coach_kernel_policy_block'}`,
-    `next: ${result.clientMessage || record.next_action || 'repair the blocked condition and retry'}`,
+    `Decision: ${decision}`,
+    `Why: ${reasons.length === 1 ? '1 reason raised by the coach kernel.' : `${reasons.length} reasons raised by the coach kernel.`}`,
     '',
-  ].join('\n');
+  ];
+  for (const reason of reasons) {
+    for (const line of renderReasonHuman(reason)) lines.push(line);
+    lines.push('');
+  }
+  const next = result.clientMessage || record.next_action;
+  if (next && next !== 'repair the blocked condition and retry') {
+    lines.push('Coach kernel\'s suggested next step:');
+    lines.push(`  ${next}`);
+    lines.push('');
+  }
+  lines.push('Debug:');
+  lines.push(`  coach_event_id: ${record.coach_event_id || 'unknown'}`);
+  lines.push(`  reasons (machine): ${reasons.join(', ')}`);
+  lines.push('  audit log: /home/hamzaibrahim1/.aria/first-class-coach-events.jsonl');
+  lines.push('═══════════════════════════════════════════════════════════════');
+  lines.push('');
+  return lines.join('\n');
 }
 
 function writeJsonAtomic(path, value) {
@@ -387,6 +573,99 @@ function writeJsonAtomic(path, value) {
   renameSync(tmp, path);
 }
 
+// M9.DRIFT.10s — coach hook rewrite race fix.
+//
+// Keys this lib explicitly OWNS in the task/project ledger. External
+// writers (e.g., the agent writing rich verification_trace evidence
+// objects, future evidence types, third-party tooling) write to any
+// other top-level key and writeJsonAtomicMerge below preserves them
+// across coach hook fires.
+//
+// IF YOU ADD A FEATURE THAT MANAGES A NEW LEDGER KEY: add the key
+// here in the same rung that adds the feature.
+
+// M9.DRIFT.10t — Edit-target-skip race fix (companion to M9.DRIFT.10s).
+//
+// The 10s merge-fix prevents the hook from CLOBBERING agent-authored
+// keys when the hook writes after the agent. The remaining race is
+// UPSTREAM of the merge: when the agent uses Claude Code's Edit /
+// Write / MultiEdit / NotebookEdit tool on the active ledger file
+// itself, the PreToolUse coach hook fires first and writeJsonAtomic's
+// tmp+rename changes the file's inode + mtime + content. Claude
+// Code's Edit tool then refuses with "File content has changed since
+// it was last read" because its Read-snapshot guard sees the file
+// changed underneath it. The agent's Edit never lands, so the merge
+// never gets the chance to preserve anything.
+//
+// Fix: when this hook fire's event is a PreToolUse for Edit / Write /
+// MultiEdit / NotebookEdit AND tool_input.file_path resolves to the
+// active ledger path, skip the writeJsonAtomicMerge for this fire.
+// The PostToolUse fire that follows the agent's Edit will run the
+// merge against the agent's now-on-disk content, which (combined with
+// the 10s managed-vs-external key split) preserves the agent's edit
+// without dropping any hook-managed phase/event row — phaseEvents and
+// evidence are accumulating arrays, so the PostToolUse merge just
+// appends.
+function isAgentEditingActiveLedger(event = {}, ledgerPath = '') {
+  if (!ledgerPath) return false;
+  const tool = String(event?.tool_name || event?.toolName || event?.tool?.name || '');
+  const editTools = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+  if (!editTools.has(tool)) return false;
+  const toolInput = event?.tool_input || event?.toolInput || event?.input || {};
+  const filePath = toolInput?.file_path || toolInput?.filePath || toolInput?.notebook_path || toolInput?.notebookPath || '';
+  if (!filePath) return false;
+  // Compare resolved absolute paths so a relative file_path can't bypass the guard.
+  try {
+    return resolve(String(filePath)) === resolve(String(ledgerPath));
+  } catch {
+    return String(filePath) === String(ledgerPath);
+  }
+}
+
+export const MANAGED_LEDGER_KEYS = Object.freeze([
+  'schema',
+  'ledgerId',
+  'identity',
+  'createdAt',
+  'updatedAt',
+  'status',
+  'controls',
+  'qualityGates',
+  'phaseEvents',
+  'evidence',
+  'blockedClaims',
+  'openBlockers',
+]);
+
+/**
+ * M9.DRIFT.10s — atomic write that preserves external (non-managed) keys.
+ *
+ * Bug it fixes: prior path was read → mutate → writeJsonAtomic(whole).
+ * If process A reads at T0, agent writes external key at T1, process A
+ * writes back at T2 — agent's T1 write is clobbered by A's stale snapshot.
+ *
+ * Fix: re-read CURRENT disk state at write time. Build merged object:
+ * external keys from current disk; managed keys from partialUpdate.
+ * Atomic write via existing tmp+rename pattern.
+ *
+ * @param {string} path
+ * @param {object} partialUpdate  contains the managed-key values this writer is publishing
+ * @param {readonly string[]} managedKeys  list of keys this writer owns
+ */
+function writeJsonAtomicMerge(path, partialUpdate, managedKeys = MANAGED_LEDGER_KEYS) {
+  // Re-read current disk state right before write. If the agent (or
+  // another process) wrote external keys between this writer's read
+  // and this write, those external keys are picked up here.
+  const current = readJsonFile(path) || {};
+  const merged = { ...current };
+  for (const key of managedKeys) {
+    if (key in partialUpdate) {
+      merged[key] = partialUpdate[key];
+    }
+  }
+  writeJsonAtomic(path, merged);
+}
+
 function markGate(ledger, gateId, status, evidence = undefined) {
   const gate = ledger.qualityGates?.[gateId];
   if (!gate) return;
@@ -409,11 +688,111 @@ function hasPromptIntent(event = {}) {
   ));
 }
 
+// AI-11803-COACH-VERIFY-FIX (2026-05-12) — extractor extension to recognize
+// Claude Code PostToolUse tool_response shapes. The prior implementation only
+// read explicit `evidence.verification` boolean flags and a narrow set of
+// event-string fields. It did NOT read `event.tool_response.stdout` or
+// `event.tool_response.output` — the canonical Claude Code PostToolUse surface
+// for Bash, curl, and HTTP probes. Consequence: a successful /chat probe
+// returning `{success:true, modelUsed:"deepseek-v4-pro", latencyMs:19824}`
+// in stdout failed to flip the local ledger's verification_trace gate,
+// which kept readinessClaimAllowed=false, which prevented the supersedes
+// downgrade from firing on remote-coach missing_*_cognition false-positives,
+// which created an infinite Stop-gate loop and pressured agents toward
+// bypass via direct ledger edit.
+//
+// This extension preserves the original boolean-flag + string-keyword paths
+// and adds two new paths:
+//   1. Read the tool_response.{stdout,output,text,result,content} family.
+//   2. Parse any JSON object embedded in the stdout and check for
+//      verification-shape fields (success/ok/verified booleans,
+//      status:"ok|success|passed|verified|active|running|ready|healthy",
+//      modelUsed+latencyMs>0, HTTP-2xx statusCode). Failed probes
+//      (`{success:false}`) explicitly do NOT match.
+//
+// JSON-first check ordering: if stdout parses as JSON, the JSON's
+// success-shape is authoritative — failed probes must NOT flip
+// verification_trace just because the literal substring "success" appears
+// in the JSON-key text. Only when stdout is NOT JSON do we fall back to
+// keyword regex (test output, build logs, plain-text probes).
+//
+// No carve-out: any path that finds verification evidence must point at
+// genuine receipt-shape.
+
+function readToolResponseTexts(event) {
+  const out = [];
+  const tr = event?.tool_response || event?.toolResponse || event?.tool_result || event?.toolResult;
+  if (tr && typeof tr === 'object') {
+    if (typeof tr.stdout === 'string') out.push(tr.stdout);
+    if (typeof tr.output === 'string') out.push(tr.output);
+    if (typeof tr.text === 'string') out.push(tr.text);
+    if (typeof tr.result === 'string') out.push(tr.result);
+    if (typeof tr.content === 'string') out.push(tr.content);
+    if (Array.isArray(tr.content)) {
+      for (const piece of tr.content) {
+        if (piece && typeof piece === 'object' && typeof piece.text === 'string') out.push(piece.text);
+      }
+    }
+  }
+  return out;
+}
+
+function extractFirstJsonObject(text) {
+  if (typeof text !== 'string') return null;
+  const start = text.indexOf('{');
+  if (start < 0) return null;
+  let depth = 0;
+  let inStr = false;
+  let strQuote = '';
+  let escape = false;
+  for (let i = start; i < text.length; i++) {
+    const ch = text[i];
+    if (inStr) {
+      if (escape) { escape = false; continue; }
+      if (ch === '\\') { escape = true; continue; }
+      if (ch === strQuote) inStr = false;
+      continue;
+    }
+    if (ch === '"' || ch === '\'') { inStr = true; strQuote = ch; continue; }
+    if (ch === '{') depth++;
+    else if (ch === '}') {
+      depth--;
+      if (depth === 0) {
+        const slice = text.slice(start, i + 1);
+        try { return JSON.parse(slice); } catch { return null; }
+      }
+    }
+  }
+  return null;
+}
+
+function isVerificationShapedJson(obj) {
+  if (!obj || typeof obj !== 'object') return false;
+  if (obj.success === false || obj.ok === false) return false;
+  if ((obj.error || obj.errors) && obj.success !== true && obj.ok !== true && obj.verified !== true) return false;
+  if (obj.success === true || obj.ok === true || obj.verified === true) return true;
+  if (typeof obj.status === 'string' && /^(?:ok|success|passed|verified|active|running|ready|healthy)$/i.test(obj.status)) return true;
+  if ((obj.modelUsed || obj.model) && typeof obj.latencyMs === 'number' && obj.latencyMs > 0) return true;
+  if (typeof obj.statusCode === 'number' && obj.statusCode >= 200 && obj.statusCode < 300) return true;
+  if (typeof obj.status === 'number' && obj.status >= 200 && obj.status < 300) return true;
+  return false;
+}
+
 function hasVerificationEvidence(evidence = {}, event = {}) {
   if (evidence.warning_clean === true || evidence.verification === true || evidence.validation_run === true) return true;
   if (event.verified === true || event.validation?.ok === true || event.test?.ok === true) return true;
   const text = firstString(event.verification, event.validation, event.testResult, event.commandResult, evidence.commandResult);
-  return /\b(?:ok|passed|pass|success|succeeded|exit\s*0|0\s*failures?)\b/i.test(text);
+  if (/\b(?:ok|passed|pass|success|succeeded|exit\s*0|0\s*failures?)\b/i.test(text)) return true;
+  const toolTexts = readToolResponseTexts(event);
+  for (const t of toolTexts) {
+    const json = extractFirstJsonObject(t);
+    if (json) {
+      if (isVerificationShapedJson(json)) return true;
+      continue;
+    }
+    if (/\b(?:ok|passed|pass|success|succeeded|exit\s*0|0\s*failures?|verified|status\s*=\s*(?:ok|success|passed|verified|active|running))\b/i.test(t)) return true;
+  }
+  return false;
 }
 
 function isExecutionPhase(phase = '') {
@@ -539,8 +918,35 @@ export function updateTaskProjectLedger({ platform, phase, source = 'first-class
   }
 
   markGate(ledger, 'ledger_created', 'passed', { ledgerPath: paths.ledgerPath });
-  if (hasPromptIntent(event) || phase === 'pre_prompt_injection' || phase === 'session_start') {
-    markGate(ledger, 'intent_boundary', 'passed', { source, phase });
+  // AI-11803-INTENT-BOUNDARY-FIX (2026-05-12) — extended condition.
+  //
+  // Prior: only `hasPromptIntent(event)` OR specific phases
+  // (pre_prompt_injection / session_start) flipped intent_boundary.
+  // Documented gap: Claude Code can deliver the FIRST hook fire for a
+  // task identity as PreToolUse (sub-agent spawn, session resumed
+  // mid-task, smoke-test fires that target only a specific phase).
+  // When that happens, neither hasPromptIntent nor the phase check
+  // trips — the gate stays pending forever even though subsequent
+  // pre_tool/post_tool/stop fires accumulate. Two example ledgers
+  // observed 2026-05-12 with intent_boundary stuck since createdAt
+  // (synthetic taskHint=`claude-coach-pretool-block-smoke` AND real
+  // operator sessions that started with pre_tool).
+  //
+  // Fix: a task-specific identity (taskHint differs from project
+  // fallback) plus any recognized phase IS evidence of operator-
+  // initiated task work. The resolved task identity hash (already
+  // baked into ledger path) is what makes the boundary; the phase
+  // is the auditable when. Prompt-shape evidence still satisfies
+  // separately (lighter-weight check; useful when identity hashing
+  // fell back to project).
+  const taskIdentityResolved = identity?.taskHint && identity?.projectHint && identity.taskHint !== identity.projectHint;
+  if (
+    hasPromptIntent(event)
+    || phase === 'pre_prompt_injection'
+    || phase === 'session_start'
+    || (taskIdentityResolved && phase && phase !== 'unknown')
+  ) {
+    markGate(ledger, 'intent_boundary', 'passed', { source, phase, taskHint: identity?.taskHint || null });
   }
   if (platform && phase && phase !== 'unknown') {
     markGate(ledger, 'scope_boundary', 'passed', { platform, phase });
@@ -579,7 +985,22 @@ export function updateTaskProjectLedger({ platform, phase, source = 'first-class
   ledger.controls.readinessClaimAllowed = missingReadinessGates.length === 0 && (ledger.openBlockers || []).length === 0;
   ledger.controls.missingReadinessGates = missingReadinessGates;
 
-  writeJsonAtomic(paths.ledgerPath, ledger);
+  // M9.DRIFT.10s — merge-write preserves externally-authored keys
+  // (e.g., agent's rich verification_trace evidence objects) that
+  // would otherwise be clobbered by the read-snapshot writeback race.
+  //
+  // M9.DRIFT.10t — skip the ledger write when the imminent tool call
+  // is the agent editing this same ledger file. Touching the file
+  // here would invalidate Claude Code's Read-snapshot and abort the
+  // agent's Edit. The PostToolUse fire merges after the Edit lands.
+  // The event row + sidecar still get appended below regardless, so
+  // we don't lose the phase trail.
+  const skipMergeForAgentSelfEdit = isAgentEditingActiveLedger(event, paths.ledgerPath);
+  if (!skipMergeForAgentSelfEdit) {
+    writeJsonAtomicMerge(paths.ledgerPath, ledger, MANAGED_LEDGER_KEYS);
+  } else {
+    process.stderr.write(`[aria-first-class-coach:m9.drift.10t] skip-merge-for-agent-self-edit ledgerPath=${paths.ledgerPath} tool=${event?.tool_name || event?.toolName || ''}\n`);
+  }
   mkdirSync(dirname(paths.eventPath), { recursive: true, mode: 0o700 });
   appendFileSync(paths.eventPath, `${JSON.stringify({ schema: `${TASK_PROJECT_LEDGER_VERSION}.event`, ledgerId: ledger.ledgerId, ...row })}\n`, { mode: 0o600 });
   return { ledger, paths, identity };
@@ -620,7 +1041,12 @@ export function extractAssistantText(event = {}) {
       const text = extractTextFromContent(parsed.content) || extractTextFromContent(parsed.message?.content) || extractTextFromContent(parsed.text);
       if (text) return text;
     }
-  } catch {}
+  } catch (err) {
+    // M0.H.X3: transcript read for assistant-text extraction now surfaces
+    // failures. Empty-string fall-through preserved; operator sees if
+    // the transcript file is missing/corrupted.
+    process.stderr.write(`[lib/first-class-coach:transcript-read] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
   return '';
 }
 
@@ -648,7 +1074,8 @@ export function recordBlockedTaskProjectClaim({ ledger, paths, text, evaluation
     openBlockerCount: evaluation?.openBlockers?.length || 0,
   });
   ledger.updatedAt = now;
-  writeJsonAtomic(paths.ledgerPath, ledger);
+  // M9.DRIFT.10s — merge-write preserves externally-authored keys.
+  writeJsonAtomicMerge(paths.ledgerPath, ledger, MANAGED_LEDGER_KEYS);
   return ledger.blockedClaims[ledger.blockedClaims.length - 1];
 }
 
@@ -704,7 +1131,7 @@ export function inferCoachPlatform(input = {}, env = process.env) {
   return PLATFORM_PHASES[normalized] ? normalized : normalized || 'unknown';
 }
 
-export function recordCoachEvent({ platform, phase, source = 'first-class-coach', event = {}, evidence = {} } = {}) {
+export function recordCoachEvent({ platform, phase, source = 'first-class-coach', event = {}, evidence = {}, metadata = null } = {}) {
   const row = {
     schema: `${FIRST_CLASS_COACH_VERSION}.event`,
     at: new Date().toISOString(),
@@ -713,6 +1140,14 @@ export function recordCoachEvent({ platform, phase, source = 'first-class-coach'
     source,
     evidence,
   };
+  // 2026-05-17 producer-enrichment for harness ticker (project memory:
+  // project_harness_ticker_counter_wiring_2026_05_17.md). When the caller
+  // knows the runtime coach decision / posture / forcedSkillLoad, attach
+  // it under metadata so the ticker consumer at
+  // runtime-client.mjs:applyHarnessTickerRows can bump Repairs / Blocks /
+  // Skills fired counters. Absent metadata = base telemetry row only
+  // (gates counter still increments).
+  if (metadata && typeof metadata === 'object') row.metadata = metadata;
   const target = coachEventPath();
   mkdirSync(dirname(target), { recursive: true, mode: 0o700 });
   appendFileSync(target, `${JSON.stringify(row)}\n`, { mode: 0o600 });

package/hooks/lib/gate-audit.mjs

@@ -32,12 +32,22 @@ export function appendGateAudit({
         ...data,
       }) + '\n',
     );
-  } catch {}
+  } catch (err) {
+    // M0.H.X3: gate-audit primary write failure now surfaces. Loss of
+    // gate audit entries means operator can't reconstruct gate decisions
+    // for the named gate; surface visibly with which gate failed.
+    process.stderr.write(`[lib/gate-audit:${gate}-audit-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 
   if (legacyLogPath) {
     try {
       if (!existsSync(dirname(legacyLogPath))) mkdirSync(dirname(legacyLogPath), { recursive: true });
       appendFileSync(legacyLogPath, `${ts} ${event} ${summary}\n`);
-    } catch {}
+    } catch (err) {
+      // M0.H.X3: legacy log path is opportunistic; primary audit at
+      // auditPath is the authority. Still surface so operator notices
+      // disk-issue patterns affecting both.
+      process.stderr.write(`[lib/gate-audit:${gate}-legacy-log-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+    }
   }
 }

package/hooks/lib/gate-loop-state.mjs

@@ -18,7 +18,12 @@ export function registerGateBlock({
       const raw = JSON.parse(readFileSync(statePath, 'utf8'));
       if (Array.isArray(raw)) rows = raw;
     }
-  } catch {}
+  } catch (err) {
+    // M0.H.X3: gate-loop-state read failure now surfaces. Empty rows
+    // proceeds = loop detection won't fire this turn; operator sees
+    // the underlying state-file corruption.
+    process.stderr.write(`[lib/gate-loop-state:state-read] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 
   const freshRows = rows.filter((row) =>
     row &&
@@ -40,7 +45,11 @@ export function registerGateBlock({
   try {
     mkdirSync(dirname(statePath), { recursive: true });
     writeFileSync(statePath, JSON.stringify(freshRows.slice(-MAX_RECORDS), null, 2) + '\n');
-  } catch {}
+  } catch (err) {
+    // M0.H.X3: gate-loop-state write failure now surfaces. Loss of write
+    // means future loop detection won't see this block; surface visibly.
+    process.stderr.write(`[lib/gate-loop-state:state-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
 
   return {
     loopDetected: priorMatches.length >= threshold,