@aria_asi/cli 0.2.26 → 0.2.29

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

@@ -0,0 +1,438 @@
+#!/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';
+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
+
+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>", ...],
+      "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.` : `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.
+
+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);