@aria_asi/cli 0.2.32 → 0.2.34

package/opencode-plugins/harness-gate/lib/skill-autoload-gate.js

@@ -0,0 +1,14 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+const RECEIPT_ROOT = process.env.ARIA_SKILL_RECEIPT_DIR || join(tmpdir(), 'aria-skill-receipts');
+const ALIASES = new Map([['deploy', 'aria-harness-deploy'], ['output', 'aria-harness-output-discipline'], ['repo', 'aria-repo-doctrine'], ['forge', 'aria-forge-guardrails']]);
+const RX = { deploy: /deploy-service\.sh|kubectl\s+(?:apply|set|rollout|delete|scale)|helm\s+upgrade|terraform\s+apply|docker\s+push/i, mutationTool: /^(?:edit|write|notebookedit|patch|apply_patch)$/i, mutation: /apply_patch|write file|edit file|modify|delete file|migration|handler|route|runtime|hook|plugin|\btest\b|smoke script/i, strip: /remove|delete|strip|drop|omit|disable|bypass|skip|stub|mock|fake|placeholder|temporary|quick scaffold|band-aid/i, readiness: /production-ready|ready for production|works in general|general readiness|client packages?|npm packages?|SDKs?|runtimes?|harnesses?|release-ready|ship-ready/i, narrow: /single flow|one flow|narrow e2e|covered flow|specific path|widget flow/i, completion: /done|complete|completed|ready|verified|fixed|shipped|implemented|production-ready/i, badProof: /but|except|caveat|remaining|not yet|still|separate|later|blocked|skipped|unresolved|follow-up|failed|failing|error|red|not run|could not verify|untested|no proof|missing proof|without proof/i, advisory: /non-blocking|warning only|warn only|advisory|fall through|falls through|fail open|soft fail|logged and continue|quality gate warning/i, success: /(?:verified|passed|success|successful|green|ok)\s*[:=\-].{0,120}(?:npm|node|playwright|jest|vitest|build|test|lint|typecheck|curl|kubectl|self-test|e2e|probe|smoke)|(?:npm|node|playwright|jest|vitest|build|test|lint|typecheck|curl|kubectl).{0,120}(?:passed|success|successful|green|exit\s*0)/i, resubmit: /re-?submission|resubmit/i, rewrite: /re-?write|rewrite|fix/i, retest: /re-?test|retest|rerun/i, aria: /ARIA console|Aria console|\/chat|aria-pipeline-mcp|aria_chat|escalat(?:e|ion).{0,80}ARIA/i };
+function normalizeSkillName(skill) { return ALIASES.get(String(skill || '').trim()) || String(skill || '').trim(); }
+function sessionDir(sessionId) { return join(RECEIPT_ROOT, encodeURIComponent(String(sessionId || 'unknown'))); }
+function readReceiptSkills(sessionId) { const dir = sessionDir(sessionId); if (!existsSync(dir)) return new Set(); const skills = new Set(); for (const name of readdirSync(dir)) { if (!name.endsWith('.json')) continue; try { const receipt = JSON.parse(readFileSync(join(dir, name), 'utf8')); if (receipt?.skill) skills.add(normalizeSkillName(receipt.skill)); } catch {} } return skills; }
+function readInlineSkills(text) { const skills = new Set(); const value = String(text || ''); for (const match of value.matchAll(/<skill_content\s+name=["']([^"']+)["']/gi)) skills.add(normalizeSkillName(match[1])); return skills; }
+export function recordSkillLoaded({ sessionId, skill, surface = 'unknown', metadata = {} } = {}) { const normalized = normalizeSkillName(skill); if (!normalized) throw new Error('recordSkillLoaded requires a skill name'); const dir = sessionDir(sessionId); mkdirSync(dir, { recursive: true }); const receipt = { skill: normalized, surface, metadata, recordedAt: new Date().toISOString() }; writeFileSync(join(dir, `${encodeURIComponent(normalized)}.json`), `${JSON.stringify(receipt, null, 2)}\n`); return receipt; }
+export function classifyRequiredSkills({ text = '', action = '', toolName = '', filePath = '', isDeploy = false, isMutation = false, isOutputCloseout = false } = {}) { const combined = [text, action, toolName, filePath].filter(Boolean).join('\n'); const required = new Set(); const reasons = []; const recoveryMissing = []; if (isDeploy || RX.deploy.test(combined)) { required.add('aria-harness-deploy'); required.add('aria-forge-guardrails'); reasons.push('deploy/shared-infrastructure action requires fail-closed deploy and forge guardrails'); } if (isMutation || RX.mutationTool.test(toolName)) { required.add('aria-repo-doctrine'); reasons.push('repository/runtime mutation requires repo doctrine'); } if (RX.strip.test(combined)) { required.add('aria-harness-no-stripping'); reasons.push('strip/remove/bypass language requires no-stripping gate'); } if (isOutputCloseout && RX.completion.test(combined)) { required.add('aria-harness-output-discipline'); reasons.push('owner-facing completion/readiness claim requires output discipline'); if (!RX.success.test(combined)) recoveryMissing.push('successful proof from a concrete command/probe'); } if (RX.readiness.test(combined)) { required.add('architecture-decision'); required.add('testing-strategy'); required.add('aria-forge-guardrails'); required.add('aria-harness-output-discipline'); reasons.push('broad production/package/SDK/runtime readiness claim requires architecture, testing, and forge guardrails'); } if (RX.readiness.test(combined) && RX.narrow.test(combined)) { required.add('testing-strategy'); required.add('aria-forge-guardrails'); reasons.push('narrow e2e proof cannot support broad readiness claim without readiness-matrix discipline'); } if (RX.completion.test(combined) && RX.badProof.test(combined)) { required.add('aria-harness-output-discipline'); required.add('aria-forge-guardrails'); reasons.push('completion claim with unresolved or failed proof requires recovery cycle'); if (!RX.resubmit.test(combined)) recoveryMissing.push('re-submission'); if (!RX.rewrite.test(combined)) recoveryMissing.push('re-write'); if (!RX.retest.test(combined)) recoveryMissing.push('re-test'); if (!RX.aria.test(combined)) recoveryMissing.push('ARIA console escalation'); } if (RX.advisory.test(combined)) { required.add('aria-forge-guardrails'); required.add('aria-harness-output-discipline'); reasons.push('advisory/fail-open gate language requires fail-closed hardening discipline'); } return { requiredSkills: [...required].sort(), reasons, recoveryMissing }; }
+export function evaluateSkillGate(options = {}) { const classified = classifyRequiredSkills(options); const text = [options.text, options.action].filter(Boolean).join('\n'); const loaded = new Set([...readReceiptSkills(options.sessionId), ...readInlineSkills(text)]); const missingSkills = classified.requiredSkills.filter((skill) => !loaded.has(skill)); const recoveryMissing = classified.recoveryMissing || []; return { ok: missingSkills.length === 0 && recoveryMissing.length === 0, surface: options.surface || 'unknown', sessionId: options.sessionId || 'unknown', requiredSkills: classified.requiredSkills, loadedSkills: [...loaded].sort(), missingSkills, recoveryMissing, reasons: classified.reasons, autoLoadAvailable: options.autoLoadAvailable === true }; }
+export function formatSkillGateBlock(result = {}) { const missing = Array.isArray(result.missingSkills) ? result.missingSkills : []; const recovery = Array.isArray(result.recoveryMissing) ? result.recoveryMissing : []; const reasons = Array.isArray(result.reasons) ? result.reasons : []; return ['=== ARIA SKILL AUTOLOAD GATE BLOCK ===', `surface: ${result.surface || 'unknown'}`, `missing_skills: ${missing.length ? missing.join(', ') : '(none)'}`, `missing_recovery_cycle: ${recovery.length ? recovery.join(', ') : '(none)'}`, `required_skills: ${(result.requiredSkills || []).join(', ') || '(none)'}`, reasons.length ? `reasons: ${reasons.join(' | ')}` : 'reasons: no classifier reason recorded', 'counter_action: re-submit, re-write, re-test, and escalate through ARIA console until successful proof exists. Do not downgrade this to an advisory warning.'].join('\n'); }

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

