@aria_asi/cli 0.2.36 → 0.2.37

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

@@ -2,13 +2,19 @@
  * Aria Harness Stop — text-emission gate via HTTPHarnessClient SDK.
  * Routes text through Mizan validateOutput() for substrate-backed QC.
  */
-import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs';
+import { existsSync, readFileSync, mkdirSync, writeFileSync, appendFileSync } 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 { dirname, join } from 'node:path';
 import { analyzeDomainOutputQuality, extractCodeBlocks } from './lib/domain-output-quality.js';
 import { evaluateSkillGate, formatSkillGateBlock } from './lib/skill-autoload-gate.js';
+import {
+  evaluateTaskProjectClaim,
+  recordBlockedTaskProjectClaim,
+  updateTaskProjectLedger,
+} from '../harness-context/task-project-ledger.mjs';
+import { resolveAriaAuthToken } from '../harness-context/auth-token.mjs';
 
 const HOME = homedir();
 const SDK_CANDIDATES = [
@@ -16,11 +22,12 @@ const SDK_CANDIDATES = [
   join(HOME, '.codex', 'aria-sdk', 'index.js'),
   join(HOME, '.claude', 'aria-sdk', 'index.js'),
 ];
-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 CURRENT_RECOVERY_PATH = join(HOME, '.aria', 'governance-recovery-current.json');
 const RUNTIME_URL = (process.env.ARIA_RUNTIME_URL || 'http://127.0.0.1:4319').replace(/\/+$/, '');
 const RECEIPT_DIR = join(HOME, '.opencode', 'aria-mizan-receipts');
+const RECOVERY_LOG_PATH = join(HOME, '.opencode', 'aria-governance-recovery.jsonl');
+const RECOVERY_NOTICE_INTERVAL_MS = Number(process.env.ARIA_RECOVERY_NOTICE_INTERVAL_MS || 30000);
 
 const LENS_NAMES = [
   'nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah',
@@ -34,23 +41,154 @@ const NON_TRIVIAL_MIN_CHARS = 300;
 const DECISION_SIGNAL_RX = /(?:should|recommend|propose|suggest|let'?s|go with|i'd|i would|here'?s the plan|i'll|next step|action item|ship it|yes do|let me)/i;
 const TRIVIAL_ACK_RX = /^(?:got it|on it|ok|sure|yes|no|done|ack)\b/i;
 const PLACEHOLDER_RX = /^\s*<[^<>]+>\s*$/;
-const BLOCK_PREFIX_RX = /^=== ARIA (?:MIZAN POST|OUTPUT GATE|LOCAL OUTPUT) BLOCK ===/;
+const BLOCK_PREFIX_RX = /^=== ARIA (?:MIZAN POST|OUTPUT GATE|LOCAL OUTPUT|SKILL AUTOLOAD GATE|UNIVERSAL GOVERNANCE GATE) BLOCK ===/;
 const APPLIED_COGNITION_RX = /<applied_cognition>[\s\S]*?decision_delta\s*:[\s\S]*?dominant_domain\s*:[\s\S]*?binds_to\s*:[\s\S]*?expected_predicate\s*:[\s\S]*?artifact_change\s*:[\s\S]*?<\/applied_cognition>/i;
+const HANDOFF_MODE_RX = /\b(?:post[_ -]?compact[_ -]?continuation|handoff[_ -]?resume|continuation[_ -]?handoff|post-compact|compact(?:ion)? handoff|post\s+commission)\b/i;
+const HANDOFF_REQUIRED_FIELDS = [
+  { key: 'current_objective', label: 'current objective', rx: /\bcurrent\s+objective\b\s*:/i },
+  { key: 'known_blockers', label: 'known blockers', rx: /\bknown\s+blockers\b\s*:/i },
+  { key: 'next_executable_step', label: 'next executable step', rx: /\bnext\s+executable\s+step\b\s*:/i },
+  { key: 'what_not_to_touch', label: 'what not to touch', rx: /\bwhat\s+not\s+to\s+touch\b\s*:/i },
+  { key: 'verification_already_run', label: 'verification already run', rx: /\bverification\s+already\s+run\b\s*:/i },
+];
+const FAKE_COMPLETION_CLAIM_RX = /\b(?:everything\s+is\s+)?(?:done|fixed|ready|complete|completed|shipped|production-ready|works in general)\b/i;
+const PROOF_SIGNAL_RX = /\b(?:passed|exit\s*=?\s*0|status\s*[:=]\s*(?:ok|healthy)|readyReplicas\s*=|\d+\s+passed|green|verified\s*[:=-].{0,80}(?:npm|jest|test|build|typecheck|kubectl|curl|smoke))\b/i;
+const GATEOFF_MARKER_PATH = join(HOME, '.aria', 'gates-off.manual');
+const GATEOFF_ENV_RX = /^(?:1|true|yes|on)$/i;
+const GATEOFF_PHRASE_RX = /\bGATEOFF\b/;
+
+function textFromPayload(payload) {
+  if (!payload) return '';
+  if (typeof payload === 'string') return payload;
+  try { return JSON.stringify(payload); } catch { return String(payload); }
+}
 
-function formatBlockReason(prefix, details) {
+function persistEmergencyGateOff(reason = 'phrase') {
+  mkdirSync(dirname(GATEOFF_MARKER_PATH), { recursive: true, mode: 0o700 });
+  writeFileSync(GATEOFF_MARKER_PATH, JSON.stringify({
+    disabled: true,
+    reason,
+    disabledAt: new Date().toISOString(),
+    reenable: 'Manual owner action only: remove this marker and unset ARIA_GATES_OFF/ARIA_HARNESS_GATES_OFF.',
+  }, null, 2) + '\n', { mode: 0o600 });
+}
+
+function emergencyGateOffDecision(payload = '') {
+  if (GATEOFF_ENV_RX.test(String(process.env.ARIA_GATES_OFF || process.env.ARIA_HARNESS_GATES_OFF || ''))) {
+    return { off: true, reason: 'env' };
+  }
+  if (existsSync(GATEOFF_MARKER_PATH)) return { off: true, reason: 'marker' };
+  if (GATEOFF_PHRASE_RX.test(textFromPayload(payload))) {
+    persistEmergencyGateOff('phrase');
+    return { off: true, reason: 'phrase' };
+  }
+  return { off: false, reason: null };
+}
+
+function recoveryTemplate(kind = 'general') {
+  const handoff = kind === 'handoff';
+  return [
+    'Recovery contract:',
+    '1. Do not retry the same blocked text.',
+    '2. Rewrite the output using this exact shape:',
+    handoff ? 'post_compact_continuation' : '<applied_cognition>',
+    handoff ? 'current objective: <one sentence of the still-active task>' : 'decision_delta: <what changed in this turn>',
+    handoff ? 'known blockers: <specific blockers, or "none verified" if truly none>' : 'dominant_domain: <code|deploy|security|testing|product|ops|writing>',
+    handoff ? 'next executable step: <single command/edit/read/action the next agent should run first>' : 'binds_to: <specific file, command result, endpoint, runtime, or user instruction>',
+    handoff ? 'what not to touch: <unrelated dirty files, secrets, protected systems, or deploys to avoid>' : 'expected_predicate: <measurable condition, e.g. exit=0, status=healthy, count=N>',
+    handoff ? 'verification already run: <commands/probes already run and exact result, or "not run">' : 'artifact_change: <exact artifact changed or "none">',
+    handoff ? '' : '</applied_cognition>',
+    '3. If the block was caused by missing proof, run the concrete command/probe first, then re-submit with the result.',
+    '4. If the block was caused by a missing skill/doctrine trigger, load the named skill, then re-write and re-test.',
+    '5. If two rewrites still block, escalate through ARIA console/MCP with the block text and stop repeating the same output.',
+  ].filter(Boolean).join('\n');
+}
+
+function formatBlockReason(prefix, details, options = {}) {
   return [
     prefix,
     '',
     String(details || 'Aria output gate blocked this message.'),
     '',
-    'Required repair: bind cognition to the actual action/output using <applied_cognition> with decision_delta, dominant_domain, binds_to, expected_predicate, and artifact_change.',
+    recoveryTemplate(options.kind || 'general'),
   ].join('\n');
 }
 
+function recoveryFingerprint(reason, source = 'opencode-stop') {
+  return createHash('sha256')
+    .update([source, String(reason || '').replace(/\s+/g, ' ').trim().slice(0, 1200)].join('\0'))
+    .digest('hex');
+}
+
+function emitRecoverableOutput(reason, { source = 'opencode-stop', sessionId = 'opencode' } = {}) {
+  const fingerprint = recoveryFingerprint(reason, source);
+  const updatedAt = new Date().toISOString();
+  const recovery = {
+    schema: 'aria.governance_recovery_current.v1',
+    updatedAt,
+    deliveryRule: 'This file is injected into the next system prompt. Execute recoveryLoop.nextStep before any completion claim.',
+    ok: true,
+    decision: 'warn',
+    source,
+    governanceMode: 'recovery-required',
+    recoveryLoop: {
+      fingerprint,
+      allowedRecoveryAttempts: 1,
+      priorRecoveryAttempts: 0,
+      remainingRecoveryAttempts: 1,
+      nextStep: 'Re-author the blocked output using the recovery contract, run a concrete verification probe when tools are available, then emit the corrected output.',
+      architectFallback: 'If Aria consult is unavailable or this same fingerprint repeats, use the strongest available client LLM under the architect harness, produce and execute the recovery plan, then verify.',
+    },
+    recoveryContract: {
+      retry: 'One recovery attempt is allowed for this exact output-gate fingerprint; repeat failure enters architect execution mode.',
+      architectMode: 'On repeat, load architecture-decision and named domain skills, define the smallest executable plan, execute the first recovery action, and verify before output.',
+      fallbackWhenAriaUnavailable: 'Do not stop or ask the owner to fix it. Bind the strongest available client LLM to the architect harness, give it this JSON contract and failed evidence, execute its recovery plan, then verify.',
+      repairRecoveryCycle: ['re-author output according to the gate reason', 'verify corrected claim or state explicit unverified boundary'],
+      retest: 'Submit the revised output through the same output gate and run the concrete verification probe named by the recovery plan.',
+      blockedReason: reason,
+    },
+  };
+  mkdirSync(dirname(CURRENT_RECOVERY_PATH), { recursive: true, mode: 0o700 });
+  writeFileSync(CURRENT_RECOVERY_PATH, `${JSON.stringify(recovery, null, 2)}\n`, { mode: 0o600 });
+  mkdirSync(dirname(RECOVERY_LOG_PATH), { recursive: true, mode: 0o700 });
+  appendFileSync(RECOVERY_LOG_PATH, `${JSON.stringify(recovery)}\n`, { mode: 0o600 });
+
+  const noticeKey = `${source}:${fingerprint}`;
+  const nowMs = Date.now();
+  const lastNoticeAt = _lastRecoveryNoticeBySource.get(noticeKey) || 0;
+  if (nowMs - lastNoticeAt >= RECOVERY_NOTICE_INTERVAL_MS) {
+    _lastRecoveryNoticeBySource.set(noticeKey, nowMs);
+    const compactReason = String(reason || 'recovery required')
+      .replace(/\s+/g, ' ')
+      .replace(/^=+\s*ARIA\s*/i, '')
+      .slice(0, 160);
+    process.stderr.write(`[aria-governance] recovery-required source=${source} fingerprint=${fingerprint.slice(0, 12)} reason="${compactReason}" details=${CURRENT_RECOVERY_PATH}\n`);
+  }
+  return recovery;
+}
+
 function isGateBlock(error) {
   return BLOCK_PREFIX_RX.test(String(error?.message || error || ''));
 }
 
+export function classifyContinuationHandoff(text) {
+  const body = String(text || '');
+  const isContinuation = HANDOFF_MODE_RX.test(body);
+  const missingFields = HANDOFF_REQUIRED_FIELDS
+    .filter((field) => !field.rx.test(body))
+    .map((field) => field.label);
+  const completionClaimLines = body
+    .split(/\r?\n/)
+    .filter((line) => /\b(?:current\s+objective|summary|status)\b\s*:/i.test(line));
+  const hasFakeCompletionClaim = completionClaimLines.some((line) => FAKE_COMPLETION_CLAIM_RX.test(line)) && !PROOF_SIGNAL_RX.test(body);
+  return {
+    isContinuation,
+    ok: isContinuation && missingFields.length === 0 && !hasFakeCompletionClaim,
+    missingFields,
+    hasFakeCompletionClaim,
+  };
+}
+
 function runUniversalGovernanceGate(payload) {
   if (!existsSync(GOVERNANCE_GATE_PATH)) return null;
   const child = spawnSync(GOVERNANCE_GATE_PATH, {
@@ -63,16 +201,22 @@ function runUniversalGovernanceGate(payload) {
   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.'}`
+      formatBlockReason(
+        '=== ARIA UNIVERSAL GOVERNANCE GATE BLOCK ===',
+        stdout || child.stderr || 'aria-governance-gate blocked this output.',
+      )
     );
   }
+  if (result?.decision === 'warn' || result?.governanceMode === 'recovery-required' || result?.governanceMode === 'architectural-intervention-required') {
+    process.stderr.write(`[aria-governance] ${result.governanceMode || 'recovery-required'} details=${CURRENT_RECOVERY_PATH}\n`);
+  }
   return result;
 }
 
 let _client = null;
 let _clientError = null;
 let _lastMizanReceipt = null;
+const _lastRecoveryNoticeBySource = new Map();
 
 function receiptPath(sessionId) {
   return join(RECEIPT_DIR, `${String(sessionId || 'opencode').replace(/[^a-zA-Z0-9_-]/g, '_')}.json`);
@@ -109,22 +253,7 @@ function makeEvidenceRef(kind, value, 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;
-  if (process.env.ARIA_MASTER_TOKEN) return process.env.ARIA_MASTER_TOKEN;
-  try {
-    if (existsSync(OWNER_TOKEN_PATH)) {
-      const v = readFileSync(OWNER_TOKEN_PATH, 'utf8').trim();
-      if (v) return v;
-    }
-  } catch {}
-  try {
-    if (existsSync(LICENSE_PATH)) {
-      const j = JSON.parse(readFileSync(LICENSE_PATH, 'utf8'));
-      if (j.token) return j.token;
-    }
-  } catch {}
-  return '';
+  return resolveAriaAuthToken({ baseUrl: resolveBaseUrl() }).token;
 }
 
 function resolveBaseUrl() {
@@ -255,11 +384,51 @@ export default async function HarnessStopPlugin(ctx) {
   process.stderr.write('[harness-stop] Active — SDK-backed text-emission gate\n');
 
   async function validateText(text, eventContext = {}) {
+    const sessionId = eventContext.sessionID || process.env.ARIA_SESSION_ID || process.env.OPENCODE_SESSION_ID || 'opencode';
+    const handoff = classifyContinuationHandoff(text);
+    if (handoff.isContinuation) {
+      if (!handoff.ok) {
+        const reasons = [
+          handoff.missingFields.length ? `missing fields: ${handoff.missingFields.join(', ')}` : '',
+          handoff.hasFakeCompletionClaim ? 'fake completion claim without proof' : '',
+        ].filter(Boolean).join('; ');
+        emitRecoverableOutput(formatBlockReason('=== ARIA LOCAL OUTPUT BLOCK ===', `post-compact continuation handoff malformed: ${reasons}`, { kind: 'handoff' }), { source: 'opencode-stop/handoff', sessionId });
+        return;
+      }
+      return;
+    }
+    const emergencyGateOff = emergencyGateOffDecision({ text, eventContext });
+    if (emergencyGateOff.off) {
+      return;
+    }
+    const ledgerResult = updateTaskProjectLedger({
+      platform: 'opencode',
+      phase: 'stop',
+      source: 'opencode-harness-stop',
+      event: { ...eventContext, text, sessionId, cwd: process.cwd() },
+    });
+    const ledgerClaim = evaluateTaskProjectClaim({ text, ledger: ledgerResult.ledger });
+    if (!ledgerClaim.ok) {
+      recordBlockedTaskProjectClaim({
+        ledger: ledgerResult.ledger,
+        paths: ledgerResult.paths,
+        text,
+        evaluation: ledgerClaim,
+      });
+      emitRecoverableOutput(formatBlockReason(
+        '=== ARIA TASK/PROJECT LEDGER BLOCK ===',
+        [
+          `ledger_id: ${ledgerResult.ledger.ledgerId}`,
+          `missing_readiness_gates: ${ledgerClaim.missingReadinessGates.join(', ') || 'none'}`,
+          `open_blockers: ${ledgerClaim.openBlockers.length}`,
+        ].join('\n')
+      ), { source: 'opencode-stop/task-project-ledger', sessionId });
+      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',
@@ -275,13 +444,9 @@ export default async function HarnessStopPlugin(ctx) {
       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.`,
-        )
-      );
+    if (!skillGate.ok && !skillGate.redirectOnly) {
+      emitRecoverableOutput(formatBlockReason('=== ARIA SKILL AUTOLOAD GATE BLOCK ===', formatSkillGateBlock(skillGate)), { source: 'opencode-stop/skill-autoload', sessionId });
+      return;
     }
     const outputRef = makeEvidenceRef('opencode_assistant_output', text.slice(0, 8000), { sessionId });
     try {
@@ -309,12 +474,14 @@ export default async function HarnessStopPlugin(ctx) {
       }
       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)
-        );
+        emitRecoverableOutput(formatBlockReason('=== ARIA MIZAN POST BLOCK ===', details), { source: 'opencode-stop/mizan-post', sessionId });
+        return;
       }
     } catch (e) {
-      if (isGateBlock(e)) throw e;
+      if (isGateBlock(e)) {
+        emitRecoverableOutput(e.message, { source: 'opencode-stop/mizan-post', sessionId });
+        return;
+      }
       process.stderr.write(`[harness-stop] mizan/post unavailable: ${e.message}\n`);
     }
 
@@ -329,26 +496,21 @@ export default async function HarnessStopPlugin(ctx) {
           sessionId,
         ));
         if (result.severity === 'block') {
-          throw new Error(
-            formatBlockReason(
-              '=== ARIA OUTPUT GATE BLOCK ===',
-              `${result.violations.length} violations: ${result.violations.join('; ').slice(0, 500)}`,
-            )
-          );
+          emitRecoverableOutput(formatBlockReason('=== ARIA OUTPUT GATE BLOCK ===', `${result.violations.length} violations: ${result.violations.join('; ').slice(0, 500)}`), { source: 'opencode-stop/validate-output', sessionId });
+          return;
         } else if (result.severity === 'warn') {
-          throw new Error(
-            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.`,
-            )
-          );
+          emitRecoverableOutput(formatBlockReason('=== ARIA OUTPUT GATE BLOCK ===', `SDK returned warn for ${result.violations.length} violation(s): ${(result.violations || []).join('; ').slice(0, 500)}. Warnings require forced recovery on owner-facing output.`), { source: 'opencode-stop/validate-output-warn', sessionId });
+          return;
         }
         if (result.gateTriggers?.length) {
           process.stderr.write(`[harness-stop] SDK triggers: ${result.gateTriggers.join(', ')}\n`);
         }
         return;
       } catch (e) {
-        if (isGateBlock(e)) throw e;
+        if (isGateBlock(e)) {
+          emitRecoverableOutput(e.message, { source: 'opencode-stop/validate-output', sessionId });
+          return;
+        }
         process.stderr.write(`[harness-stop] SDK validateOutput failed: ${e.message} — falling through to local gate\n`);
       }
     }
@@ -380,31 +542,19 @@ export default async function HarnessStopPlugin(ctx) {
     } 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}`,
-        )
-      );
+      emitRecoverableOutput(formatBlockReason('=== ARIA LOCAL OUTPUT BLOCK ===', `cognition=${cog.count}/${REQUIRED_LENSES}; drift=${driftHits.length}`), { source: 'opencode-stop/local-cognition-drift', sessionId });
+      return;
     }
 
     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',
-        )
-      );
+      emitRecoverableOutput(formatBlockReason('=== ARIA LOCAL OUTPUT BLOCK ===', 'decision-bearing output lacks required applied_cognition binding fields'), { source: 'opencode-stop/applied-cognition', sessionId });
+      return;
     }
 
     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('; ')}`,
-        )
-      );
+      emitRecoverableOutput(formatBlockReason('=== ARIA LOCAL OUTPUT BLOCK ===', `domain output QA (${domainQuality.domains.join(', ') || 'general'}): ${domainQuality.blockers.join('; ')}`), { source: 'opencode-stop/domain-output-quality', sessionId });
+      return;
     }
 
     try {
@@ -432,6 +582,17 @@ export default async function HarnessStopPlugin(ctx) {
         source: 'opencode-stop-gate-runtime',
         model_used: process.env.OPENCODE_MODEL || 'opencode',
       });
+      updateTaskProjectLedger({
+        platform: 'opencode',
+        phase: 'post_turn',
+        source: 'opencode-harness-stop',
+        event: { ...eventContext, text, sessionId, cwd: process.cwd() },
+        evidence: {
+          post_turn: true,
+          output_ref: outputRef,
+          verification: false,
+        },
+      });
     } catch (e) {
       process.stderr.write(`[harness-stop] decision/log unavailable: ${e.message}\n`);
     }

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

