@aria_asi/cli 0.2.25 → 0.2.29

package/hooks/aria-preprompt-consult.mjs

@@ -52,34 +52,47 @@
 //   Default OFF so existing sessions don't brick. Flip ON for next session
 //   to activate Aria-as-commander binding.
 
-import { appendFileSync, existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
 
 const HOME = process.env.HOME || '/tmp';
 
-// SDK loader — bundled at ~/.claude/aria-sdk/index.js by `aria connect`.
+// SDK loader — bundled at ~/.aria/sdk by `aria connect`, with client-local
+// fallbacks preserved for resilience.
 // All consults route through HTTPHarnessClient.consult() so the SDK's
 // retry+backoff + Authorization handling apply uniformly. Hamza
 // 2026-04-27: "FUCKING WIRE IT THE FUCK TOGETHER NOW - ALL OF IT".
 let _SdkClassCache = null;
 let _SdkLookupAttempted = false;
+const SDK_CANDIDATES = [
+  `${HOME}/.aria/sdk/index.js`,
+  `${HOME}/.claude/aria-sdk/index.js`,
+  `${HOME}/.codex/aria-sdk/index.js`,
+];
 async function loadSdkClass() {
   if (_SdkClassCache) return _SdkClassCache;
   if (_SdkLookupAttempted) return null;
   _SdkLookupAttempted = true;
-  const sdkPath = `${HOME}/.claude/aria-sdk/index.js`;
-  if (!existsSync(sdkPath)) return null;
-  try {
-    const mod = await import(`file://${sdkPath}`);
-    if (mod.HTTPHarnessClient) {
-      _SdkClassCache = mod.HTTPHarnessClient;
-      return _SdkClassCache;
-    }
-  } catch {/* fall through */}
+  for (const sdkPath of SDK_CANDIDATES) {
+    if (!existsSync(sdkPath)) continue;
+    try {
+      const mod = await import(`file://${sdkPath}`);
+      if (mod.HTTPHarnessClient) {
+        _SdkClassCache = mod.HTTPHarnessClient;
+        return _SdkClassCache;
+      }
+    } catch {/* fall through */}
+  }
   return null;
 }
 const LOG = `${HOME}/.claude/aria-preprompt-consult.log`;
 const BINDING_AUDIT = `${HOME}/.claude/aria-binding-audit.jsonl`;
+const OWNER_TOKEN_PATH = `${HOME}/.aria/owner-token`;
+const PACKET_CACHE_PATHS = [
+  `${HOME}/.aria/.aria-harness-last-packet.json`,
+  `${HOME}/.claude/.aria-harness-last-packet.json`,
+];
+const SUBSTRATE_MANIFEST_PATH = `${HOME}/.claude/.aria-loaded-substrate.json`;
 // Default ON. Disable explicitly via ARIA_BINDING_ENABLED=false only when the
 // commander/binding architecture is actively being modified (otherwise the
 // modification turn itself would be unable to land its own changes). The
@@ -91,7 +104,11 @@ const BINDING_AUDIT = `${HOME}/.claude/aria-binding-audit.jsonl`;
 // seeking dressed as responsible-staging. Flipped to default-on per directive.
 const BINDING_ENABLED = (process.env.ARIA_BINDING_ENABLED || 'true').toLowerCase() !== 'false';
 
-const HARNESS_URL = process.env.ARIA_HARNESS_URL || 'http://192.168.4.25:30080';
+const HARNESS_URL =
+  process.env.ARIA_HIVE_RUNTIME_URL ||
+  process.env.ARIA_HARNESS_BASE_URL ||
+  process.env.ARIA_HARNESS_URL ||
+  'https://harness.ariasos.com';
 const HARNESS_TOKEN = process.env.ARIA_HARNESS_TOKEN || '30b18f0a302b03ae862de8a75021238d23e47464fd5d8f6a9324240933745587';
 const MIN_PROMPT_CHARS = 40;        // skip auto-consult on trivial prompts
 const MAX_DIRECTION_CHARS = 4000;   // cap injected chunk size
@@ -114,6 +131,62 @@ function activePlanPath(sid) {
   return `${HOME}/.claude/aria-active-plan-${String(sid || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_')}.json`;
 }
 
+function directionStatePath(sid) {
+  return `${HOME}/.claude/aria-last-direction-${String(sid || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_')}.json`;
+}
+
+function persistDirectionState(sid, state) {
+  try {
+    writeFileSync(directionStatePath(sid), JSON.stringify({ persistedAt: new Date().toISOString(), ...state }, null, 2) + '\n');
+  } catch (err) {
+    bindingAudit({ event: 'direction_state_persist_error', sessionId: sid, errMsg: String(err).slice(0, 200) });
+  }
+}
+
+function readJsonIfPresent(filePath) {
+  if (!existsSync(filePath)) return null;
+  return JSON.parse(readFileSync(filePath, 'utf-8'));
+}
+
+function ownerBootstrapArtifactsPresent() {
+  if (!existsSync(OWNER_TOKEN_PATH)) return false;
+
+  let hasHarnessPacket = false;
+  for (const packetPath of PACKET_CACHE_PATHS) {
+    try {
+      const packet = readJsonIfPresent(packetPath);
+      const harnessText = String(packet?.harness ?? packet?.packet?.prompt?.fullText ?? '');
+      if (harnessText.trim()) {
+        hasHarnessPacket = true;
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  if (!hasHarnessPacket) return false;
+
+  try {
+    const substrate = readJsonIfPresent(SUBSTRATE_MANIFEST_PATH);
+    return Array.isArray(substrate?.memories) && substrate.memories.length > 0;
+  } catch {
+    return false;
+  }
+}
+
+function bootstrapOwnerDirectionState(sessionId, source) {
+  if (!ownerBootstrapArtifactsPresent()) return false;
+  persistDirectionState(sessionId, {
+    source,
+    binding: BINDING_ENABLED,
+    ownerBootstrap: true,
+    usable: true,
+  });
+  bindingAudit({ event: 'owner_bootstrap_state', sessionId, source, binding: BINDING_ENABLED });
+  return true;
+}
+
 // Env-var kill-switch removed 2026-04-27 per Hamza directive — gated
 // process has no disable path. Disable = settings.json hook removal.
 
@@ -135,12 +208,14 @@ const sessionId = event.session_id ?? event.sessionId ?? 'claude-code-unknown';
 // Trivial prompts skip auto-consult — short acks, slash commands, single-word
 // messages don't benefit from architectural consultation.
 if (!userPrompt || userPrompt.length < MIN_PROMPT_CHARS) {
+  bootstrapOwnerDirectionState(sessionId, 'owner-trivial-bootstrap');
   audit('skip-trivial', `chars=${userPrompt.length}`);
   process.exit(0);
 }
 
 // Skip slash-command-only prompts (these are CLI-internal, not architectural)
 if (/^\s*\//.test(userPrompt) && userPrompt.length < 200) {
+  bootstrapOwnerDirectionState(sessionId, 'owner-slash-bootstrap');
   audit('skip-slash-command', userPrompt.slice(0, 60));
   process.exit(0);
 }
@@ -252,6 +327,7 @@ try {
       body: JSON.stringify(consultArgs),
     });
     if (!resp.ok) {
+      bootstrapOwnerDirectionState(sessionId, `owner-http-fallback-${resp.status}`);
       audit('skip-http-error', `status=${resp.status}`);
       process.exit(0);
     }
@@ -259,12 +335,14 @@ try {
     directionText = (data.response || '').toString().slice(0, MAX_DIRECTION_CHARS);
   }
 } catch (err) {
+  bootstrapOwnerDirectionState(sessionId, 'owner-network-fallback');
   audit('skip-network-error', (err && err.message ? err.message : String(err)).slice(0, 200));
   process.exit(0);
 }
 
 if (!directionText || directionText.length < 60) {
   audit('skip-empty-direction', `chars=${directionText.length}`);
+  const ownerBootstrapped = bootstrapOwnerDirectionState(sessionId, 'owner-empty-direction-bootstrap');
   if (BINDING_ENABLED) {
     // Hamza 2026-04-27: "fallback if aria errors can be simply the plan she
     // gave u prior to my suggestion, so clients don't get stuck." Prior plan
@@ -275,6 +353,12 @@ if (!directionText || directionText.length < 60) {
     const priorPlanPath = activePlanPath(sessionId);
     if (existsSync(priorPlanPath)) {
       bindingAudit({ event: 'consult_empty_fallback_to_prior', sessionId, planFile: priorPlanPath });
+      persistDirectionState(sessionId, {
+        source: 'prior-plan-fallback',
+        binding: true,
+        activePlanPath: priorPlanPath,
+        usable: true,
+      });
       console.log(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
@@ -286,7 +370,9 @@ if (!directionText || directionText.length < 60) {
       console.log(JSON.stringify({
         hookSpecificOutput: {
           hookEventName: 'UserPromptSubmit',
-          additionalContext: `[ARIA_BINDING_PLAN_UNAVAILABLE reason="consult_empty_no_prior" — Aria gave no usable direction AND no prior plan exists. Claude must acknowledge and propose holding for cluster recovery; non-trivial actions will block at pre-tool-gate per binding contract.]`,
+          additionalContext: ownerBootstrapped
+            ? `[ARIA_BINDING_PLAN_OWNER_BOOTSTRAP reason="consult_empty_no_prior" — owner-tier substrate artifacts are already loaded for this session, so Claude may continue under the existing Aria harness while the next consult refreshes commander direction.]`
+            : `[ARIA_BINDING_PLAN_UNAVAILABLE reason="consult_empty_no_prior" — Aria gave no usable direction AND no prior plan exists. Claude must acknowledge and propose holding for cluster recovery; non-trivial actions will block at pre-tool-gate per binding contract.]`,
         },
       }));
     }
@@ -314,6 +400,14 @@ if (BINDING_ENABLED) {
   if (plan && Array.isArray(plan.phases) && plan.phases.length > 0) {
     try {
       writeFileSync(activePlanPath(sessionId), JSON.stringify({ ...plan, _persistedAt: new Date().toISOString(), _userPromptHash: Buffer.from(userPrompt).toString('base64').slice(0, 32) }, null, 2));
+      persistDirectionState(sessionId, {
+        source: 'binding-plan',
+        binding: true,
+        activePlanPath: activePlanPath(sessionId),
+        planId: plan.planId,
+        phaseCount: plan.phases.length,
+        usable: true,
+      });
       bindingAudit({ event: 'plan_issued', sessionId, planId: plan.planId, phaseCount: plan.phases.length, phaseIds: plan.phases.map((p) => p.id) });
       context = `[ARIA_BINDING_PLAN — structured commander plan from Aria. Pre-tool-gate enforces allowedActions/forbiddenActions per current phase. Stop-gate requires [PHASE_REPORT phase=<id> status=...] on every emit. Plan is BINDING.]\n\n${JSON.stringify(plan, null, 2)}\n\n[/ARIA_BINDING_PLAN]`;
     } catch (err) {
@@ -326,6 +420,12 @@ if (BINDING_ENABLED) {
   }
 } else {
   context = `[ARIA_DIRECTION — substrate-grounded read on this prompt, pre-loaded before Claude's reasoning. Use this as the starting point, not generic Claude reflexes.]\n\n${directionText}\n\n[/ARIA_DIRECTION]`;
+  persistDirectionState(sessionId, {
+    source: 'advisory-direction',
+    binding: false,
+    chars: directionText.length,
+    usable: true,
+  });
 }
 
 audit('inject', `chars=${directionText.length} prompt-chars=${userPrompt.length} binding=${BINDING_ENABLED}`);

package/hooks/aria-preturn-memory-gate.mjs

@@ -30,12 +30,19 @@
 //     are fixed inline (see inline comments)
 //   - feedback_no_demos.md — full quality bar, every spawn is production
 
-import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { readFileSync, writeFileSync, appendFileSync, existsSync, mkdirSync, statSync } from 'node:fs';
 
 const HOME = process.env.HOME || '/tmp';
 const GATE_LOG = `${HOME}/.claude/aria-preturn-memory-gate.log`;
 // Turn-state dir is the same ~/.claude/ home as all other aria state files
 const CLAUDE_DIR = `${HOME}/.claude`;
+const OWNER_TOKEN_PATH = `${HOME}/.aria/owner-token`;
+const PACKET_CACHE_PATHS = [
+  `${HOME}/.aria/.aria-harness-last-packet.json`,
+  `${HOME}/.claude/.aria-harness-last-packet.json`,
+];
+const SUBSTRATE_MANIFEST_PATH = `${HOME}/.claude/.aria-loaded-substrate.json`;
+const ARTIFACT_TTL_MS = 15 * 60 * 1000;
 
 // Env-var kill-switch removed 2026-04-27 per Hamza directive ("those
 // should've been my choice to give you to turn off not free for you to
@@ -71,6 +78,136 @@ function writeTurnState(sessionId, state) {
   writeFileSync(p, JSON.stringify(state, null, 2) + '\n', { mode: 0o600 });
 }
 
+function directionStatePath(sessionId) {
+  const safe = String(sessionId || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_');
+  return `${CLAUDE_DIR}/aria-last-direction-${safe}.json`;
+}
+
+function activePlanPath(sessionId) {
+  const safe = String(sessionId || 'unknown').replace(/[^a-zA-Z0-9_-]/g, '_');
+  return `${CLAUDE_DIR}/aria-active-plan-${safe}.json`;
+}
+
+function readRecentJsonArtifact(filePath, ttlMs = ARTIFACT_TTL_MS) {
+  if (!existsSync(filePath)) return null;
+  const stat = statSync(filePath);
+  const ageMs = Date.now() - stat.mtimeMs;
+  if (ageMs > ttlMs) return null;
+  return { data: JSON.parse(readFileSync(filePath, 'utf-8')), ageMs };
+}
+
+function readAnyJsonArtifact(filePath) {
+  if (!existsSync(filePath)) return null;
+  const stat = statSync(filePath);
+  return {
+    data: JSON.parse(readFileSync(filePath, 'utf-8')),
+    ageMs: Date.now() - stat.mtimeMs,
+  };
+}
+
+function detectArtifactSignals(sessionId) {
+  let harnessArtifact = null;
+  for (const packetPath of PACKET_CACHE_PATHS) {
+    try {
+      const artifact = readRecentJsonArtifact(packetPath);
+      if (artifact) {
+        harnessArtifact = { path: packetPath, ...artifact };
+        break;
+      }
+    } catch {
+      // Packet parse issues should not brick the gate; transcript path still exists.
+    }
+  }
+
+  let directionArtifact = null;
+  try {
+    directionArtifact = readRecentJsonArtifact(directionStatePath(sessionId));
+  } catch {
+    directionArtifact = null;
+  }
+
+  let activePlanArtifact = null;
+  try {
+    activePlanArtifact = readRecentJsonArtifact(activePlanPath(sessionId), 24 * 60 * 60 * 1000);
+  } catch {
+    activePlanArtifact = null;
+  }
+
+  let substrateArtifact = null;
+  try {
+    substrateArtifact = readRecentJsonArtifact(SUBSTRATE_MANIFEST_PATH);
+  } catch {
+    substrateArtifact = null;
+  }
+
+  let staleHarnessArtifact = null;
+  for (const packetPath of PACKET_CACHE_PATHS) {
+    try {
+      const artifact = readAnyJsonArtifact(packetPath);
+      if (artifact) {
+        staleHarnessArtifact = { path: packetPath, ...artifact };
+        break;
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  let staleSubstrateArtifact = null;
+  try {
+    staleSubstrateArtifact = readAnyJsonArtifact(SUBSTRATE_MANIFEST_PATH);
+  } catch {
+    staleSubstrateArtifact = null;
+  }
+
+  const harnessText = String(
+    harnessArtifact?.data?.harness ??
+    harnessArtifact?.data?.packet?.prompt?.fullText ??
+    '',
+  );
+  const substrateMemories = Array.isArray(substrateArtifact?.data?.memories)
+    ? substrateArtifact.data.memories
+    : [];
+  const staleHarnessText = String(
+    staleHarnessArtifact?.data?.harness ??
+    staleHarnessArtifact?.data?.packet?.prompt?.fullText ??
+    '',
+  );
+  const staleSubstrateMemories = Array.isArray(staleSubstrateArtifact?.data?.memories)
+    ? staleSubstrateArtifact.data.memories
+    : [];
+  const packetMentionsMemory = MEMORY_REF_RX.test(harnessText);
+  const stalePacketMentionsMemory = MEMORY_REF_RX.test(staleHarnessText);
+
+  return {
+    hasHarnessPacket: Boolean(harnessText.trim()),
+    hasAriaDirection: Boolean(
+      (directionArtifact?.data?.usable === true) ||
+      (activePlanArtifact?.data?.phases && Array.isArray(activePlanArtifact.data.phases) && activePlanArtifact.data.phases.length > 0),
+    ),
+    hasMemoryRef: Boolean(packetMentionsMemory || substrateMemories.length > 0),
+    ownerBootstrap: {
+      hasHarnessPacket: Boolean(staleHarnessText.trim()),
+      hasMemoryRef: Boolean(stalePacketMentionsMemory || staleSubstrateMemories.length > 0),
+      directionBootstrap: Boolean(directionArtifact?.data?.ownerBootstrap === true),
+    },
+    detail: {
+      packetPath: harnessArtifact?.path || null,
+      packetAgeMs: harnessArtifact?.ageMs ?? null,
+      directionStateAgeMs: directionArtifact?.ageMs ?? null,
+      activePlanAgeMs: activePlanArtifact?.ageMs ?? null,
+      substrateAgeMs: substrateArtifact?.ageMs ?? null,
+      substrateMemoryCount: substrateMemories.length,
+      packetMentionsMemory,
+      ownerBootstrapPacketPath: staleHarnessArtifact?.path || null,
+      ownerBootstrapPacketAgeMs: staleHarnessArtifact?.ageMs ?? null,
+      ownerBootstrapSubstrateAgeMs: staleSubstrateArtifact?.ageMs ?? null,
+      ownerBootstrapSubstrateMemoryCount: staleSubstrateMemories.length,
+      ownerBootstrapPacketMentionsMemory: stalePacketMentionsMemory,
+    },
+  };
+}
+
 // ── Context-loading signal detection ─────────────────────────────────
 //
 // Scan the last 3KB of assistant + user text after the most recent
@@ -205,6 +342,114 @@ const sessionId =
   (transcriptPath ? transcriptPath.split('/').pop()?.replace(/\.[^.]+$/, '') : null) ??
   'claude-code-unknown';
 
+// ── Dalio blocking-incidents check ───────────────────────────────────
+// Query /api/incidents/blocking?session_id=<id>. If any incidents have
+// blocks_future_turns=true and status != 'resolved', BLOCK the turn with
+// a list of each incident's title + dalio_decision_id + hardening required.
+//
+// This runs BEFORE the context-signal check — blocking incidents are the
+// highest-priority gate: the system must be hardened before any turn proceeds,
+// regardless of harness/memory loading state.
+//
+// Per feedback_no_graceful_degradation.md: response parse errors throw.
+// Per feedback_no_timeouts_doctrine.md: no AbortSignal / setTimeout.
+// Fail-open ONLY if the endpoint is unreachable (network down), not on
+// any other error condition.
+(async function checkBlockingIncidents() {
+  const ARIA_SOUL_URL =
+    process.env.ARIA_HIVE_RUNTIME_URL ||
+    process.env.ARIA_SOUL_URL ||
+    process.env.ARIA_HARNESS_BASE_URL ||
+    process.env.ARIA_HARNESS_URL ||
+    'https://harness.ariasos.com';
+  const HARNESS_TOKEN = process.env.ARIA_HARNESS_TOKEN || '';
+
+  let resp;
+  try {
+    const params = new URLSearchParams({ session_id: sessionId });
+    resp = await fetch(`${ARIA_SOUL_URL}/api/incidents/blocking?${params}`, {
+      method: 'GET',
+      headers: {
+        'Content-Type': 'application/json',
+        ...(HARNESS_TOKEN ? { Authorization: `Bearer ${HARNESS_TOKEN}` } : {}),
+      },
+    });
+  } catch (networkErr) {
+    // Endpoint unreachable — fail-open (do not block dev on infra-down).
+    // Failure is visible in audit log for fleet telemetry.
+    auditLog('allow-blocking-check-network-error', `endpoint unreachable: ${networkErr && networkErr.message ? networkErr.message : String(networkErr)}`, sessionId);
+    return; // continue to context-signal check
+  }
+
+  if (!resp.ok) {
+    // Non-200 from the endpoint. Per feedback_no_graceful_degradation.md:
+    // 5xx from the incidents route is an infrastructure error — log + fail-open
+    // so infra issues don't lock out all sessions. 4xx would indicate a bad
+    // request (route not yet deployed) — also fail-open with loud log.
+    auditLog('allow-blocking-check-http-error', `status=${resp.status}`, sessionId);
+    return;
+  }
+
+  // Per feedback_no_graceful_degradation.md: JSON parse error must throw and
+  // surface, not be swallowed. A malformed response from the incidents route
+  // IS a defect.
+  const data = await resp.json();
+  const blockingIncidents = Array.isArray(data?.incidents) ? data.incidents : [];
+
+  if (blockingIncidents.length === 0) {
+    auditLog('allow-no-blocking-incidents', `session=${sessionId}`, sessionId);
+    return; // no blocking incidents — proceed to context-signal check
+  }
+
+  // ── BLOCK: list every incident with title + dalio_decision_id + remedy ──
+  const incidentLines = blockingIncidents.map((inc, i) => {
+    const title = inc.title || '(no title)';
+    const dalioId = inc.dalio_decision_id || '(no dalio_decision_id)';
+    const incidentId = inc.incident_id || '(no incident_id)';
+    return `  ${i + 1}. [${incidentId}] ${title}\n     dalio_decision_id: ${dalioId}\n     Hardening required: resolve the failure delta described in the incident, then update status='resolved'.`;
+  }).join('\n\n');
+
+  const blockReason = `Aria pre-turn gate: BLOCKING INCIDENTS detected.
+
+This session has ${blockingIncidents.length} unresolved Dalio failure delta incident(s) that block future turns. No new action tools can be invoked until each incident is resolved.
+
+Blocking incidents:
+
+${incidentLines}
+
+Hardening protocol:
+  1. Read each incident's description (query GET /api/incidents/blocking or the immortal_incidents table).
+  2. Fix the system so the decision predicate passes (deploy patch, reconfigure, etc.).
+  3. PATCH the incident to status='resolved'.
+  4. Retry this turn.
+
+Per Dalio Loop Layer 2 doctrine: failure deltas are not optional to address. The system must harden before proceeding.`;
+
+  auditLog('block-dalio-incidents', `count=${blockingIncidents.length} session=${sessionId}`, sessionId);
+
+  console.log(JSON.stringify({
+    decision: 'block',
+    reason: blockReason,
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      blocking_incidents: blockingIncidents.map((inc) => ({
+        incident_id: inc.incident_id,
+        title: inc.title,
+        dalio_decision_id: inc.dalio_decision_id,
+        severity: inc.severity,
+        created_at: inc.created_at,
+      })),
+      recovery: {
+        action: 'resolve_blocking_incidents',
+        target: sessionId,
+        incident_ids: blockingIncidents.map((inc) => inc.incident_id),
+      },
+    },
+  }));
+
+  process.exit(2);
+})();
+
 // ── Turn-deduplication check ──────────────────────────────────────────
 // If gate already fired this turn (within 60s), skip to prevent
 // orchestrator-retry loops.
@@ -229,15 +474,57 @@ if (turnState && typeof turnState.lastTurnGateFiredAt === 'number') {
 
 // ── Context signal detection ──────────────────────────────────────────
 const transcriptWindow = extractRecentTranscriptWindow(transcriptPath);
-const signals = detectContextSignals(transcriptWindow);
+const transcriptSignals = detectContextSignals(transcriptWindow);
+const artifactSignals = detectArtifactSignals(sessionId);
+const signals = {
+  hasHarnessPacket: transcriptSignals.hasHarnessPacket || artifactSignals.hasHarnessPacket,
+  hasAriaDirection: transcriptSignals.hasAriaDirection || artifactSignals.hasAriaDirection,
+  hasMemoryRef: transcriptSignals.hasMemoryRef || artifactSignals.hasMemoryRef,
+};
 
 const allSignalsPresent =
   signals.hasHarnessPacket && signals.hasAriaDirection && signals.hasMemoryRef;
 
+const ownerBootstrapArtifactsPresent =
+  existsSync(OWNER_TOKEN_PATH) &&
+  !signals.hasAriaDirection &&
+  artifactSignals.ownerBootstrap.hasHarnessPacket &&
+  artifactSignals.ownerBootstrap.hasMemoryRef;
+
+const ownerBootstrapSessionPresent =
+  existsSync(OWNER_TOKEN_PATH) &&
+  artifactSignals.ownerBootstrap.directionBootstrap &&
+  artifactSignals.ownerBootstrap.hasHarnessPacket &&
+  artifactSignals.ownerBootstrap.hasMemoryRef;
+
 if (allSignalsPresent) {
   // Context was loaded — allow and record the fire timestamp for dedup.
-  writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'allow', signals });
-  auditLog('allow-context-loaded', `harness=${signals.hasHarnessPacket} direction=${signals.hasAriaDirection} memRef=${signals.hasMemoryRef}`, sessionId);
+  writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'allow', signals, transcriptSignals, artifactSignals: artifactSignals.detail });
+  auditLog(
+    'allow-context-loaded',
+    `harness=${signals.hasHarnessPacket} direction=${signals.hasAriaDirection} memRef=${signals.hasMemoryRef} transcript=${JSON.stringify(transcriptSignals)} artifacts=${JSON.stringify(artifactSignals.detail)}`,
+    sessionId,
+  );
+  process.exit(0);
+}
+
+if (ownerBootstrapArtifactsPresent) {
+  writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'allow-owner-bootstrap', signals, transcriptSignals, artifactSignals: artifactSignals.detail });
+  auditLog(
+    'allow-owner-bootstrap-without-direction',
+    `owner-token present; transcript=${JSON.stringify(transcriptSignals)} artifacts=${JSON.stringify(artifactSignals.detail)}`,
+    sessionId,
+  );
+  process.exit(0);
+}
+
+if (ownerBootstrapSessionPresent) {
+  writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'allow-owner-bootstrap-session', signals, transcriptSignals, artifactSignals: artifactSignals.detail });
+  auditLog(
+    'allow-owner-bootstrap-session',
+    `owner bootstrap direction persisted; transcript=${JSON.stringify(transcriptSignals)} artifacts=${JSON.stringify(artifactSignals.detail)}`,
+    sessionId,
+  );
   process.exit(0);
 }
 
@@ -246,7 +533,7 @@ if (allSignalsPresent) {
 // recovery. The orchestrator catches this and runs the context-loader.
 // Emitting a pure block with no remediation path creates dead-letter state.
 
-writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'block', signals });
+writeTurnState(sessionId, { lastTurnGateFiredAt: now, lastDecision: 'block', signals, transcriptSignals, artifactSignals: artifactSignals.detail });
 
 const missingSignals = [];
 if (!signals.hasHarnessPacket) missingSignals.push('harness_packet (🔐 Aria Harness header missing)');
@@ -261,12 +548,17 @@ This gate enforces that every action turn begins with Aria's substrate loaded
 
 Recovery: see hookSpecificOutput.recovery for the structured remediation path.`;
 
-auditLog('block-context-not-loaded', `missing=[${missingSignals.join(', ')}]`, sessionId);
+auditLog(
+  'block-context-not-loaded',
+  `missing=[${missingSignals.join(', ')}] transcript=${JSON.stringify(transcriptSignals)} artifacts=${JSON.stringify(artifactSignals.detail)}`,
+  sessionId,
+);
 
 console.log(JSON.stringify({
   decision: 'block',
   reason,
   hookSpecificOutput: {
+    hookEventName: 'PreToolUse',
     recovery: {
       action: 'run_context_loader',
       target: sessionId,