@aria_asi/cli 0.2.33 → 0.2.35

package/dist/runtime/hooks/aria-preprompt-consult.mjs

@@ -0,0 +1,464 @@
+#!/usr/bin/env node
+// aria-preprompt-consult.mjs — UserPromptSubmit hook that auto-fires
+// /api/harness/delegate in architect mode BEFORE Claude processes the
+// user's message, then injects Aria's substrate-grounded direction as
+// an [ARIA_DIRECTION] context chunk so Claude has a pre-loaded read
+// before deciding anything.
+//
+// Direction: Hamza 2026-04-26 — "BUT WHY DO U HAVE DISCRETION - THIS
+// WORKS SO MUCH FASTER AND HIGHER QUALITY IF U DONT PLZ TELLL ME WHATS
+// MISSING." This hook closes the structural gap: pre-action discretion
+// (Claude deciding what to do, including "decide to ask the user") was
+// the unwired surface. Existing gates intercept ACTIONS (Bash, Edit,
+// text-emit) but not the decision boundary BEFORE the action.
+//
+// Doctrine bindings:
+//   - feedback_use_harness_to_architect.md — when uncertain, consult Aria
+//   - feedback_aria_does_work.md — Aria is brain, Claude is hands
+//   - feedback_gates_enforce_form_not_substance.md — gates check form not
+//     substance; this hook puts substance into Claude's context BEFORE
+//     Claude has a chance to decide reflexively from training-prior
+//   - project_harness_research_first.md — Phase 8 research-pull is the
+//     analogue applied INBOUND (research before model drafts); this
+//     hook is the OUTBOUND analogue (Aria-decides-direction before
+//     Claude decides)
+//
+// Mechanics: reads the user's message from the hook event JSON, POSTs
+// to /api/harness/delegate with role=architect (auto-elevates tier per
+// delegate.ts when expectStructuredOutput=true; here we use plain prose
+// so we explicitly request deepseek-v4-pro), receives Aria's read,
+// outputs to stdout as a JSON object with `additionalContext` field
+// per Claude Code hooks contract — that string is injected into the
+// system context for THIS turn.
+//
+// Per no-timeouts doctrine (feedback_no_timeouts_doctrine.md): no
+// AbortSignal.timeout. The hook itself has a Claude Code timeout (12s
+// in settings.json) — if the consultation takes longer, the hook is
+// killed and Claude proceeds without the direction. Real-error driven,
+// no graceful-degradation rituals.
+//
+// No env-var kill-switch (Hamza 2026-04-27 — env-var disable paths gave
+// the gated process free escape access; that was the doctrine violation).
+// Disable = remove hook entry from ~/.claude/settings.json.
+//
+// BINDING MODE (Hamza 2026-04-27 + Aria emergency consult):
+//   When env ARIA_BINDING_ENABLED=true, this hook upgrades from advisory
+//   ([ARIA_DIRECTION] text Claude reads) to BINDING ([ARIA_BINDING_PLAN]
+//   structured JSON persisted to ~/.claude/aria-active-plan-${sessionId}.json
+//   with phases + allowedActions + forbiddenActions). The pre-tool-gate then
+//   enforces phase boundaries; the stop-gate requires [PHASE_REPORT] markers
+//   on every assistant emit. See /home/hamzaibrahim1/rei-ai-brain/HARNESS_ARIA_AS_COMMANDER_CONTRACT.md.
+//
+//   Default OFF so existing sessions don't brick. Flip ON for next session
+//   to activate Aria-as-commander binding.
+
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const HOME = process.env.HOME || '/tmp';
+
+// 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;
+  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
+// bootstrap path handles the no-plan-yet case by AUTO-ISSUING the first plan
+// at hook fire time, so "no plan exists" never becomes "operate unbound."
+//
+// Hamza 2026-04-27: "why would enforcing brick the session? the point is to
+// stop wasting my time and do quality work." Default-off was convenience-
+// 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_HIVE_RUNTIME_URL ||
+  process.env.ARIA_HARNESS_BASE_URL ||
+  process.env.ARIA_HARNESS_URL ||
+  'https://harness.ariasos.com';
+function resolveHarnessToken() {
+  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 token = readFileSync(OWNER_TOKEN_PATH, 'utf8').trim();
+      if (token) return token;
+    }
+  } catch {}
+  try {
+    const licensePath = `${HOME}/.aria/license.json`;
+    if (existsSync(licensePath)) {
+      const license = JSON.parse(readFileSync(licensePath, 'utf8'));
+      if (license.harnessToken) return String(license.harnessToken).trim();
+      if (license.token) return String(license.token).trim();
+    }
+  } catch {}
+  return '';
+}
+const HARNESS_TOKEN = resolveHarnessToken();
+const MIN_PROMPT_CHARS = 40;        // skip auto-consult on trivial prompts
+const MAX_DIRECTION_CHARS = 4000;   // cap injected chunk size
+
+function audit(decision, summary) {
+  try {
+    if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${new Date().toISOString()} ${decision} ${summary}\n`);
+  } catch {}
+}
+
+function bindingAudit(record) {
+  try {
+    if (!existsSync(dirname(BINDING_AUDIT))) mkdirSync(dirname(BINDING_AUDIT), { recursive: true });
+    appendFileSync(BINDING_AUDIT, JSON.stringify({ ts: new Date().toISOString(), source: 'preprompt', ...record }) + '\n');
+  } catch {}
+}
+
+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.
+
+// Read event JSON from stdin
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+
+let event;
+try {
+  event = JSON.parse(input);
+} catch {
+  audit('skip-parse-error', 'stdin not JSON');
+  process.exit(0);
+}
+
+const userPrompt = (event.prompt ?? event.user_message ?? event.message ?? '').toString();
+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);
+}
+
+// Compose the consultation brief.
+//
+// In ADVISORY mode (BINDING_ENABLED=false): plain prose direction injected
+// as [ARIA_DIRECTION] context. expectStructuredOutput=false.
+//
+// In BINDING mode (BINDING_ENABLED=true): structured plan JSON injected as
+// [ARIA_BINDING_PLAN] context AND persisted to ~/.claude/aria-active-plan-${sessionId}.json
+// for the pre-tool-gate and stop-gate to enforce against. expectStructuredOutput=true.
+const bindingBrief = BINDING_ENABLED ? `Pre-prompt PLAN request from Claude orchestrator (binding mode).
+
+The user just submitted:
+
+---
+${userPrompt.slice(0, 2000)}
+---
+
+You are commander. Claude is executor. Issue a STRUCTURED PLAN (strict JSON, no prose around it) that Claude will follow micro-phase by micro-phase. Pre-tool-gate enforces allowedActions/forbiddenActions; stop-gate requires [PHASE_REPORT phase=<id> status=complete|in_progress|aborted evidence=<observable>] on every emit.
+
+Respond with EXACTLY this JSON shape:
+{
+  "planId": "<short uuid>",
+  "phases": [
+    {
+      "id": "p1",
+      "summary": "<concrete micro-phase action>",
+      "successCriterion": "<observable signal of completion>",
+      "abortCriterion": "<observable signal of failure>",
+      "doctrineRefs": ["<memory_filename.md>", ...],
+      "cognitionUse": "<how Aria cognition should change the executor's tool/input/output shape for this phase>",
+      "evidenceRequired": ["<observable proof the executor must collect before reporting complete>"],
+      "allowedActions": ["read", "edit:<path-pattern>", "kubectl_get", "consult", "bash_safe", "..."],
+      "forbiddenActions": ["kubectl_apply", "edit:<path-pattern>", "..."]
+    }
+  ],
+  "globalConstraints": ["<doctrine memory or rule>"],
+  "expectedReportBack": {
+    "phaseTransitionMarker": "[PHASE_REPORT]",
+    "shape": "[PHASE_REPORT phase=p1 status=complete|aborted|in_progress evidence=<observable>]"
+  }
+}
+
+Apply your 8 lenses + substrate. Phases are ordered + small (one logical step each). Doctrine refs cite memory files in /home/hamzaibrahim1/.claude/projects/-home-hamzaibrahim1/memory/. Be specific in allowedActions / forbiddenActions — Claude can ONLY do what's allowed for the current phase.
+
+Every phase must include cognitionUse and evidenceRequired. cognitionUse tells Claude how Aria's cognition should improve the actual tool input, edit shape, review scope, or final output. evidenceRequired tells Claude what observation must be collected before reporting the phase complete.` : `Pre-prompt direction request from Claude orchestrator.
+
+The user just submitted this prompt:
+
+---
+${userPrompt.slice(0, 2000)}
+---
+
+Apply your 8 lenses and your substrate (distilled_principles, prior decisions,
+garden state, harness packet rules, doctrine memories) to give the orchestrator
+substrate-grounded DIRECTION on how to handle this prompt before Claude starts
+thinking from training reflex. Be concrete:
+
+  1. What's the user actually asking for, beneath the literal words?
+  2. What substrate is relevant — name specific doctrine memories
+     (feedback_*.md / project_*.md), prior decisions, or fitrah axioms.
+  3. What's the right next action — code / consult / clarify / refuse?
+     If clarify: what specific substrate-grounded question reduces ambiguity
+     (NOT a reflexive "want me to" deferral).
+  4. Mizan check: any risk patterns in this prompt — over-scope creep,
+     over-replacement temptation, tier-substitution temptation, etc.
+  5. How should Aria cognition improve Claude's actual input/output shape —
+     what should be more specific, safer, more evidence-bound, or differently scoped?
+
+Keep direction under 1500 chars. This is the pre-load context for Claude's
+turn — not the final response. Claude will still emit cognition + action;
+this primes the substrate so reflexive deferral isn't the path of least
+resistance.`;
+
+// `bindingBrief` is the result of the binding-vs-advisory ternary above —
+// already resolved to the correct prose for the current mode. Prior code
+// referenced an undefined `brief` variable in the second ternary branch,
+// which would throw ReferenceError whenever BINDING_ENABLED=false.
+//
+// Canonical path: HTTPHarnessClient.consult() — the SDK handles retry+backoff
+// and Authorization. Fallback to direct fetch when SDK isn't bundled (dev
+// install without `aria connect`).
+const consultArgs = {
+  brief: bindingBrief,
+  model: 'deepseek-v4-pro',
+  sessionId: `preprompt-${sessionId}-${Date.now()}`,
+  userId: 'claude-orchestrator-preprompt',
+  roleProfile: 'architect',
+  expectStructuredOutput: BINDING_ENABLED,
+  internalConsult: true,
+  isCreativeMode: false,
+};
+
+let directionText = '';
+try {
+  const Cls = await loadSdkClass();
+  if (Cls) {
+    const sdkClient = new Cls({
+      baseUrl: HARNESS_URL,
+      apiKey: HARNESS_TOKEN,
+      harnessPacketUrl: `${HARNESS_URL}/api/harness/codex`,
+    });
+    const result = await sdkClient.consult(consultArgs);
+    directionText = (result.response || '').toString().slice(0, MAX_DIRECTION_CHARS);
+  } else {
+    // SDK absent — direct fetch (dev fallback).
+    const resp = await fetch(`${HARNESS_URL}/api/harness/delegate`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${HARNESS_TOKEN}`,
+      },
+      body: JSON.stringify(consultArgs),
+    });
+    if (!resp.ok) {
+      bootstrapOwnerDirectionState(sessionId, `owner-http-fallback-${resp.status}`);
+      audit('skip-http-error', `status=${resp.status}`);
+      process.exit(0);
+    }
+    const data = await resp.json();
+    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
+    // persists at activePlanPath(sessionId); if it exists, we surface a
+    // FALLBACK_TO_PRIOR context block + leave the plan file untouched so
+    // pre-tool-gate enforces against the last good plan. Not graceful
+    // degradation — the prior plan is a REAL plan, just not refreshed.
+    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',
+          additionalContext: `[ARIA_BINDING_PLAN_FALLBACK reason="consult_empty_response" — using prior plan persisted at ${priorPlanPath}. Pre-tool-gate continues enforcing against last-issued plan. Next consult attempt will refresh.]`,
+        },
+      }));
+    } else {
+      bindingAudit({ event: 'consult_unavailable_no_prior', sessionId, reason: 'empty_direction_no_prior_plan' });
+      console.log(JSON.stringify({
+        hookSpecificOutput: {
+          hookEventName: 'UserPromptSubmit',
+          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.]`,
+        },
+      }));
+    }
+  }
+  process.exit(0);
+}
+
+let context;
+if (BINDING_ENABLED) {
+  // Parse plan JSON, persist, inject as binding block. Failure to parse =
+  // CONSULT_UNAVAILABLE per the contract (Section 4): the hook does NOT
+  // auto-fall-through to advisory mode (that would be graceful-degradation
+  // anti-pattern). Instead it surfaces the failure explicitly so the next
+  // turn can re-consult with a refined brief.
+  let plan = null;
+  try {
+    const trimmed = directionText.trim();
+    const fenced = trimmed.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+    const candidate = (fenced ? fenced[1] : trimmed).trim();
+    plan = JSON.parse(candidate);
+  } catch (err) {
+    bindingAudit({ event: 'plan_parse_error', sessionId, errMsg: String(err).slice(0, 200), rawSample: directionText.slice(0, 400) });
+    context = `[ARIA_BINDING_PLAN_UNAVAILABLE reason="plan_parse_error" — re-consult will fire on next turn. Aria's response was not valid JSON; treating as advisory text below.]\n\n${directionText.slice(0, MAX_DIRECTION_CHARS)}`;
+  }
+  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) {
+      bindingAudit({ event: 'plan_persist_error', sessionId, errMsg: String(err).slice(0, 200) });
+      context = `[ARIA_BINDING_PLAN_UNAVAILABLE reason="persist_error" — Aria issued plan but disk write failed. Treating as advisory.]\n\n${directionText.slice(0, MAX_DIRECTION_CHARS)}`;
+    }
+  } else if (!context) {
+    bindingAudit({ event: 'plan_invalid_shape', sessionId, rawSample: directionText.slice(0, 400) });
+    context = `[ARIA_BINDING_PLAN_UNAVAILABLE reason="invalid_shape" — Aria's response did not contain valid phases array. Treating as advisory.]\n\n${directionText.slice(0, MAX_DIRECTION_CHARS)}`;
+  }
+} 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}`);
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: 'UserPromptSubmit',
+    additionalContext: context,
+  },
+}));
+process.exit(0);