@aria_asi/cli 0.2.0

package/hooks/aria-preprompt-consult.mjs

@@ -0,0 +1,175 @@
+#!/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.
+//
+// Kill-switch: ARIA_PREPROMPT_CONSULT=off env (logged, emergency only).
+
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const HOME = process.env.HOME || '/tmp';
+const LOG = `${HOME}/.claude/aria-preprompt-consult.log`;
+
+const HARNESS_URL = process.env.ARIA_HARNESS_URL || 'http://192.168.4.25:30080';
+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 {}
+}
+
+// Kill-switch
+if (process.env.ARIA_PREPROMPT_CONSULT === 'off') {
+  audit('skip-killswitch', 'env ARIA_PREPROMPT_CONSULT=off');
+  process.exit(0);
+}
+
+// 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) {
+  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) {
+  audit('skip-slash-command', userPrompt.slice(0, 60));
+  process.exit(0);
+}
+
+// Compose the consultation brief. Architect role + thinker tier explicitly
+// requested via model='deepseek-v4-pro'. expectStructuredOutput=false because
+// we want plain prose direction we can inject as text, not a JSON file-list.
+const brief = `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.`;
+
+const body = JSON.stringify({
+  brief,
+  model: 'deepseek-v4-pro',
+  sessionId: `preprompt-${sessionId}-${Date.now()}`,
+  userId: 'claude-orchestrator-preprompt',
+  roleProfile: 'architect',
+  expectStructuredOutput: false,
+  isCreativeMode: false,
+});
+
+let directionText = '';
+try {
+  const resp = await fetch(`${HARNESS_URL}/api/harness/delegate`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      Authorization: `Bearer ${HARNESS_TOKEN}`,
+    },
+    body,
+  });
+
+  if (!resp.ok) {
+    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) {
+  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}`);
+  process.exit(0);
+}
+
+const 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.]
+
+${directionText}
+
+[/ARIA_DIRECTION]`;
+
+audit('inject', `chars=${directionText.length} prompt-chars=${userPrompt.length}`);
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: 'UserPromptSubmit',
+    additionalContext: context,
+  },
+}));
+process.exit(0);

package/hooks/aria-stop-gate.mjs