@@ -3,6 +3,7 @@
  * Routes through the canonical SDK for outcome/garden/ledger writes.
  */
 import { existsSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -14,6 +15,7 @@ const SDK_CANDIDATES = [
 ];
 const OWNER_TOKEN_PATH = join(HOME, '.aria', 'owner-token');
 const LICENSE_PATH = join(HOME, '.aria', 'license.json');
+const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
 
 let _client = null;
 let _clientError = null;
@@ -46,6 +48,32 @@ function resolveSdkPath() {
   return SDK_CANDIDATES.find((candidate) => existsSync(candidate)) || '';
 }
 
+function makeEvidenceRef(kind, value, metadata = {}) {
+  const raw = typeof value === 'string' ? value : JSON.stringify(value ?? null);
+  const sha256 = createHash('sha256').update(raw).digest('hex');
+  return {
+    evidenceId: `ev_${sha256.slice(0, 16)}`,
+    kind,
+    at: new Date().toISOString(),
+    sha256,
+    preview: raw.slice(0, 500),
+    metadata,
+  };
+}
+
+async function releaseHiveLease(sessionId, files) {
+  const token = resolveToken();
+  if (!token || !Array.isArray(files) || files.length === 0) return;
+  await fetch(`${RUNTIME_URL}/hive/release`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${token}`,
+    },
+    body: JSON.stringify({ sessionId, files }),
+  }).catch(() => {});
+}
+
 async function getClient() {
   if (_client) return _client;
   if (_clientError) return null;
@@ -78,6 +106,15 @@ export default async function HarnessOutcomePlugin(ctx) {
         : String(input.args?.file_path ?? input.args?.notebook_path ?? '').slice(0, 200) || 'unknown';
       const success = !output?.error;
       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] : []);
+      const outcomeRef = makeEvidenceRef('opencode_tool_outcome', {
+        toolName,
+        actionKind,
+        actionTarget,
+        success,
+        output: output ?? null,
+      }, { sessionId });
 
       // Try SDK first
       const client = await getClient();
@@ -86,6 +123,7 @@ export default async function HarnessOutcomePlugin(ctx) {
           await client.recordDiscovery({
             text: `${actionKind}: ${actionTarget} — ${success ? 'ok' : 'failed'}`,
             kind: success ? 'observation' : 'defect',
+            evidence: JSON.stringify(outcomeRef),
             source: 'opencode-outcome-plugin',
             resolution_status: success ? 'resolved' : 'open',
             sessionId,
@@ -122,6 +160,7 @@ export default async function HarnessOutcomePlugin(ctx) {
           actionKind,
           actionTarget,
           actionShape: { tool: toolName, success },
+          evidenceRef: outcomeRef,
         }),
       }).catch(() => {});
     },

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

@@ -3,8 +3,12 @@
  * Routes text through Mizan validateOutput() for substrate-backed QC.
  */
 import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { analyzeDomainOutputQuality, extractCodeBlocks } from './lib/domain-output-quality.js';
+import { evaluateSkillGate, formatSkillGateBlock } from './lib/skill-autoload-gate.js';
 
 const HOME = homedir();
 const SDK_CANDIDATES = [
@@ -14,6 +18,7 @@ const SDK_CANDIDATES = [
 ];
 const OWNER_TOKEN_PATH = join(HOME, '.aria', 'owner-token');
 const LICENSE_PATH = join(HOME, '.aria', 'license.json');
+const GOVERNANCE_GATE_PATH = join(HOME, '.aria', 'bin', 'aria-governance-gate');
 const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
 const RECEIPT_DIR = join(HOME, '.opencode', 'aria-mizan-receipts');
 
@@ -46,6 +51,25 @@ function isGateBlock(error) {
   return BLOCK_PREFIX_RX.test(String(error?.message || error || ''));
 }
 
+function runUniversalGovernanceGate(payload) {
+  if (!existsSync(GOVERNANCE_GATE_PATH)) return null;
+  const child = spawnSync(GOVERNANCE_GATE_PATH, {
+    input: `${JSON.stringify(payload)}\n`,
+    encoding: 'utf8',
+    maxBuffer: 1024 * 1024,
+  });
+  const stdout = String(child.stdout || '').trim();
+  let result = null;
+  try { result = stdout ? JSON.parse(stdout) : null; } catch {}
+  if (child.status !== 0 || result?.ok === false || result?.decision === 'block') {
+    throw new Error(
+      `=== ARIA UNIVERSAL GOVERNANCE GATE BLOCK ===\n\n` +
+      `${stdout || child.stderr || 'aria-governance-gate blocked this output.'}`
+    );
+  }
+  return result;
+}
+
 let _client = null;
 let _clientError = null;
 let _lastMizanReceipt = null;
@@ -71,6 +95,19 @@ function persistReceiptState(sessionId, payload) {
   } catch {}
 }
 
+function makeEvidenceRef(kind, value, metadata = {}) {
+  const raw = typeof value === 'string' ? value : JSON.stringify(value ?? null);
+  const sha256 = createHash('sha256').update(raw).digest('hex');
+  return {
+    evidenceId: `ev_${sha256.slice(0, 16)}`,
+    kind,
+    at: new Date().toISOString(),
+    sha256,
+    preview: raw.slice(0, 500),
+    metadata,
+  };
+}
+
 function resolveToken() {
   if (process.env.ARIA_HARNESS_TOKEN) return process.env.ARIA_HARNESS_TOKEN;
   if (process.env.ARIA_API_KEY) return process.env.ARIA_API_KEY;
@@ -137,7 +174,7 @@ async function runtimeValidateOutput(text, sessionId) {
   return payload.validation || payload.result || payload;
 }
 
-async function runtimeMizanPost(text, sessionId, context = {}) {
+async function runtimeMizanPost(text, sessionId, context = {}, evidence = {}) {
   const existing = loadReceiptState(sessionId);
   const token = resolveToken();
   if (!token) throw new Error('no token');
@@ -150,10 +187,22 @@ async function runtimeMizanPost(text, sessionId, context = {}) {
     body: JSON.stringify({
       sessionId,
       text,
+      evidence,
       context: {
         sessionId,
+        actor: 'opencode',
+        system: 'opencode',
+        platform: 'opencode',
+        surface: 'opencode-harness-stop',
         ...context,
       },
+      packetRequest: {
+        stage: 'preflight',
+        actor: 'opencode',
+        system: 'opencode',
+        platform: 'opencode',
+        message: String(context.message || text || '').slice(0, 1000),
+      },
       parentReceiptId: existing?.receipt?.receiptId || _lastMizanReceipt?.receiptId || null,
     }),
   });
@@ -205,160 +254,206 @@ function detectCognitionLenses(text) {
 export default async function HarnessStopPlugin(ctx) {
   process.stderr.write('[harness-stop] Active — SDK-backed text-emission gate\n');
 
-  return {
-    'session.idle': async (event) => {
-      process.stderr.write('  [strip gate registed — session i\n');
-    },
-
-    event: async ({ event }) => {
-      if (event.type !== 'message.updated') return;
-      const parts = event.properties?.parts || [];
-      const text = parts
-        .filter(p => p.type === 'text')
-        .map(p => p.text || '')
-        .join('\n');
+  async function validateText(text, eventContext = {}) {
+    if (!text || text.length < NON_TRIVIAL_MIN_CHARS) return;
+    if (TRIVIAL_ACK_RX.test(text.trim())) return;
 
-      if (!text || text.length < NON_TRIVIAL_MIN_CHARS) return;
-      if (TRIVIAL_ACK_RX.test(text.trim())) return;
+    const cog = detectCognitionLenses(text);
+    const sessionId = eventContext.sessionID || process.env.ARIA_SESSION_ID || process.env.OPENCODE_SESSION_ID || 'opencode';
+    runUniversalGovernanceGate({
+      sessionId,
+      sourceRuntime: 'opencode',
+      surface: 'opencode-harness-stop',
+      text,
+      isOutputCloseout: true,
+      evidence: makeEvidenceRef('opencode_assistant_output_candidate', text.slice(0, 8000), { sessionId }),
+    });
+    const skillGate = evaluateSkillGate({
+      sessionId,
+      surface: 'opencode-harness-stop',
+      text: JSON.stringify(eventContext || {}) + '\n' + text,
+      isOutputCloseout: true,
+      autoLoadAvailable: false,
+    });
+    if (!skillGate.ok) {
+      throw new Error(
+        formatBlockReason(
+          '=== ARIA SKILL AUTOLOAD GATE BLOCK ===',
+          `${formatSkillGateBlock(skillGate)}\nRequired next step: load ${skillGate.missingSkills.join(', ')} before re-emitting this output.`,
+        )
+      );
+    }
+    const outputRef = makeEvidenceRef('opencode_assistant_output', text.slice(0, 8000), { sessionId });
+    try {
+      const mizan = await runtimeMizanPost(text.slice(0, 8000), sessionId, {
+        message: text.slice(0, 1000),
+        plannedApproach: 'OpenCode stop gate output review',
+        outputRef,
+      }, {
+        output_ref: outputRef,
+        cognition_lens_count: cog.count,
+      });
+      _lastMizanReceipt = mizan.receipt || _lastMizanReceipt;
+      if (_lastMizanReceipt) {
+        const existing = loadReceiptState(sessionId) || {};
+        persistReceiptState(sessionId, {
+          ...existing,
+          updatedAt: new Date().toISOString(),
+          sessionId,
+          postReceipt: _lastMizanReceipt,
+          postResult: mizan.result || null,
+          postContract: mizan.contract || null,
+          postSummary: mizan.summary || null,
+          outputRef,
+        });
+      }
+      if (mizan.receipt?.blocked || mizan.result?.fitrahVetoed || mizan.result?.reAuthorSignal) {
+        const details = (mizan.result?.notes || ['post-phase blocked']).slice(0, 4).join(' | ');
+        throw new Error(
+          formatBlockReason('=== ARIA MIZAN POST BLOCK ===', details)
+        );
+      }
+    } catch (e) {
+      if (isGateBlock(e)) throw e;
+      process.stderr.write(`[harness-stop] mizan/post unavailable: ${e.message}\n`);
+    }
 
-      const cog = detectCognitionLenses(text);
-      const sessionId = process.env.ARIA_SESSION_ID || 'opencode';
+    const client = await getClient();
+    if (client) {
       try {
-        const mizan = await runtimeMizanPost(text.slice(0, 8000), sessionId, {
-          message: text.slice(0, 1000),
-          plannedApproach: 'OpenCode stop gate output review',
-        });
-        _lastMizanReceipt = mizan.receipt || _lastMizanReceipt;
-        if (_lastMizanReceipt) {
-          const existing = loadReceiptState(sessionId) || {};
-          persistReceiptState(sessionId, {
-            ...existing,
-            updatedAt: new Date().toISOString(),
-            sessionId,
-            postReceipt: _lastMizanReceipt,
-            postResult: mizan.result || null,
-            postContract: mizan.contract || null,
-            postSummary: mizan.summary || null,
-          });
-        }
-        if (mizan.receipt?.blocked || mizan.result?.fitrahVetoed || mizan.result?.reAuthorSignal) {
-          const details = (mizan.result?.notes || ['post-phase blocked']).slice(0, 4).join(' | ');
+        const result = await runtimeValidateOutput(
+          text.slice(0, 8000),
+          sessionId,
+        ).catch(() => client.validateOutput(
+          text.slice(0, 8000),
+          sessionId,
+        ));
+        if (result.severity === 'block') {
+          throw new Error(
+            formatBlockReason(
+              '=== ARIA OUTPUT GATE BLOCK ===',
+              `${result.violations.length} violations: ${result.violations.join('; ').slice(0, 500)}`,
+            )
+          );
+        } else if (result.severity === 'warn') {
           throw new Error(
-            formatBlockReason('=== ARIA MIZAN POST BLOCK ===', details)
+            formatBlockReason(
+              '=== ARIA OUTPUT GATE BLOCK ===',
+              `SDK returned warn for ${result.violations.length} violation(s): ${(result.violations || []).join('; ').slice(0, 500)}. Warnings are fail-closed on owner-facing output.`,
+            )
           );
         }
+        if (result.gateTriggers?.length) {
+          process.stderr.write(`[harness-stop] SDK triggers: ${result.gateTriggers.join(', ')}\n`);
+        }
+        return;
       } catch (e) {
         if (isGateBlock(e)) throw e;
-        process.stderr.write(`[harness-stop] mizan/post unavailable: ${e.message}\n`);
+        process.stderr.write(`[harness-stop] SDK validateOutput failed: ${e.message} — falling through to local gate\n`);
       }
+    }
 
-      // Try SDK validateOutput() — Mizan classifier-backed validation
-      const client = await getClient();
-      if (client) {
-        try {
-          const result = await runtimeValidateOutput(
-            text.slice(0, 8000),
-            sessionId,
-          ).catch(() => client.validateOutput(
-            text.slice(0, 8000),
-            sessionId,
-          ));
-          if (result.severity === 'block') {
-            throw new Error(
-              formatBlockReason(
-                '=== ARIA OUTPUT GATE BLOCK ===',
-                `${result.violations.length} violations: ${result.violations.join('; ').slice(0, 500)}`,
-              )
-            );
-          } else if (result.severity === 'warn') {
-            process.stderr.write(
-              `[harness-stop] SDK WARN — ${result.violations.length} violations (non-blocking)\n`
-            );
-          }
-          // Log gate triggers
-          if (result.gateTriggers?.length) {
-            process.stderr.write(`[harness-stop] SDK triggers: ${result.gateTriggers.join(', ')}\n`);
-          }
-          return;
-        } catch (e) {
-          if (isGateBlock(e)) throw e;
-          process.stderr.write(`[harness-stop] SDK validateOutput failed: ${e.message} — falling through to local gate\n`);
+    const triggerMapPaths = [
+      `${HOME}/.aria/runtime/discipline/doctrine_trigger_map.json`,
+      `${HOME}/.aria/runtime/doctrine_trigger_map.json`,
+      `${HOME}/.opencode/doctrine_trigger_map.json`,
+      `${HOME}/.codex/doctrine_trigger_map.json`,
+      `${HOME}/.claude/hooks/doctrine_trigger_map.json`,
+      `${HOME}/.claude/projects/-home-hamzaibrahim1/memory/doctrine_trigger_map.json`,
+    ];
+    let driftHits = [];
+    try {
+      const triggerMapPath = triggerMapPaths.find((candidate) => existsSync(candidate));
+      if (triggerMapPath) {
+        const triggerMap = JSON.parse(readFileSync(triggerMapPath, 'utf8'));
+        const lower = text.toLowerCase();
+        for (const t of triggerMap.triggers || []) {
+          try {
+            const rx = new RegExp(t.trigger, 'i');
+            if (rx.test(lower)) {
+              const memCited = t.memory && lower.includes(t.memory.replace(/\.md$/, '').toLowerCase());
+              if (!memCited) driftHits.push(t.trigger);
+            }
+          } catch {}
         }
       }
+    } catch {}
 
-      // Local fallback gate
-      // Scan drift triggers
-      const triggerMapPaths = [
-        `${HOME}/.aria/runtime/discipline/doctrine_trigger_map.json`,
-        `${HOME}/.aria/runtime/doctrine_trigger_map.json`,
-        `${HOME}/.opencode/doctrine_trigger_map.json`,
-        `${HOME}/.codex/doctrine_trigger_map.json`,
-        `${HOME}/.claude/hooks/doctrine_trigger_map.json`,
-        `${HOME}/.claude/projects/-home-hamzaibrahim1/memory/doctrine_trigger_map.json`,
-      ];
-      let driftHits = [];
-      try {
-        const triggerMapPath = triggerMapPaths.find((candidate) => existsSync(candidate));
-        if (triggerMapPath) {
-          const triggerMap = JSON.parse(readFileSync(triggerMapPath, 'utf8'));
-          const lower = text.toLowerCase();
-          for (const t of triggerMap.triggers || []) {
-            try {
-              const rx = new RegExp(t.trigger, 'i');
-              if (rx.test(lower)) {
-                const memCited = t.memory && lower.includes(t.memory.replace(/\.md$/, '').toLowerCase());
-                if (!memCited) driftHits.push(t.trigger);
-              }
-            } catch {}
-          }
-        }
-      } catch {}
+    if (cog.count < REQUIRED_LENSES || driftHits.length >= 2) {
+      throw new Error(
+        formatBlockReason(
+          '=== ARIA LOCAL OUTPUT BLOCK ===',
+          `cognition=${cog.count}/${REQUIRED_LENSES}; drift=${driftHits.length}`,
+        )
+      );
+    }
 
-      if (cog.count < REQUIRED_LENSES || driftHits.length >= 2) {
-        throw new Error(
-          formatBlockReason(
-            '=== ARIA LOCAL OUTPUT BLOCK ===',
-            `cognition=${cog.count}/${REQUIRED_LENSES}; drift=${driftHits.length}`,
-          )
-        );
-      }
+    if (DECISION_SIGNAL_RX.test(text) && !APPLIED_COGNITION_RX.test(text)) {
+      throw new Error(
+        formatBlockReason(
+          '=== ARIA LOCAL OUTPUT BLOCK ===',
+          'decision-bearing output lacks required applied_cognition binding fields',
+        )
+      );
+    }
 
-      if (DECISION_SIGNAL_RX.test(text) && !APPLIED_COGNITION_RX.test(text)) {
-        throw new Error(
-          formatBlockReason(
-            '=== ARIA LOCAL OUTPUT BLOCK ===',
-            'decision-bearing output lacks required applied_cognition binding fields',
-          )
-        );
-      }
+    const domainQuality = analyzeDomainOutputQuality(text, { codeBlocks: extractCodeBlocks(text) });
+    if (domainQuality.blockers.length > 0) {
+      throw new Error(
+        formatBlockReason(
+          '=== ARIA LOCAL OUTPUT BLOCK ===',
+          `domain output QA (${domainQuality.domains.join(', ') || 'general'}): ${domainQuality.blockers.join('; ')}`,
+        )
+      );
+    }
 
-      try {
-        const existing = loadReceiptState(sessionId);
-        await runtimeDecisionLog({
-          decision_type: 'turn_action',
-          category: 'agentic_execution',
-          context: `opencode stop-gate turn (chars=${text.length})`,
-          decision: 'turn completed',
-          reasoning: cog.count > 0
-            ? `Cognition lenses applied: ${cog.names.join(', ')}.`
-            : 'No explicit cognition block in turn.',
-          outcome: 'pending',
-          outcome_details: {
-            expected: null,
-            immediate_actual: null,
-            anchors: [],
-          },
-          expected_outcome: null,
-          metadata: {
-            pre_receipt_id: existing?.receipt?.receiptId || null,
-            post_receipt_id: _lastMizanReceipt?.receiptId || null,
-          },
-          source: 'opencode-stop-gate-runtime',
-          model_used: process.env.OPENCODE_MODEL || 'opencode',
-        });
-      } catch (e) {
-        process.stderr.write(`[harness-stop] decision/log unavailable: ${e.message}\n`);
-      }
+    try {
+      const existing = loadReceiptState(sessionId);
+      await runtimeDecisionLog({
+        decision_type: 'turn_action',
+        category: 'agentic_execution',
+        context: `opencode stop-gate turn (chars=${text.length})`,
+        decision: 'turn completed',
+        reasoning: cog.count > 0
+          ? `Cognition lenses applied: ${cog.names.join(', ')}.`
+          : 'No explicit cognition block in turn.',
+        outcome: 'pending',
+        outcome_details: {
+          expected: null,
+          immediate_actual: null,
+          anchors: [],
+        },
+        expected_outcome: null,
+        metadata: {
+          pre_receipt_id: existing?.receipt?.receiptId || null,
+          post_receipt_id: _lastMizanReceipt?.receiptId || null,
+          output_ref: outputRef,
+        },
+        source: 'opencode-stop-gate-runtime',
+        model_used: process.env.OPENCODE_MODEL || 'opencode',
+      });
+    } catch (e) {
+      process.stderr.write(`[harness-stop] decision/log unavailable: ${e.message}\n`);
+    }
+  }
+
+  return {
+    'session.idle': async (event) => {
+      process.stderr.write('[harness-stop] session idle heartbeat — text-emission gate registered\n');
+    },
+
+    event: async ({ event }) => {
+      if (event.type !== 'message.updated') return;
+      const parts = event.properties?.parts || [];
+      const text = parts
+        .filter(p => p.type === 'text')
+        .map(p => p.text || '')
+        .join('\n');
+      await validateText(text, { event });
+    },
+
+    'experimental.text.complete': async (input, output) => {
+      await validateText(String(output?.text || ''), input || {});
     },
   };
 }

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

@@ -0,0 +1,103 @@
+// Domain-aware output QA for Aria stop gates.
+// Deterministic local checks complement remote Mizan; they do not replace it.
+
+const DOMAIN_RULES = [
+  {
+    domain: 'code',
+    signal: /```|\b(?:function|class|interface|type|import|export|npm test|typecheck|eslint|jest|vitest|tsx?|jsx?|\.ts|\.tsx|\.js|\.py)\b/i,
+  },
+  {
+    domain: 'ui',
+    signal: /\b(?:ui|ux|frontend|react|component|page|screen|modal|form|button|layout|tailwind|css|html|mobile|responsive|accessib|aria-label|keyboard|focus state|dark mode)\b/i,
+  },
+  {
+    domain: 'beauty',
+    signal: /\b(?:beauty|beautiful|polish|visual|aesthetic|elegant|layout|typography|spacing|hierarchy|composition|brand|design language|modern|clean)\b/i,
+  },
+  {
+    domain: 'security',
+    signal: /\b(?:security|auth|token|secret|credential|password|jwt|oauth|csrf|xss|sql injection|permission|role|cors|sanitize|encrypt|webhook signature)\b/i,
+  },
+  {
+    domain: 'ops',
+    signal: /\b(?:deploy|rollout|rollback|kubernetes|kubectl|docker|image|pod|health check|slo|alert|log|metric|trace|env var|migration|release)\b/i,
+  },
+  {
+    domain: 'product',
+    signal: /\b(?:user flow|customer|workflow|conversion|pricing|onboarding|checkout|activation|retention|business|persona|job-to-be-done|acceptance criteria)\b/i,
+  },
+  {
+    domain: 'writing',
+    signal: /\b(?:summary|explain|docs|readme|copy|email|post|article|message|final answer|status report|release notes)\b/i,
+  },
+];
+
+function hasAny(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+function lineHits(text, rx, label) {
+  const hits = [];
+  const lines = String(text || '').split('\n');
+  for (let i = 0; i < lines.length; i++) {
+    if (rx.test(lines[i])) hits.push(`${label} at line ${i + 1}`);
+  }
+  return hits;
+}
+
+export function extractCodeBlocks(text) {
+  return [...String(text || '').matchAll(/```[a-z0-9_-]*\n([\s\S]*?)```/gi)].map((m) => m[1] || '');
+}
+
+export function analyzeDomainOutputQuality(text, options = {}) {
+  const source = String(text || '');
+  const lower = source.toLowerCase();
+  const codeBlocks = options.codeBlocks || extractCodeBlocks(source);
+  const domains = DOMAIN_RULES.filter((rule) => rule.signal.test(source)).map((rule) => rule.domain);
+  const blockers = [];
+  const warnings = [];
+
+  if (domains.includes('code')) {
+    for (const hit of lineHits(source, /\b(?:TODO|FIXME|XXX|implementation pending|not implemented|coming soon|placeholder)\b/i, 'code placeholder semantics')) blockers.push(hit);
+    for (const block of codeBlocks) {
+      if (/@ts-expect-error|@ts-ignore/.test(block)) blockers.push('code: type suppression instead of fixing the type contract');
+      if (/catch\s*\([^)]*\)\s*\{\s*(?:return\s+(?:''|""|null|undefined|\[\]|\{\})|\}\s*$|\/\/[^\n]*$)/m.test(block)) blockers.push('code: silent or empty catch block hides runtime failure');
+      if (/console\.log\(/.test(block) && !/\/\/\s*(?:debug|log)/i.test(block)) warnings.push('code: console.log appears in shipped code without debug intent');
+    }
+  }
+
+  if (domains.includes('ui')) {
+    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 (domains.includes('security')) {
+    if (/\b(?:token|secret|credential|password|api key|jwt)\b/i.test(source) && !/\b(?:redact|mask|env|secret store|do not log|rotate|least privilege)\b/i.test(source)) blockers.push('security: secrets/tokens require redaction, env/secret-store handling, no logging, or rotation guidance');
+    if (/\b(?:auth|permission|role|admin|tenant)\b/i.test(source) && !/\b(?:authorize|authorization|least privilege|tenant isolation|deny by default|role check)\b/i.test(source)) warnings.push('security: auth/permission output should state authorization and isolation checks');
+  }
+
+  if (domains.includes('ops')) {
+    if (/\b(?:deploy|rollout|release|migration|kubectl|docker push)\b/i.test(source) && !/\b(?:rollback|health|smoke|verify|readiness|observability|monitor)\b/i.test(source)) blockers.push('ops: deploy/release output must include rollback plus health/smoke/readiness verification');
+    if (/\b(?:env var|config|secret)\b/i.test(source) && !/\b(?:scope|owner|runtime|restart|reload|secret)\b/i.test(source)) warnings.push('ops: runtime config changes should name scope and reload/restart expectations');
+  }
+
+  if (domains.includes('product')) {
+    if (!/\b(?:user|customer|operator|admin|persona|workflow|acceptance criteria|success metric|job-to-be-done)\b/i.test(source)) warnings.push('product: product output should bind to a user/workflow and success criterion');
+  }
+
+  if (domains.includes('writing')) {
+    if (/\b(?:done|fixed|verified|published|deployed|passed|complete)\b/i.test(lower) && !/\b(?:verified|observed|passed|evidence|output|registry|status|unverified|not verified)\b/i.test(lower)) blockers.push('writing: completion claim needs observed evidence or explicit unverified boundary');
+    if (/\b(?:should work|probably|presumably|i assume)\b/i.test(source)) blockers.push('writing: uncertainty must be stated as an evidence boundary, not an assumption');
+  }
+
+  return {
+    domains: [...new Set(domains)],
+    blockers: [...new Set(blockers)],
+    warnings: [...new Set(warnings)],
+  };
+}