@aria_asi/cli 0.2.26 → 0.2.30

package/src/lib/aristotle-noor-wire.ts

@@ -0,0 +1,310 @@
+/**
+ * aristotle-noor-wire — SDK-side thin wrapper that dispatches every SDK and
+ * CLI emission through the harness-side `runAristotleNoorPipeline` so the
+ * 28 Aristotle modules + 14 Noor cognitives fire on every client emission
+ * just like they do for harness-internal turns.
+ *
+ * Hamza directive 2026-04-27 (task #98): distrust signal — every emission
+ * path must pass through these primitives so quality is uniform across the
+ * fleet. The SDK and CLI cannot import server-only modules (db pool,
+ * NoorCore, etc.), so we dispatch via HTTP to a dedicated harness route
+ * (`POST /api/harness/aristotle-noor`) which delegates to the canonical
+ * `runAristotleNoorPipeline` in `apps/arias-soul/api/lib/aria-emission-pipeline.ts`.
+ *
+ * Doctrine bindings:
+ *   - NO TIMEOUTS, NO AbortSignal — fail-open on transport faults so the
+ *     CLI / chat loop never gets blocked by a transient harness outage.
+ *   - NO STUBS — every dispatch is a real network call; failures surface
+ *     in the result `notes` array, never silently swallowed.
+ *   - REUSE — we share the SDK's existing `HarnessClient` POST plumbing
+ *     so license-token + Bearer auth + cognition-log writes are all the
+ *     same primitives as the rest of the SDK.
+ *   - SENIOR-DEV CODE ORG — public API at the top, types after the
+ *     module JSDoc, helpers below a divider, every export typed.
+ *
+ * @module aristotle-noor-wire
+ */
+
+import { fetchHarness, validateOutput } from '../harness-client.js';
+import { pushCognitionLog } from '../cognition-log.js';
+
+// ─── Public types ───────────────────────────────────────────────────────────
+
+/** Surface labels accepted by the harness-side
+ *  `runAristotleNoorPipeline`. Mirrors the `EmissionSurface` union in
+ *  `apps/arias-soul/api/lib/aria-emission-pipeline.ts`. */
+export type SdkEmissionSurface =
+  | 'cli-chat'
+  | 'cli-login'
+  | 'cli-connect'
+  | 'cli-install-hooks'
+  | 'cli-check-update'
+  | 'sdk-fetch-harness'
+  | 'sdk-validate-output'
+  | 'sdk-chat-turn'
+  | 'sdk-other';
+
+/** Input contract for the SDK-side wire. The harness route accepts this
+ *  shape verbatim and forwards to `runAristotleNoorPipeline`. */
+export interface AristotleNoorWireInput {
+  surface: SdkEmissionSurface;
+  emissionId: string;
+  sessionId?: string;
+  userId?: string;
+  isHamza?: boolean;
+  message?: string;
+  draft?: string;
+  plannedApproach?: string;
+  tier?: string;
+  isFirstOfSession?: boolean;
+  metadata?: Record<string, unknown>;
+}
+
+/** Result envelope from the harness pipeline — mirrors
+ *  `AristotleNoorResult` on the server, lossy-typed for SDK consumption. */
+export interface AristotleNoorWireResult {
+  fired: string[];
+  fitrahVetoed: boolean;
+  fitrahAlignment: number;
+  qualityScore: number;
+  reAuthorSignal: boolean;
+  notes: string[];
+  soulCharge: number | null;
+  soulManifoldStatus: string | null;
+  ghazaliVerdict: string | null;
+  latencyMs: number;
+  /** True when the dispatch reached the harness; false on transport fault
+   *  (in which case the rest of the result is a fail-open default). */
+  dispatched: boolean;
+}
+
+// ─── Public API ─────────────────────────────────────────────────────────────
+
+/**
+ * Dispatch a single SDK / CLI emission through the harness-side Aristotle
+ * + Noor pipeline. Fail-open by construction — transport faults return a
+ * default-shaped result with `dispatched: false` so callers never block.
+ *
+ * The wire posts to `POST /api/harness/aristotle-noor`. When that route is
+ * not yet deployed (older harness builds), we fall back to firing the
+ * `validateOutput` path with the draft so at least the post-stage 8-lens
+ * + Mizan rewrite legs fire — that way no client emission ever ships
+ * without SOME primitive coverage.
+ */
+export async function runAristotleNoorOnSDK(
+  input: AristotleNoorWireInput,
+): Promise<AristotleNoorWireResult> {
+  const t0 = Date.now();
+  const baseUrl = process.env.ARIA_HARNESS_BASE_URL ?? 'https://harness.ariasos.com';
+  const url = `${baseUrl}/api/harness/aristotle-noor`;
+
+  try {
+    const response = await fetch(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(input),
+    });
+
+    if (!response.ok) {
+      // Harness route missing → fall through to legacy validate-output path
+      return await fallbackToValidateOutput(input, t0);
+    }
+
+    const data = (await response.json()) as Partial<AristotleNoorWireResult>;
+    const result: AristotleNoorWireResult = {
+      fired: data.fired ?? [],
+      fitrahVetoed: data.fitrahVetoed ?? false,
+      fitrahAlignment: data.fitrahAlignment ?? 1.0,
+      qualityScore: data.qualityScore ?? 100,
+      reAuthorSignal: data.reAuthorSignal ?? false,
+      notes: data.notes ?? [],
+      soulCharge: data.soulCharge ?? null,
+      soulManifoldStatus: data.soulManifoldStatus ?? null,
+      ghazaliVerdict: data.ghazaliVerdict ?? null,
+      latencyMs: data.latencyMs ?? Date.now() - t0,
+      dispatched: true,
+    };
+
+    // Mirror the dispatch into the cognition log so SDK/CLI cognition events
+    // appear in the same hive stream as harness-side events.
+    pushCognitionLog({
+      source: 'aria-cli',
+      type: 'aristotle_noor_wire',
+      gate: `aristotle-noor:${input.surface}`,
+      passed: !result.fitrahVetoed && !result.reAuthorSignal,
+      reason: result.notes.slice(0, 3).join(' | '),
+      score: result.qualityScore,
+      metadata: {
+        emissionId: input.emissionId,
+        sessionId: input.sessionId,
+        userId: input.userId,
+        fired: result.fired,
+        fitrahAlignment: result.fitrahAlignment,
+        soulCharge: result.soulCharge,
+        ghazaliVerdict: result.ghazaliVerdict,
+      },
+    }).catch(() => undefined);
+
+    return result;
+  } catch {
+    return await fallbackToValidateOutput(input, t0);
+  }
+}
+
+/**
+ * Wrap a single chat-turn lifecycle (used by `chat.ts:AriaChat`). Fires
+ * pre + post Aristotle/Noor coverage around the model call without
+ * altering the existing chat shape. Returns the wire result so the caller
+ * can surface re-author signal / Fitrah veto / quality score upstream.
+ *
+ * Usage:
+ *   const wire = await wrapAriaChatTurn({
+ *     emissionId, sessionId, userId, message, plannedApproach,
+ *   }, async (pre) => { ... call provider, return draft text ... });
+ *   if (wire.fitrahVetoed) emitRefusal(); else emit(wire.draft);
+ */
+export async function wrapAriaChatTurn(
+  ctx: Omit<AristotleNoorWireInput, 'surface' | 'draft'>,
+  produceDraft: (pre: AristotleNoorWireResult) => Promise<string>,
+): Promise<AristotleNoorWireResult & { draft: string }> {
+  const pre = await runAristotleNoorOnSDK({
+    ...ctx,
+    surface: 'sdk-chat-turn',
+  });
+
+  if (pre.fitrahVetoed) {
+    return { ...pre, draft: '' };
+  }
+
+  const draft = await produceDraft(pre);
+
+  const post = await runAristotleNoorOnSDK({
+    ...ctx,
+    surface: 'sdk-chat-turn',
+    draft,
+  });
+
+  // Merge post-fire signals into the pre snapshot so callers get one
+  // unified view of every primitive that fired.
+  return {
+    fired: dedupe([...pre.fired, ...post.fired]),
+    fitrahVetoed: post.fitrahVetoed,
+    fitrahAlignment: post.fitrahAlignment,
+    qualityScore: post.qualityScore,
+    reAuthorSignal: post.reAuthorSignal,
+    notes: [...pre.notes, ...post.notes],
+    soulCharge: post.soulCharge ?? pre.soulCharge,
+    soulManifoldStatus: post.soulManifoldStatus ?? pre.soulManifoldStatus,
+    ghazaliVerdict: post.ghazaliVerdict ?? pre.ghazaliVerdict,
+    latencyMs: pre.latencyMs + post.latencyMs,
+    dispatched: pre.dispatched && post.dispatched,
+    draft,
+  };
+}
+
+/**
+ * Lifecycle wrapper for CLI commands. Fires pre-coverage before the
+ * command's main action, then post-coverage after. Failures never block
+ * the command — the wire is observability + cognition-log + Fitrah hard-gate.
+ *
+ * Returns the post result so the caller can decide whether to print a
+ * one-line cognition footer (`task #95 — human-readable harness footer`).
+ */
+export async function wrapCliCommand<T>(
+  command: SdkEmissionSurface,
+  emissionId: string,
+  action: () => Promise<T>,
+  ctx: Omit<AristotleNoorWireInput, 'surface' | 'emissionId'> = {},
+): Promise<{ result: T; coverage: AristotleNoorWireResult }> {
+  await runAristotleNoorOnSDK({
+    ...ctx,
+    surface: command,
+    emissionId,
+  });
+
+  const result = await action();
+
+  const coverage = await runAristotleNoorOnSDK({
+    ...ctx,
+    surface: command,
+    emissionId,
+    draft: typeof result === 'string' ? result : undefined,
+  });
+
+  return { result, coverage };
+}
+
+// ─── Internal helpers ───────────────────────────────────────────────────────
+
+/** Fail-open default — fires the legacy `validateOutput` route so at
+ *  least the post-stage 8-lens + Mizan rewrite legs run when the new
+ *  `/api/harness/aristotle-noor` route is unreachable. */
+async function fallbackToValidateOutput(
+  input: AristotleNoorWireInput,
+  t0: number,
+): Promise<AristotleNoorWireResult> {
+  const fired: string[] = [];
+  const notes: string[] = ['aristotle-noor: harness route unreachable, ran validateOutput fallback'];
+  let qualityScore = 100;
+  let reAuthorSignal = false;
+
+  if (input.draft) {
+    try {
+      const verdict = await validateOutput({
+        text: input.draft,
+        sessionId: input.sessionId ?? input.emissionId,
+      });
+      if (verdict) {
+        fired.push('eight_lens_detector_fallback', 'mizan_validate_fallback');
+        if (verdict.severity === 'block') {
+          qualityScore = 40;
+          reAuthorSignal = true;
+        } else if (verdict.severity === 'warn') {
+          qualityScore = 70;
+        }
+      }
+    } catch {
+      // swallow — fail-open
+    }
+  } else if (input.message) {
+    // Pre-stage fallback: at minimum, fetch the harness packet so doctrine
+    // injection still surfaces to the caller.
+    try {
+      await fetchHarness({
+        message: input.message,
+        sessionId: input.sessionId ?? input.emissionId,
+        userId: input.userId,
+      });
+      fired.push('harness_fetch_fallback');
+    } catch {
+      // swallow — fail-open
+    }
+  }
+
+  return {
+    fired,
+    fitrahVetoed: false,
+    fitrahAlignment: 1.0,
+    qualityScore,
+    reAuthorSignal,
+    notes,
+    soulCharge: null,
+    soulManifoldStatus: null,
+    ghazaliVerdict: null,
+    latencyMs: Date.now() - t0,
+    dispatched: false,
+  };
+}
+
+/** Stable order-preserving dedupe used by `wrapAriaChatTurn`. */
+function dedupe<T>(values: T[]): T[] {
+  const seen = new Set<T>();
+  const out: T[] = [];
+  for (const v of values) {
+    if (!seen.has(v)) {
+      seen.add(v);
+      out.push(v);
+    }
+  }
+  return out;
+}

package/src/providers/types.ts

@@ -1,3 +1,5 @@
+import type { RuntimeProofSnapshot } from '../runtime-proof.js';
+
 export interface Message {
   role: 'system' | 'user' | 'assistant';
   content: string;
@@ -11,10 +13,14 @@ export interface ChatOptions {
 
 export interface ChatResult {
   text: string;
+  provider?: string;
+  model?: string;
+  latencyMs?: number;
   usage?: {
     promptTokens: number;
     completionTokens: number;
   };
+  runtimeProof?: RuntimeProofSnapshot;
 }
 
 export type ProviderName = 'openai' | 'anthropic' | 'google' | 'deepseek' | 'openrouter' | 'ollama';