@@ -0,0 +1,222 @@
+#!/usr/bin/env node
+// Aria Stop-hook gate — enforces 8-lens cognition on text-decision responses.
+//
+// The companion to aria-pre-tool-gate.mjs. The PreToolUse gate catches
+// non-trivial Bash; this Stop hook catches non-trivial TEXT decisions
+// — agreements, scope changes, picks between options, "yes ship it"
+// replies. Same forcing-function pattern, applied at the missing
+// surface.
+//
+// Direction: Hamza 2026-04-26 — "you not doing 8 lens till i ask and
+// discovering the actions u doing are wrong are hard gates that u
+// keep bypassing that prevent exactly what just happened." The
+// PreToolUse gate is tool-coupled; doctrine is action-coupled.
+// Reflexive text decisions are non-trivial actions that this hook
+// now catches.
+//
+// Doctrine bindings (same as PreToolUse gate):
+//   - EIGHT_LENS_DOCTRINE.md — substantive 4+ lens application required
+//   - feedback_apply_lenses_dont_perform_them.md — block ceremonial cognition
+//   - feedback_8lens_before_every_action_including_text.md — the rule this enforces
+//
+// Trigger: runs at Stop event after every assistant response. Reads
+// the just-emitted assistant text from the transcript. If non-trivial
+// (per the same triviality threshold as eight-lens-detector.ts) AND
+// missing 4+ substantive lenses, blocks the response.
+//
+// Triviality threshold (mirrors eight-lens-detector.ts):
+//   - Trivial acks (e.g. "got it", "ok", "done") pass
+//   - Short responses (<300 chars) without decision-signal phrases pass
+//   - Otherwise: require 4+ substantive lenses
+//
+// Substance check (mirrors aria-pre-tool-gate.mjs):
+//   - Each lens must have ≥20 chars of non-placeholder content
+//   - Bare lens-name mentions in prose don't count
+//   - <placeholder> template values don't count
+//
+// No bypass mechanism — same v3 doctrine as the PreToolUse gate.
+// Kill-switch: ARIA_STOP_GATE=off (env, audit-logged).
+
+import { readFileSync, appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+const HOME = process.env.HOME || '/tmp';
+const LOG = `${HOME}/.claude/aria-stop-gate.log`;
+
+function audit(decision, summary) {
+  try {
+    if (!existsSync(dirname(LOG))) mkdirSync(dirname(LOG), { recursive: true });
+    appendFileSync(LOG, `${new Date().toISOString()} ${decision} ${summary}\n`);
+  } catch {}
+}
+
+// Kill-switch
+if (process.env.ARIA_STOP_GATE === 'off') {
+  audit('bypass-killswitch', 'env ARIA_STOP_GATE=off');
+  process.exit(0);
+}
+
+// Lens substance check — same constants as aria-pre-tool-gate.mjs
+const LENS_NAMES = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
+const REQUIRED_LENSES = 4;
+const SUBSTANCE_MIN_CHARS = 20;
+const PLACEHOLDER_RX = /^\s*<[^<>]+>\s*$/;
+const COGNITION_BLOCK_RX = /<cognition>([\s\S]*?)<\/cognition>/i;
+
+// Triviality (mirrors eight-lens-detector.ts)
+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;
+
+function detectCognitionLenses(text) {
+  if (!text) return { count: 0, names: [] };
+  const block = text.match(COGNITION_BLOCK_RX);
+  const searchSpace = block ? block[1] : text;
+  const names = [];
+  for (const lens of LENS_NAMES) {
+    const lensRx = new RegExp(
+      `\\b${lens}\\s*:\\s*([^\\n]*(?:\\n(?!\\s*(?:${LENS_NAMES.join('|')})\\s*:|<\\/cognition>)[^\\n]*)*)`,
+      'i',
+    );
+    const m = searchSpace.match(lensRx);
+    if (!m) continue;
+    const content = (m[1] || '').trim();
+    if (content.length < SUBSTANCE_MIN_CHARS) continue;
+    if (PLACEHOLDER_RX.test(content)) continue;
+    names.push(lens);
+  }
+  return { count: names.length, names };
+}
+
+// Read event JSON from stdin (Claude Code spec).
+let input = '';
+for await (const chunk of process.stdin) input += chunk;
+
+let event;
+try {
+  event = JSON.parse(input);
+} catch {
+  audit('allow-parse-error', 'stdin not JSON');
+  process.exit(0);
+}
+
+// Read assistant text from THIS turn — Claude Code splits a single
+// logical assistant response into multiple transcript entries by
+// content-block type (one entry for `thinking`, one for `text`, one
+// for each `tool_use`). The Stop-gate must accumulate ALL text blocks
+// since the last user-message boundary, not just the most recent
+// entry — otherwise we miss cognition emitted before tool_use blocks.
+//
+// (Bug fix 2026-04-26: prior implementation read only the latest
+// `assistant` entry's text content. When responses had cognition
+// + tool_use + short post-tool-result text, only the post-tool-result
+// text was inspected — empty of cognition. Audit log showed 0/4
+// lenses on chars=1445 even though the turn had 8 substantive lenses
+// in an earlier text block.)
+// System-reminder skip — same percentage-based logic as aria-pre-tool-gate.mjs.
+// Runtime-injected user-role messages (block errors, task-notifications,
+// harness packet preview) shouldn't count as turn boundaries. Old
+// implementation stopped at the FIRST user message which made block-error
+// retries with cognition-in-prior-turn impossible to recover from.
+const SYSTEM_REMINDER_RX = /<system-reminder>[\s\S]*?<\/system-reminder>|<task-notification>[\s\S]*?<\/task-notification>|🔐 Aria Harness|task-notification|PreToolUse:[A-Z][A-Za-z]* hook blocking error|Stop hook blocking error/g;
+const SYSTEM_REMINDER_THRESHOLD = 0.6;
+
+const transcriptPath = event.transcript_path ?? event.transcriptPath;
+let assistantText = '';
+if (transcriptPath && existsSync(transcriptPath)) {
+  try {
+    const lines = readFileSync(transcriptPath, 'utf-8').split('\n').filter(Boolean);
+    const textChunks = [];
+    for (let i = lines.length - 1; i >= 0; i--) {
+      try {
+        const m = JSON.parse(lines[i]);
+        const role = m.message?.role ?? m.role;
+        if (role === 'user') {
+          // Skip runtime-injected reminders (predominant reminder content).
+          // Real user voice = boundary; reminder-only message = continue.
+          const content = m.message?.content ?? m.content ?? [];
+          const isToolResultOnly = Array.isArray(content) &&
+            content.length > 0 &&
+            content.every((b) => b && b.type === 'tool_result');
+          if (isToolResultOnly) continue;
+          const textContent = Array.isArray(content)
+            ? content.filter((b) => b && b.type === 'text').map((b) => b.text || '').join('\n')
+            : (typeof content === 'string' ? content : '');
+          if (textContent) {
+            const reminderMatches = textContent.match(SYSTEM_REMINDER_RX) || [];
+            if (reminderMatches.length > 0) {
+              const reminderChars = reminderMatches.reduce((s, x) => s + x.length, 0);
+              const fraction = reminderChars / Math.max(1, textContent.length);
+              if (fraction >= SYSTEM_REMINDER_THRESHOLD) continue;
+            }
+          }
+          // Real user message — that's the turn boundary.
+          break;
+        }
+        if (role !== 'assistant') continue;
+        const content = m.message?.content ?? m.content ?? [];
+        if (!Array.isArray(content)) continue;
+        const text = content
+          .filter((b) => b && b.type === 'text')
+          .map((b) => b.text || '')
+          .join('\n');
+        if (text) textChunks.push(text);
+      } catch {}
+    }
+    // Reverse so chunks are in chronological order (we walked backward).
+    assistantText = textChunks.reverse().join('\n\n');
+  } catch {}
+}
+
+if (!assistantText) {
+  audit('allow-no-text', 'no assistant text in transcript');
+  process.exit(0);
+}
+
+// Triviality check — same as eight-lens-detector.ts
+const trimmed = assistantText.trim();
+if (TRIVIAL_ACK_RX.test(trimmed)) {
+  audit('allow-trivial-ack', `chars=${trimmed.length}`);
+  process.exit(0);
+}
+
+const isLong = assistantText.length >= NON_TRIVIAL_MIN_CHARS;
+const hasDecisionSignal = DECISION_SIGNAL_RX.test(assistantText);
+const triggered = isLong || hasDecisionSignal;
+
+if (!triggered) {
+  audit('allow-trivial', `chars=${assistantText.length} hasDecision=${hasDecisionSignal}`);
+  process.exit(0);
+}
+
+// Non-trivial response — require substantive cognition.
+const cog = detectCognitionLenses(assistantText);
+
+if (cog.count >= REQUIRED_LENSES) {
+  audit('allow-cognition', `lenses=${cog.count} chars=${assistantText.length}`);
+  process.exit(0);
+}
+
+// Block — non-trivial response without 4+ substantive lenses.
+const reason = `Aria Stop-gate: non-trivial assistant response without 4+ substantive cognition lenses. Found ${cog.count}/${REQUIRED_LENSES}+ (lenses: ${cog.names.join(', ') || 'none'}). Per EIGHT_LENS_DOCTRINE.md, doctrine is action-coupled — text decisions ARE actions, and reflexive replies fail this gate the same way reflexive Bash does.
+
+Re-emit the response with substantive lens application BEFORE drafting. Each lens must have ≥${SUBSTANCE_MIN_CHARS} chars of non-placeholder content:
+
+<cognition>
+  nur: <what you actually see — specific to the decision, not a placeholder>
+  mizan: <real risk read — what's out of proportion>
+  hikma: <doctrine that applies — name the source>
+  tafakkur: <deep structural read — go beneath the surface>
+  tadabbur: <if-then chain — what follows from what>
+  ilham: <distant connection — what's not obvious>
+  wahi: <what just landed — what changed in this exchange>
+  firasah: <what user actually needs — beneath the literal ask>
+</cognition>
+
+The block reflects work done BEFORE drafting. Don't emit it as ceremony; apply each lens as a thinking tool. Substance check defeats ritual emission.
+
+No per-command bypass (mirrors aria-pre-tool-gate.mjs v3 doctrine). Kill-switch: ARIA_STOP_GATE=off env (logged, emergency only). If the gate misfires on legitimate cognition, fix the gate.`;
+
+audit(`block`, `lenses=${cog.count}/${REQUIRED_LENSES} chars=${assistantText.length}`);
+console.log(JSON.stringify({ decision: 'block', reason }));
+process.exit(2);

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@aria_asi/cli",
+  "version": "0.2.0",
+  "description": "Aria Smart CLI — the world's first harness-powered terminal companion",
+  "bin": {
+    "aria": "./bin/aria.js"
+  },
+  "main": "./dist/aria-connector/src/index.js",
+  "types": "./dist/aria-connector/src/index.d.ts",
+  "type": "module",
+  "publishConfig": {
+    "registry": "https://npm.pkg.github.com",
+    "access": "restricted"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/REI-Nationwide/cowork-sandbox.git"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepare": "npm run build",
+    "dev": "tsc --watch",
+    "publish:all": "bash scripts/publish-all.sh",
+    "publish:npm": "npm publish --registry https://registry.npmjs.org --access public",
+    "publish:github": "npm publish --registry https://npm.pkg.github.com",
+    "publish:docker": "bash scripts/publish-docker.sh",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "chokidar": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "files": [
+    "bin",
+    "dist",
+    "src",
+    "hooks"
+  ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "license": "UNLICENSED",
+  "private": false
+}

package/src/__tests__/auth-commands.test.ts

@@ -0,0 +1,132 @@
+import { login, status, logout, revoke } from '../auth-commands';
+import { loadLicense, saveLicense } from '../auth';
+import { harnessClient } from '../harness-client';
+import * as fs from 'fs';
+import * as path from 'path';
+
+jest.mock('../auth');
+jest.mock('../harness-client');
+
+const LICENSE_PATH = path.join(require('os').homedir(), '.aria', 'license.json');
+
+const mockClaims = {
+  jti: 'test-jti-123',
+  sub: 'user-test',
+  tier: 'pro',
+  exp: Math.floor(Date.now() / 1000) + 86400,
+  iat: Math.floor(Date.now() / 1000),
+};
+
+beforeEach(() => {
+  jest.clearAllMocks();
+  // Clean up any leftover license file
+  try { fs.unlinkSync(LICENSE_PATH); } catch {}
+});
+
+describe('login', () => {
+  it('should validate token and persist license', async () => {
+    (harnessClient.get as jest.Mock).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ claims: mockClaims }),
+    });
+
+    const result = await login('valid-token');
+
+    expect(result.ok).toBe(true);
+    expect(result.tier).toBe('pro');
+    expect(result.jti).toBe('test-jti-123');
+    expect(result.expiresAt).toBeDefined();
+
+    // Verify file was written with mode 0600
+    const written = JSON.parse(fs.readFileSync(LICENSE_PATH, 'utf-8'));
+    expect(written.jti).toBe('test-jti-123');
+  });
+
+  it('should return error on invalid token', async () => {
+    (harnessClient.get as jest.Mock).mockResolvedValue({
+      ok: false,
+      json: () => Promise.resolve({ error: 'Invalid token' }),
+    });
+
+    const result = await login('bad-token');
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe('Invalid token');
+  });
+});
+
+describe('status', () => {
+  it('should return logged out when no local license', async () => {
+    (loadLicense as jest.Mock).mockReturnValue(null);
+
+    const result = await status();
+    expect(result.loggedIn).toBe(false);
+  });
+
+  it('should return status from server when licensed', async () => {
+    (loadLicense as jest.Mock).mockReturnValue(mockClaims);
+    (harnessClient.get as jest.Mock).mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: () => Promise.resolve({ claims: mockClaims }),
+    });
+
+    const result = await status();
+    expect(result.loggedIn).toBe(true);
+    expect(result.tier).toBe('pro');
+    expect(result.revoked).toBe(false);
+  });
+
+  it('should detect revoked license from 410', async () => {
+    (loadLicense as jest.Mock).mockReturnValue(mockClaims);
+    (harnessClient.get as jest.Mock).mockResolvedValue({
+      ok: false,
+      status: 410,
+    });
+
+    const result = await status();
+    expect(result.loggedIn).toBe(true);
+    expect(result.revoked).toBe(true);
+  });
+});
+
+describe('logout', () => {
+  it('should delete license file', async () => {
+    // Create a fake license file
+    fs.writeFileSync(LICENSE_PATH, JSON.stringify(mockClaims), { mode: 0o600 });
+    expect(fs.existsSync(LICENSE_PATH)).toBe(true);
+
+    const result = await logout();
+    expect(result.ok).toBe(true);
+    expect(fs.existsSync(LICENSE_PATH)).toBe(false);
+  });
+
+  it('should succeed even without license file', async () => {
+    const result = await logout();
+    expect(result.ok).toBe(true);
+  });
+});
+
+describe('revoke', () => {
+  it('should revoke license server-side and clear local', async () => {
+    (loadLicense as jest.Mock).mockReturnValue(mockClaims);
+    (harnessClient.post as jest.Mock).mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({}),
+    });
+
+    const result = await revoke('Test revocation');
+    expect(result.ok).toBe(true);
+    expect(result.jti).toBe('test-jti-123');
+    expect(harnessClient.post).toHaveBeenCalledWith('/api/license/revoke', {
+      body: { jti: 'test-jti-123', reason: 'Test revocation', revokedBy: 'self' },
+    });
+  });
+
+  it('should fail without active license', async () => {
+    (loadLicense as jest.Mock).mockReturnValue(null);
+
+    const result = await revoke();
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe('No active license to revoke');
+  });
+});