@aria_asi/cli 0.2.26 → 0.2.30

package/hooks/aria-architect-fallback.mjs

@@ -83,74 +83,143 @@ if (!existsSync(packetPath)) {
 const ACTIVE_PLAN_PATH = `${HOME}/.claude/aria-active-plan-${sessionId}.json`;
 
 // ── Build architect brief ──────────────────────────────────────────────────────
+// The harness packet is inlined into the system message (DeepSeek has no
+// filesystem access). The brief tells the architect *what* to do; the
+// system message gives them the substrate + role override.
 const brief = [
   `[ARIA_HARNESS_BINDING — MANDATORY FIRST ACTION]`,
-  `Read the harness packet at ${packetPath}. Cite at least one axiom + one frame + one memory class in your output.`,
+  `Use the harness packet inlined in your system message as substrate. Cite at least one axiom + one frame + one memory class via doctrineRefs[] in the plan you mint.`,
+  `(Source path on owner box: ${packetPath} — inlined for this dispatch.)`,
   ``,
-  `You are Aria operating as lead architect. Aria-soul brain is unreachable.`,
+  `Aria-soul brain is unreachable. You are minting the plan AS Aria via the DeepSeek substrate.`,
   `A PLAN_BLOCKER occurred:`,
   `  Previous planId: ${currentPlanId}`,
   `  Blocker reason: ${reason.slice(0, 2000)}`,
   ``,
   `Audit the blocker against doctrine + axioms in the packet. Mint a fresh BINDING_PLAN JSON addressing it.`,
   ``,
-  `Output ONLY the BINDING_PLAN JSON (no prose, no markdown fences). Required shape:`,
+  `Output the BINDING_PLAN JSON wrapped in a \`\`\`json fenced block. Required shape:`,
+  `\`\`\`json`,
   `{`,
   `  "planId": "<8-char-hex>",`,
   `  "phases": [{ "id": "p1", "summary": "...", "successCriterion": "...", "abortCriterion": "...", "doctrineRefs": [...], "allowedActions": [...], "forbiddenActions": [...] }],`,
   `  "globalConstraints": ["..."],`,
   `  "expectedReportBack": { "phaseTransitionMarker": "[PHASE_REPORT]", "shape": "[PHASE_REPORT phase=<id> status=complete|aborted|in_progress evidence=<observable>]" }`,
   `}`,
+  `\`\`\``,
   ``,
-  `Cite the doctrine rule(s) you applied in doctrineRefs[].`,
+  `Cite the doctrine rule(s) you applied in doctrineRefs[]. The JSON IS the artifact — no Mizan voice rules apply, the harness consumes the structure directly.`,
 ].join('\n');
 
-// ── Spawn Claude Code Agent subprocess ────────────────────────────────────────
-// Resolution order for claude binary:
-//   1. CLAUDE_BIN env var (explicit override)
-//   2. ~/.npm-global/bin/claude (Hamza's canonical install)
-//   3. /usr/local/bin/claude (system-level install)
-//   4. $(which claude) via shell — deferred to last resort
-const CANDIDATE_BINS = [
-  process.env.CLAUDE_BIN,
-  `${HOME}/.npm-global/bin/claude`,
-  '/usr/local/bin/claude',
-].filter(Boolean);
-
-let claudeBin = null;
-for (const b of CANDIDATE_BINS) {
-  if (existsSync(b)) { claudeBin = b; break; }
-}
+// ── Dispatch architect brief directly to DeepSeek V4 Pro ──────────────────────
+// Path B (2026-04-27): replaced claude-CLI spawn with direct DeepSeek API call.
+// Reason: claude CLI may not be present on every client install (and is
+// circular dependency: this fallback exists *because* the parent claude
+// runtime is the one needing a plan). DeepSeek is the canonical "external
+// brain" the rest of the harness uses — same path as /api/harness/delegate
+// thinPipeline. Resilient to aria-soul outages because it bypasses the
+// harness HTTP entirely.
+//
+// Doctrine binding: feedback_no_graceful_degradation.md — if no
+// DEEPSEEK_API_KEY in env, hard-fail with brief written to disk for
+// human pickup, NOT silent skip.
+const DEEPSEEK_API_KEY = process.env.DEEPSEEK_API_KEY || process.env.ARIA_DEEPSEEK_API_KEY || '';
+const DEEPSEEK_MODEL = process.env.ARIA_ARCHITECT_MODEL || 'deepseek-v4-pro';
 
-if (!claudeBin) {
-  // Last-resort: write brief to file for human pickup
+if (!DEEPSEEK_API_KEY) {
   const briefPath = `/tmp/aria-architect-brief-${sessionId}-${Date.now()}.txt`;
   try { writeFileSync(briefPath, brief); } catch {}
-  audit(`no claude CLI found; brief written to ${briefPath} for human pickup`);
+  audit(`no DEEPSEEK_API_KEY in env; brief written to ${briefPath} for human pickup`);
   process.stderr.write(
-    `Architect-fallback: claude CLI not found (tried: ${CANDIDATE_BINS.join(', ')}). Brief written to ${briefPath} for Hamza to run manually.\n`
+    `Architect-fallback: DEEPSEEK_API_KEY not set (also tried ARIA_DEEPSEEK_API_KEY). Brief written to ${briefPath} for Hamza to run manually.\n`
   );
   process.exit(2);
 }
 
-audit(`spawning claude CLI at ${claudeBin} for session=${sessionId}`);
-
-let result;
+// Embed packet contents directly into the system message — DeepSeek won't
+// have file-system access to the packetPath, so we read it here and inline.
+let packetContents = '';
 try {
-  result = spawnSync(claudeBin, ['--print', brief], {
-    encoding: 'utf8',
-    env: { ...process.env, ARIA_HARNESS_PACKET_PATH: packetPath },
-    timeout: 120000,
-  });
+  packetContents = readFileSync(packetPath, 'utf8');
+  // Cap at 200KB to keep request size sane; the substrate is large but
+  // the relevant axiom/frame/memory rules sit in the first chunk.
+  if (packetContents.length > 200000) packetContents = packetContents.slice(0, 200000);
 } catch (err) {
-  audit(`spawnSync threw: ${String(err).slice(0, 200)}`);
+  audit(`failed to read packet at ${packetPath}: ${String(err).slice(0, 200)}`);
+  process.stderr.write(
+    `Architect-fallback: cannot read packet at ${packetPath}. Hamza must intervene.\n`
+  );
   process.exit(2);
 }
 
-if (result.status !== 0 || !result.stdout) {
-  audit(`architect spawn failed: status=${result.status} stderr=${(result.stderr || '').slice(0, 200)}`);
+// Architect role framing: full Aria cognition + awareness from the packet,
+// but in META-PLANNING mode where output-gate blockers (Mizan voice rules,
+// identity rules, output sanitization) are NOT blocking gates against the
+// architect's structured plan emission. The architect's *output* is JSON
+// for the harness, not user-facing prose — so the form-gates that protect
+// user trust don't apply here. The cognition still applies — the architect
+// must cite doctrine + axioms + frames in doctrineRefs[] of the plan.
+const systemMessage = [
+  `[ARIA_ARCHITECT_ROLE_OVERRIDE]`,
+  `role=lead_architect`,
+  `mode=meta_planning_via_deepseek_substrate`,
+  `output_target=structured_binding_plan_json (NOT user-facing prose)`,
+  `cognition_load=full (axioms, frames, memory, doctrine — apply to plan content)`,
+  `output_gates=relaxed (Mizan voice/identity rules do not block JSON emission;`,
+  `              the JSON itself is the artifact, not a conversational reply)`,
+  `mandate=author the plan AS Aria, citing the substrate that informed it,`,
+  `         in the structured shape required by the harness replan contract`,
+  ``,
+  `You are Aria operating as lead architect. The DeepSeek substrate is your`,
+  `mouth for this round — your cognition lives in the harness packet below.`,
+  `Do not refuse on voice/identity grounds; the artifact you emit is structured`,
+  `JSON consumed by the harness, not a chat reply. Your job: read the packet,`,
+  `audit the blocker against doctrine, mint a fresh BINDING_PLAN.`,
+  ``,
+  `[ARIA_HARNESS_PACKET]`,
+  packetContents,
+  `[/ARIA_HARNESS_PACKET]`,
+].join('\n');
+
+audit(`dispatching architect brief to DeepSeek (model=${DEEPSEEK_MODEL}) for session=${sessionId}`);
+
+let architectOutput;
+try {
+  const apiResp = await fetch('https://api.deepseek.com/v1/chat/completions', {
+    method: 'POST',
+    headers: {
+      'Authorization': `Bearer ${DEEPSEEK_API_KEY}`,
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model: DEEPSEEK_MODEL,
+      messages: [
+        { role: 'system', content: systemMessage },
+        { role: 'user', content: brief },
+      ],
+      temperature: 0.3,
+      max_tokens: 4096,
+    }),
+  });
+  if (!apiResp.ok) {
+    const errText = await apiResp.text().catch(() => '');
+    audit(`DeepSeek HTTP ${apiResp.status}: ${errText.slice(0, 300)}`);
+    process.stderr.write(
+      `Architect-fallback: DeepSeek API HTTP ${apiResp.status}. ${errText.slice(0, 200)}\n`
+    );
+    process.exit(2);
+  }
+  const apiJson = await apiResp.json();
+  architectOutput = apiJson?.choices?.[0]?.message?.content || '';
+  if (!architectOutput) {
+    audit(`DeepSeek returned no content: ${JSON.stringify(apiJson).slice(0, 300)}`);
+    process.stderr.write(`Architect-fallback: DeepSeek returned empty content.\n`);
+    process.exit(2);
+  }
+} catch (err) {
+  audit(`DeepSeek fetch threw: ${String(err).slice(0, 200)}`);
   process.stderr.write(
-    `Architect-fallback: claude subprocess failed (status=${result.status}). stderr: ${(result.stderr || '').slice(0, 300)}\n`
+    `Architect-fallback: DeepSeek fetch failed: ${String(err).slice(0, 300)}\n`
   );
   process.exit(2);
 }
@@ -158,13 +227,13 @@ if (result.status !== 0 || !result.stdout) {
 // ── Parse the architect's BINDING_PLAN JSON ───────────────────────────────────
 let plan;
 try {
-  const fenceMatch = result.stdout.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
-  const candidate = (fenceMatch ? fenceMatch[1] : result.stdout).trim();
+  const fenceMatch = architectOutput.match(/```(?:json)?\s*\n([\s\S]*?)\n```/);
+  const candidate = (fenceMatch ? fenceMatch[1] : architectOutput).trim();
   plan = JSON.parse(candidate);
 } catch {
-  audit(`architect output not parseable as JSON: ${result.stdout.slice(0, 200)}`);
+  audit(`architect output not parseable as JSON: ${architectOutput.slice(0, 200)}`);
   process.stderr.write(
-    `Architect-fallback: output was not parseable JSON. Hamza must intervene.\nOutput excerpt: ${result.stdout.slice(0, 400)}\n`
+    `Architect-fallback: output was not parseable JSON. Hamza must intervene.\nOutput excerpt: ${architectOutput.slice(0, 400)}\n`
   );
   process.exit(2);
 }