@aria_asi/cli 0.2.40 → 0.2.41

package/opencode-plugins/harness-context/index.js

@@ -17,11 +17,35 @@
 
 import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const PLUGIN_DIR = dirname(fileURLToPath(import.meta.url));
 const INJECT_SCRIPT = join(PLUGIN_DIR, 'inject-context.mjs');
+const UNIVERSAL_TURN_PACKET_SCRIPT = join(process.env.HOME || homedir(), '.opencode', 'hooks', 'aria-universal-turn-packet.mjs');
+
+function getUniversalTurnPacketContext() {
+  if (!existsSync(UNIVERSAL_TURN_PACKET_SCRIPT)) {
+    process.stderr.write(`[harness-context] aria-universal-turn-packet.mjs missing at ${UNIVERSAL_TURN_PACKET_SCRIPT}\n`);
+    return null;
+  }
+  try {
+    return execFileSync(process.execPath, [UNIVERSAL_TURN_PACKET_SCRIPT, '--surface', 'opencode', '--context'], {
+      encoding: 'utf-8',
+      timeout: 12000,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: {
+        ...process.env,
+        ARIA_SURFACE_ID: 'opencode',
+        ARIA_UNIVERSAL_TURN_PACKET_CONTEXT: '1',
+      },
+    });
+  } catch (err) {
+    process.stderr.write(`[harness-context] universal turn packet failed: ${err && err.message ? err.message : String(err)}\n`);
+    throw err;
+  }
+}
 
 function getHarnessContext() {
   if (!existsSync(INJECT_SCRIPT)) {
@@ -47,14 +71,23 @@ function getHarnessContext() {
 }
 
 export default async function HarnessContextPlugin(ctx) {
+  const universalTurnPacket = getUniversalTurnPacketContext();
   const context = getHarnessContext();
-  if (context) {
+  const coachDirectives = getPendingCoachDirectives();
+  const fullContext = [universalTurnPacket, context, coachDirectives].filter(Boolean).join('\n');
+  if (fullContext) {
     try {
-      ctx.system?.prepend?.(context.slice(0, 40000));
-    } catch (_) {
-      // ctx.system shape varies across OpenCode versions; if prepend isn't
-      // available we silently no-op rather than crash plugin load.
-    }
+      ctx.system?.prepend?.(fullContext.slice(0, 40000));
+    } catch (_) {}
+    clearPendingCoachDirectives();
+  }
+  try {
+    await recordCoachPhase('pre_turn', {
+      sessionId: process.env.ARIA_SESSION_ID || process.env.OPENCODE_SESSION_ID || 'opencode',
+      text: 'session-start',
+    });
+  } catch (e) {
+    if (e.coachBlock) throw e;
   }
   return {};
 }

package/opencode-plugins/harness-context/task-project-ledger.mjs

@@ -64,6 +64,8 @@ function markGate(ledger, gateId, status, evidence = undefined) {
 
 function hasPromptIntent(event = {}) {
   return Boolean(firstString(
+    event.goal,
+    event.taskGoal,
     event.prompt,
     event.userPrompt,
     event.user_input,
@@ -80,7 +82,9 @@ function hasPromptIntent(event = {}) {
 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, evidence.outputPreview);
+  if (evidence.qa?.ok === true || evidence.qaLearningLoop?.ok === true || event.qa?.ok === true || event.qaLearningLoop?.ok === true) return true;
+  if (['verified', 'verified_narrowly'].includes(String(evidence.endPhaseQaAutofire?.verdict || event.endPhaseQaAutofire?.verdict || ''))) return true;
+  const text = firstString(event.verification, event.validation, event.testResult, event.commandResult, event.evidence, evidence.commandResult, evidence.outputPreview, evidence.evidence);
   return /\b(?:ok|passed|pass|success|succeeded|exit\s*0|0\s*failures?)\b/i.test(text);
 }
 

package/opencode-plugins/harness-gate/index.js

@@ -8,8 +8,13 @@ import { spawnSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { evaluateSkillGate, formatSkillGateBlock } from './lib/skill-autoload-gate.js';
+// Atlas dossier client — fourth deploy surface (opencode harness-gate).
+// Re-exported from connector hooks/lib via shim. Added 2026-05-17.
+import { fetchGoverningSkills } from './lib/atlas-dossier-client.js';
 import { updateTaskProjectLedger } from '../harness-context/task-project-ledger.mjs';
 import { resolveAriaAuthToken } from '../harness-context/auth-token.mjs';
+import { recordCoachPhase } from '../lib/coach.js';
+import { tryApplyRecoveryGrant } from './lib/recovery-grants.js';
 
 const HOME = homedir();
 const SDK_CANDIDATES = [
@@ -94,6 +99,12 @@ function emergencyGateOffDecision(payload = '') {
   return { off: false, reason: null };
 }
 
+function gateBlockWithGrant(msg, sessionId) {
+  const gm = tryApplyRecoveryGrant(sessionId);
+  if (gm) return gm;
+  return null;
+}
+
 function receiptPath(sessionId) {
   return join(RECEIPT_DIR, `${String(sessionId || 'opencode').replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
 }
@@ -234,6 +245,19 @@ export default async function HarnessGatePlugin(ctx) {
       if (emergencyGateOff.off) {
         return;
       }
+
+      try {
+        await recordCoachPhase('pre_tool', {
+          sessionId: input.sessionID || process.env.ARIA_SESSION_ID || process.env.OPENCODE_SESSION_ID || 'opencode',
+          toolName,
+          action: toolName === 'Bash' ? String(args?.command || '') : String(args?.file_path || args?.filePath || ''),
+          isDeploy: false,
+          isMutation: ['Edit', 'Write', 'NotebookEdit'].includes(toolName),
+          text: toolName === 'Bash' ? String(args?.command || '').slice(0, 500) : String(args?.file_path || args?.filePath || ''),
+        });
+      } catch (e) {
+        if (e.coachBlock) throw e;
+      }
       const rawToolName = String(input.tool || input.name || input.type || '');
       const normalizedToolName = rawToolName.toLowerCase();
       const toolName = normalizedToolName.includes('bash') ? 'Bash'
@@ -282,6 +306,17 @@ export default async function HarnessGatePlugin(ctx) {
         isMutation: Boolean(isFileMutation),
         evidence: actionRef,
       });
+      // Atlas dossier wire (Phase 1 — corpus-to-runtime, opencode surface).
+      // Fail-open: missing socket / timeout / parse-fail returns [] with a
+      // LOUD stderr line emitted from atlas-dossier-client.
+      let dossierGoverningSkills = [];
+      if (filePath && typeof filePath === 'string' && filePath.trim()) {
+        try {
+          dossierGoverningSkills = await fetchGoverningSkills(filePath);
+        } catch (err) {
+          process.stderr.write(`[opencode-harness-gate:atlas-dossier-error] ${err instanceof Error ? err.message : String(err)}\n`);
+        }
+      }
       const skillGate = evaluateSkillGate({
         sessionId,
         surface: 'opencode-harness-gate',
@@ -292,6 +327,7 @@ export default async function HarnessGatePlugin(ctx) {
         isDeploy: Boolean(deploy),
         isMutation: Boolean(isFileMutation),
         autoLoadAvailable: false,
+        additionalRequiredSkills: dossierGoverningSkills,
       });
       if (!skillGate.ok && !skillGate.redirectOnly) {
         throw new Error(

package/opencode-plugins/harness-gate/lib/atlas-dossier-client.js

@@ -0,0 +1 @@
+export * from '../../../hooks/lib/atlas-dossier-client.mjs';

package/opencode-plugins/harness-gate/lib/recovery-grants.js

@@ -0,0 +1,79 @@
+/**
+ * Recovery Grant System — owner/client grants additional recovery attempts.
+ * Grants stored at ~/.aria/recovery-grants/<sessionId>.json, expire after 30min.
+ */
+
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const HOME = homedir();
+const RECOVERY_GRANTS_DIR = join(HOME, '.aria', 'recovery-grants');
+const GRANT_MAX_AGE_MS = 30 * 60 * 1000;
+
+function sanitize(sessionId) {
+  return String(sessionId || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_');
+}
+
+export function loadRecoveryGrant(sessionId) {
+  if (!sessionId) return null;
+  try { mkdirSync(RECOVERY_GRANTS_DIR, { recursive: true, mode: 0o755 }); } catch {}
+  const grantPath = join(RECOVERY_GRANTS_DIR, `${sanitize(sessionId)}.json`);
+  if (!existsSync(grantPath)) return null;
+  try {
+    const raw = JSON.parse(readFileSync(grantPath, 'utf8'));
+    const created = raw.created_at ? Date.parse(raw.created_at) : null;
+    if (created && (Date.now() - created) > GRANT_MAX_AGE_MS) {
+      try { unlinkSync(grantPath); } catch {}
+      return null;
+    }
+    const remaining = raw.remaining_attempts != null ? Number(raw.remaining_attempts) : Number(raw.additional_attempts || 0);
+    if (remaining <= 0) { try { unlinkSync(grantPath); } catch {} return null; }
+    return {
+      grantedBy: raw.granted_by || 'unknown',
+      additionalAttempts: Number(raw.additional_attempts) || 0,
+      remainingAttempts: remaining,
+      reason: raw.reason || 'no reason',
+      fingerprint: raw.fingerprint || null,
+      grantPath,
+      raw,
+    };
+  } catch { return null; }
+}
+
+export function consumeRecoveryGrant(grant) {
+  if (!grant?.grantPath) return 0;
+  const updated = {
+    ...grant.raw,
+    remaining_attempts: Math.max(0, grant.remainingAttempts - 1),
+    last_consumed_at: new Date().toISOString(),
+  };
+  try {
+    if (updated.remaining_attempts <= 0) {
+      unlinkSync(grant.grantPath);
+      return 0;
+    }
+    writeFileSync(grant.grantPath, JSON.stringify(updated, null, 2) + '\n');
+    return updated.remaining_attempts;
+  } catch { return grant.remainingAttempts; }
+}
+
+export function formatRecoveryGrantMessage(grant) {
+  if (!grant) return '';
+  return [
+    '', '=== RECOVERY GRANT ACTIVE ===',
+    `granted_by: ${grant.grantedBy}`,
+    `remaining: ${grant.remainingAttempts}`,
+    `reason: ${grant.reason}`,
+  ].join('\n');
+}
+
+export function tryApplyRecoveryGrant(sessionId) {
+  const grant = loadRecoveryGrant(sessionId);
+  if (!grant) return null;
+  const remaining = consumeRecoveryGrant(grant);
+  if (remaining <= 0 && grant.remainingAttempts <= 1) {
+    return formatRecoveryGrantMessage(grant) + '\n\nLast attempt consumed.';
+  }
+  return formatRecoveryGrantMessage(grant);
+}

package/opencode-plugins/harness-outcome/index.js

@@ -8,6 +8,7 @@ import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { updateTaskProjectLedger } from '../harness-context/task-project-ledger.mjs';
 import { resolveAriaAuthToken } from '../harness-context/auth-token.mjs';
+import { recordCoachPhase } from '../lib/coach.js';
 
 const HOME = homedir();
 const SDK_CANDIDATES = [
@@ -107,6 +108,17 @@ export default async function HarnessOutcomePlugin(ctx) {
       const sessionId = process.env.ARIA_SESSION_ID || 'opencode';
       const filePath = toolName !== 'Bash' ? String(input.args?.file_path ?? input.args?.notebook_path ?? '') : '';
       await releaseHiveLease(sessionId, filePath ? [filePath] : []);
+      // Coach post-tool phase
+      try {
+        await recordCoachPhase('post_tool', {
+          sessionId,
+          toolName,
+          action: actionTarget,
+          text: String(output?.stdout || output?.stderr || '').slice(0, 500),
+        });
+      } catch (e) {
+        if (e.coachBlock) throw e;
+      }
       const outcomeRef = makeEvidenceRef('opencode_tool_outcome', {
         toolName,
         actionKind,

package/opencode-plugins/harness-stop/index.js

@@ -9,14 +9,20 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { analyzeDomainOutputQuality, extractCodeBlocks } from './lib/domain-output-quality.js';
 import { evaluateSkillGate, formatSkillGateBlock } from './lib/skill-autoload-gate.js';
+// Atlas dossier client — Phase 1B v2 mirror on opencode harness-stop surface.
+// Walks recent file edits, parallel-fetches dossier, unions governing skills.
+// Re-exported from connector hooks/lib via shim. Added 2026-05-17.
+import { fetchGoverningSkills } from './lib/atlas-dossier-client.js';
 import {
   evaluateTaskProjectClaim,
   recordBlockedTaskProjectClaim,
   updateTaskProjectLedger,
 } from '../harness-context/task-project-ledger.mjs';
 import { resolveAriaAuthToken } from '../harness-context/auth-token.mjs';
+import { recordCoachPhase } from '../lib/coach.js';
+import { runEndOfPhaseQaAutofire } from '../../hooks/lib/end-phase-qa-autofire.mjs';
 
-const HOME = homedir();
+const HOME = process.env.ARIA_HOME || process.env.HOME || homedir();
 const SDK_CANDIDATES = [
   join(HOME, '.aria', 'sdk', 'index.js'),
   join(HOME, '.codex', 'aria-sdk', 'index.js'),
@@ -437,12 +443,55 @@ export default async function HarnessStopPlugin(ctx) {
       isOutputCloseout: true,
       evidence: makeEvidenceRef('opencode_assistant_output_candidate', text.slice(0, 8000), { sessionId }),
     });
+    // Atlas dossier wire (Phase 1B v2 — opencode Stop surface). Walks recent
+    // Edit/Write tool_use entries (capped at 5), parallel-fetches Atlas
+    // governing_skills, unions, passes as additionalRequiredSkills.
+    const STOP_MAX_FILES = 5;
+    let stopDossierGoverningSkills = [];
+    try {
+      const FILE_EDIT_TOOLS = new Set(['Edit', 'Write', 'MultiEdit', 'NotebookEdit']);
+      const touched = [];
+      const seenPaths = new Set();
+      const msgs = Array.isArray(eventContext?.messages) ? eventContext.messages : [];
+      outer: for (let i = msgs.length - 1; i >= 0; i--) {
+        const m = msgs[i];
+        const content = Array.isArray(m?.content) ? m.content : [];
+        for (let j = content.length - 1; j >= 0; j--) {
+          const block = content[j];
+          if (block && block.type === 'tool_use' && FILE_EDIT_TOOLS.has(block.name)) {
+            const fp = block.input?.file_path || block.input?.notebook_path;
+            if (typeof fp === 'string' && fp.trim()) {
+              const norm = fp.trim();
+              if (!seenPaths.has(norm)) {
+                seenPaths.add(norm);
+                touched.push(norm);
+                if (touched.length >= STOP_MAX_FILES) break outer;
+              }
+            }
+          }
+        }
+      }
+      if (touched.length > 0) {
+        const results = await Promise.all(touched.map((p) => fetchGoverningSkills(p)));
+        const unioned = new Set();
+        for (const arr of results) {
+          for (const s of Array.isArray(arr) ? arr : []) {
+            if (typeof s === 'string' && s.trim()) unioned.add(s.trim());
+          }
+        }
+        stopDossierGoverningSkills = [...unioned];
+      }
+    } catch (err) {
+      process.stderr.write(`[opencode-harness-stop:atlas-dossier-error] ${err instanceof Error ? err.message : String(err)}\n`);
+    }
+
     const skillGate = evaluateSkillGate({
       sessionId,
       surface: 'opencode-harness-stop',
       text: JSON.stringify(eventContext || {}) + '\n' + text,
       isOutputCloseout: true,
       autoLoadAvailable: false,
+      additionalRequiredSkills: stopDossierGoverningSkills,
     });
     if (!skillGate.ok && !skillGate.redirectOnly) {
       emitRecoverableOutput(formatBlockReason('=== ARIA SKILL AUTOLOAD GATE BLOCK ===', formatSkillGateBlock(skillGate)), { source: 'opencode-stop/skill-autoload', sessionId });
@@ -485,6 +534,28 @@ export default async function HarnessStopPlugin(ctx) {
       process.stderr.write(`[harness-stop] mizan/post unavailable: ${e.message}\n`);
     }
 
+    const endPhaseQaAutofire = runEndOfPhaseQaAutofire({
+      sessionId,
+      phase: 'opencode-stop-phase-close',
+      trigger: 'phase_close',
+      text,
+      qaKernel: {
+        ok: true,
+        hardBlock: false,
+        lensCount: cog.count,
+        skillGateOk: skillGate.ok === true || skillGate.redirectOnly === true,
+      },
+      validation: {
+        pass: true,
+        validation: { passed: true },
+        layer3: { pass: true },
+      },
+      postReceipt: _lastMizanReceipt,
+      outputRef,
+      ledger: ledgerResult.ledger,
+      source: 'opencode-harness-stop',
+    });
+
     const client = await getClient();
     if (client) {
       try {
@@ -578,6 +649,11 @@ export default async function HarnessStopPlugin(ctx) {
           pre_receipt_id: existing?.receipt?.receiptId || null,
           post_receipt_id: _lastMizanReceipt?.receiptId || null,
           output_ref: outputRef,
+          end_phase_qa_autofire: {
+            verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+            receipt_hash: endPhaseQaAutofire.receipt.receipt_hash,
+            latest_path: endPhaseQaAutofire.latestPath,
+          },
         },
         source: 'opencode-stop-gate-runtime',
         model_used: process.env.OPENCODE_MODEL || 'opencode',
@@ -591,6 +667,11 @@ export default async function HarnessStopPlugin(ctx) {
           post_turn: true,
           output_ref: outputRef,
           verification: false,
+          end_phase_qa_autofire: {
+            verdict: endPhaseQaAutofire.receipt.claim_gate.verdict,
+            receipt_hash: endPhaseQaAutofire.receipt.receipt_hash,
+            latest_path: endPhaseQaAutofire.latestPath,
+          },
         },
       });
     } catch (e) {
@@ -614,7 +695,21 @@ export default async function HarnessStopPlugin(ctx) {
     },
 
     'experimental.text.complete': async (input, output) => {
-      await validateText(String(output?.text || ''), input || {});
+      const outputText = String(output?.text || '');
+      if (classifyContinuationHandoff(outputText).isContinuation) {
+        await validateText(outputText, input || {});
+        return;
+      }
+      // Coach post-cognition phase
+      try {
+        await recordCoachPhase('post_cognition', {
+          sessionId: input?.sessionID || process.env.ARIA_SESSION_ID || process.env.OPENCODE_SESSION_ID || 'opencode',
+          text: outputText.slice(0, 500),
+        });
+      } catch (e) {
+        if (e.coachBlock) throw e;
+      }
+      await validateText(outputText, input || {});
     },
   };
 }

package/opencode-plugins/harness-stop/lib/atlas-dossier-client.js

@@ -0,0 +1 @@
+export * from '../../../hooks/lib/atlas-dossier-client.mjs';

package/opencode-plugins/harness-stop/lib/domain-output-quality.js

@@ -36,6 +36,19 @@ function hasAny(text, patterns) {
   return patterns.some((pattern) => pattern.test(text));
 }
 
+function hasAestheticClaim(text) {
+  const source = String(text || '');
+  if (/\b(?:beautiful|polished|sleek|aesthetic|elegant)\b/i.test(source)) return true;
+  return /\b(?:clean|modern|nice)\b/i.test(source) &&
+    /\b(?:ui|ux|visual|design|layout|brand|screen|page|typography|spacing|palette|composition)\b/i.test(source);
+}
+
+function hasUiDesignObligation(source, userText = '') {
+  const combined = `${String(userText || '')}\n${String(source || '')}`;
+  return /\b(?:build|design|implement|create|style|layout|frontend|component|screen|page|modal|form|button|accessibility|responsive|mobile|desktop|css|tailwind|react)\b/i.test(combined) &&
+    !/\b(?:ui surfaces respond|endpoint or ui surfaces|screenshots? of the exact flows|marketing proof|smoke run)\b/i.test(combined);
+}
+
 function lineHits(text, rx, label) {
   const hits = [];
   const lines = String(text || '').split('\n');
@@ -66,14 +79,14 @@ export function analyzeDomainOutputQuality(text, options = {}) {
     }
   }
 
-  if (domains.includes('ui')) {
+  if (domains.includes('ui') && hasUiDesignObligation(source)) {
     if (!hasAny(source, [/\b(?:mobile|responsive|breakpoint|small screen|desktop)\b/i])) blockers.push('ui: UI/design output must address desktop and mobile responsiveness');
     if (!hasAny(source, [/\b(?:accessib|aria-|keyboard|focus|screen reader|semantic html|label)\b/i])) blockers.push('ui: UI/design output must address accessibility, focus, labels, or semantic structure');
     if (/\b(?:button|input|form|modal|menu|dialog)\b/i.test(source) && !/\b(?:focus|keyboard|aria-|label|escape|tab order)\b/i.test(source)) blockers.push('ui: interactive elements need keyboard/focus/accessibility behavior');
   }
 
   if (domains.includes('beauty')) {
-    if (/\b(?:clean|modern|beautiful|polished|nice|sleek)\b/i.test(source) && !hasAny(source, [/\b(?:spacing|typography|contrast|hierarchy|rhythm|composition|palette|motion|density|visual language)\b/i])) blockers.push('beauty: aesthetic claim lacks concrete visual language such as spacing, typography, contrast, hierarchy, palette, or composition');
+    if (hasAestheticClaim(source) && !hasAny(source, [/\b(?:spacing|typography|contrast|hierarchy|rhythm|composition|palette|motion|density|visual language)\b/i])) blockers.push('beauty: aesthetic claim lacks concrete visual language such as spacing, typography, contrast, hierarchy, palette, or composition');
   }
 
   if (domains.includes('security')) {

package/opencode-plugins/lib/coach.js

@@ -0,0 +1,148 @@
+/**
+ * Shared Coach Phase — injectable into any OpenCode plugin lifecycle hook.
+ *
+ * Coach phases mapped to OpenCode hooks:
+ *   pre-turn      → harness-context plugin load
+ *   pre-tool      → harness-gate tool.execute.before
+ *   post-tool     → harness-outcome tool.execute.after
+ *   post-cognition → harness-stop experimental.text.complete
+ *   intra-turn    → consecutive tool.execute.before calls
+ */
+
+import { resolveAriaAuthToken } from '../harness-context/auth-token.mjs';
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+
+const HOME = homedir();
+const COACH_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
+const COACH_DIRECTIVES_PATH = join(HOME, '.aria', 'runtime', 'state', 'coach-pending-directives.json');
+const _cache = { lastPhase: null, lastAt: 0, lastResult: null };
+const COOLDOWN_MS = 2000;
+
+function resolveToken() {
+  return resolveAriaAuthToken({ baseUrl: COACH_URL }).token;
+}
+
+function remoteCoachEnabled() {
+  return /^(?:1|true|yes|on)$/i.test(String(
+    process.env.ARIA_REMOTE_COACH_ENABLED ||
+    process.env.ARIA_RUNTIME_COACH_ENABLED ||
+    process.env.ARIA_COACH_REMOTE_ENABLED ||
+    ''
+  ));
+}
+
+export async function recordCoachPhase(phase, ctx = {}) {
+  const now = Date.now();
+  if (_cache.lastPhase === phase && (now - _cache.lastAt) < COOLDOWN_MS) {
+    return _cache.lastResult;
+  }
+  _cache.lastPhase = phase;
+  _cache.lastAt = now;
+  _cache.lastResult = null;
+  if (!remoteCoachEnabled()) {
+    _cache.lastResult = {
+      ok: true,
+      skipped: true,
+      permitted: true,
+      decision: 'allow',
+      phase,
+      reasons: ['remote_coach_disabled'],
+    };
+    return _cache.lastResult;
+  }
+  try {
+    const token = resolveToken();
+    if (!token) return null;
+    const resp = await fetch(`${COACH_URL}/coach/phase`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` },
+      body: JSON.stringify({
+        phase,
+        platform: 'opencode',
+        surface: 'opencode-harness',
+        requestId: `opencode:${phase}:${Date.now()}`,
+        text: ctx.text || ctx.action || '',
+        action: ctx.action || '',
+        metadata: {
+          sessionId: ctx.sessionId,
+          toolName: ctx.toolName || null,
+          isDeploy: ctx.isDeploy || false,
+          isMutation: ctx.isMutation || false,
+          source: 'opencode-plugin-coach',
+        },
+      }),
+      signal: AbortSignal.timeout(3000),
+    });
+    if (!resp.ok) return null;
+    const body = await resp.json().catch(() => null);
+    _cache.lastResult = body;
+    if (body?.permitted === false) {
+      const err = new Error(
+        `=== ARIA COACH BLOCK: ${phase} ===\n\n` +
+        `${body.clientMessage || body.reason || 'Coach kernel denied.'}\n\n` +
+        'Recovery: 1. Do not retry unchanged. 2. Add required evidence/cognition. 3. Re-submit.'
+      );
+      err.coachBlock = true;
+      throw err;
+    }
+    if (body?.skillDirectives?.length) {
+      process.stderr.write(`[coach] ${phase} skills: ${body.skillDirectives.join(', ')}\n`);
+    }
+    if (body?.skillDirectives?.length || body?.clientMessage || body?.coachingContext) {
+      savePendingDirectives(phase, ctx.sessionId, body);
+    }
+    return body;
+  } catch (e) {
+    if (e.coachBlock) throw e;
+    process.stderr.write(`[coach] ${phase} unavailable: ${e.message}\n`);
+    return null;
+  }
+}
+
+function savePendingDirectives(phase, sessionId, body) {
+  try {
+    mkdirSync(join(HOME, '.aria', 'runtime', 'state'), { recursive: true, mode: 0o700 });
+    const existing = existsSync(COACH_DIRECTIVES_PATH)
+      ? JSON.parse(readFileSync(COACH_DIRECTIVES_PATH, 'utf8'))
+      : { directives: [], updatedAt: null };
+    const entry = {
+      phase,
+      sessionId: sessionId || 'opencode',
+      at: new Date().toISOString(),
+      skills: body.skillDirectives || [],
+      message: body.clientMessage || null,
+      context: body.coachingContext || null,
+    };
+    existing.directives = [...(existing.directives || []), entry].slice(-10);
+    existing.updatedAt = entry.at;
+    writeFileSync(COACH_DIRECTIVES_PATH, JSON.stringify(existing, null, 2) + '\n', { mode: 0o600 });
+  } catch {}
+}
+
+export function getPendingCoachDirectives() {
+  if (!existsSync(COACH_DIRECTIVES_PATH)) return '';
+  try {
+    const raw = JSON.parse(readFileSync(COACH_DIRECTIVES_PATH, 'utf8'));
+    const directives = Array.isArray(raw.directives) ? raw.directives : [];
+    if (!directives.length) return '';
+    const recent = directives.slice(-5);
+    const skills = [...new Set(recent.flatMap((d) => d.skills || []))];
+    const messages = recent.map((d) => d.message).filter(Boolean);
+    const parts = [];
+    if (skills.length) {
+      parts.push(`[COACH SKILLS REQUIRED]\nCoach kernel requires: ${skills.join(', ')}. Apply them in your thinking and responses.`);
+    }
+    if (messages.length) {
+      parts.push(`[COACH DIRECTIVES]\n${messages.slice(-3).join('\n\n')}`);
+    }
+    return parts.length ? '\n\n' + parts.join('\n\n') + '\n\n[COACH]\nApply directives. Verify claims. No shortcuts.' : '';
+  } catch {
+    return '';
+  }
+}
+
+export function clearPendingCoachDirectives() {
+  try { if (existsSync(COACH_DIRECTIVES_PATH)) unlinkSync(COACH_DIRECTIVES_PATH); } catch {}
+}