@@ -1,14 +1 @@
-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'); }
+export * from '../../../hooks/lib/skill-autoload-gate.mjs';

package/dist/runtime/auth-token.mjs

@@ -0,0 +1,121 @@
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+const HOME = homedir();
+const ARIA_DIR = join(HOME, '.aria');
+const OWNER_TOKEN_PATH = join(ARIA_DIR, 'owner-token');
+const LICENSE_PATH = join(ARIA_DIR, 'license.json');
+const CLIENT_TOKEN_DIR = join(ARIA_DIR, 'harness-tokens');
+
+function nonEmpty(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : '';
+}
+
+function readJson(path) {
+  try {
+    if (!existsSync(path)) return null;
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function readText(path) {
+  try {
+    if (!existsSync(path)) return '';
+    return readFileSync(path, 'utf8').trim();
+  } catch {
+    return '';
+  }
+}
+
+function sanitizeScope(value) {
+  const clean = String(value || '').trim().replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 96);
+  return clean || 'default';
+}
+
+function scopeFromBaseUrl(baseUrl) {
+  try {
+    const parsed = new URL(String(baseUrl || ''));
+    return `base-${createHash('sha256').update(`${parsed.protocol}//${parsed.host}`).digest('hex').slice(0, 16)}`;
+  } catch {
+    return 'default';
+  }
+}
+
+function hasExplicitClientScope(options) {
+  return Boolean(nonEmpty(options.clientId) || nonEmpty(options.tokenScope));
+}
+
+function inferScope(options, license) {
+  const explicit = nonEmpty(options.tokenScope) || nonEmpty(options.clientId);
+  if (explicit) return sanitizeScope(explicit);
+  const envScope = nonEmpty(process.env.ARIA_HARNESS_CLIENT_ID) || nonEmpty(process.env.ARIA_CLIENT_ID) || nonEmpty(process.env.ARIA_TENANT_ID);
+  if (envScope) return sanitizeScope(envScope);
+  const licenseScope = nonEmpty(license?.jti) || nonEmpty(license?.sub);
+  if (licenseScope) return sanitizeScope(licenseScope);
+  return sanitizeScope(scopeFromBaseUrl(nonEmpty(options.baseUrl)));
+}
+
+function persistedPath(scope) {
+  return join(CLIENT_TOKEN_DIR, `${sanitizeScope(scope)}.json`);
+}
+
+function readPersistedToken(scope) {
+  const parsed = readJson(persistedPath(scope));
+  return nonEmpty(parsed?.token);
+}
+
+function persistToken(scope, token, source) {
+  if (!token) return false;
+  try {
+    mkdirSync(CLIENT_TOKEN_DIR, { recursive: true, mode: 0o700 });
+    writeFileSync(
+      persistedPath(scope),
+      `${JSON.stringify({ scope, token, source, updatedAt: new Date().toISOString() }, null, 2)}\n`,
+      { encoding: 'utf8', mode: 0o600 },
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export function resolveAriaAuthToken(options = {}) {
+  const license = readJson(LICENSE_PATH);
+  const scope = inferScope(options, license);
+  const persist = options.persistToken !== false;
+
+  const explicit = nonEmpty(options.explicitToken);
+  if (explicit) {
+    return { token: explicit, source: 'explicit', scope, persisted: persist ? persistToken(scope, explicit, 'explicit') : false };
+  }
+
+  const envSources = [
+    ['env:ARIA_HARNESS_TOKEN', process.env.ARIA_HARNESS_TOKEN],
+    ['env:ARIA_API_KEY', process.env.ARIA_API_KEY],
+    ['env:ARIA_MASTER_TOKEN', process.env.ARIA_MASTER_TOKEN],
+  ];
+  for (const [source, value] of envSources) {
+    const token = nonEmpty(value);
+    if (!token) continue;
+    return { token, source, scope, persisted: persist ? persistToken(scope, token, source) : false };
+  }
+
+  const stored = readPersistedToken(scope);
+  if (stored) return { token: stored, source: 'persisted-client-token', scope, persisted: true };
+
+  if (!hasExplicitClientScope(options) || process.env.ARIA_ALLOW_OWNER_TOKEN_FOR_CLIENT_SCOPE === 'true') {
+    const ownerToken = readText(OWNER_TOKEN_PATH);
+    if (ownerToken) return { token: ownerToken, source: 'owner-token-file', scope, persisted: false };
+  }
+
+  const harnessToken = nonEmpty(license?.harnessToken);
+  if (harnessToken) return { token: harnessToken, source: 'license:harnessToken', scope, persisted: false };
+  const token = nonEmpty(license?.token);
+  if (token) return { token, source: 'license:token', scope, persisted: false };
+  return { token: '', source: 'missing', scope, persisted: false };
+}