@aria_asi/cli 0.2.32 → 0.2.34

package/dist/runtime/hooks/test-tier-lens-labeling.mjs

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+// Smoke test: Phase 11 #59 — canonical lens labeling
+//
+// Verifies that aria-pre-tool-gate.mjs and aria-stop-gate.mjs:
+//   1. Show canonical Arabic lens names (nur, mizan, etc.) when the harness
+//      packet has isHamza/hamza=true (OWNER tier).
+//   2. Preserve those same canonical labels on client-surface execution too.
+//   3. Gate enforcement (block on insufficient cognition) fires in both
+//      tiers without renaming the lenses.
+//
+// Usage: node hooks/test-tier-lens-labeling.mjs
+// Exit:  0 = all assertions passed, 1 = failure
+
+import { spawnSync } from 'node:child_process';
+import { writeFileSync, mkdirSync, existsSync, unlinkSync, readFileSync } from 'node:fs';
+import * as path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const PRE_TOOL_HOOK = path.join(HERE, 'aria-pre-tool-gate.mjs');
+const STOP_HOOK = path.join(HERE, 'aria-stop-gate.mjs');
+const HOME = process.env.HOME || '/tmp';
+const CLAUDE_DIR = `${HOME}/.claude`;
+const PACKET_PATH = `${CLAUDE_DIR}/.aria-harness-last-packet.json`;
+
+// ── Canonical label set ────────────────────────────────────────────────────
+const CANONICAL = ['nur', 'mizan', 'hikma', 'tafakkur', 'tadabbur', 'ilham', 'wahi', 'firasah'];
+
+// ── Assertion helpers ───────────────────────────────────────────────────────
+let passed = 0;
+let failed = 0;
+
+function assert(label, condition, detail) {
+  if (condition) {
+    console.log(`  PASS  ${label}`);
+    passed++;
+  } else {
+    console.error(`  FAIL  ${label}`);
+    if (detail !== undefined) console.error(`        detail: ${String(detail).slice(0, 300)}`);
+    failed++;
+  }
+}
+
+// ── Packet helpers ──────────────────────────────────────────────────────────
+// Save/restore the real packet so running this test doesn't corrupt live state.
+let originalPacketContent = null;
+
+function savePacket() {
+  try {
+    if (existsSync(PACKET_PATH)) {
+      originalPacketContent = readFileSync(PACKET_PATH, 'utf8');
+    } else {
+      originalPacketContent = null;
+    }
+  } catch { originalPacketContent = null; }
+}
+
+function restorePacket() {
+  try {
+    if (originalPacketContent !== null) {
+      writeFileSync(PACKET_PATH, originalPacketContent);
+    } else if (existsSync(PACKET_PATH)) {
+      unlinkSync(PACKET_PATH);
+    }
+  } catch {}
+}
+
+function writeOwnerPacket() {
+  // contractGate.signals.hamza === true → OWNER tier
+  const packet = {
+    ok: true,
+    stage: 'preflight',
+    harness: 'surface=platform:hamza group:false hamza:true',
+    contractGate: {
+      signals: { hamza: true },
+    },
+  };
+  if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
+  writeFileSync(PACKET_PATH, JSON.stringify(packet));
+}
+
+function writeClientPacket() {
+  // contractGate.signals.hamza === "false" (string) → CLIENT tier
+  const packet = {
+    ok: true,
+    stage: 'preflight',
+    harness: 'surface=platform:client group:false hamza:false',
+    contractGate: {
+      signals: { hamza: 'false' },
+    },
+  };
+  if (!existsSync(CLAUDE_DIR)) mkdirSync(CLAUDE_DIR, { recursive: true });
+  writeFileSync(PACKET_PATH, JSON.stringify(packet));
+}
+
+// ── Transcript helpers ──────────────────────────────────────────────────────
+// Write a minimal transcript where the most recent assistant turn has NO
+// cognition block — triggering a block decision.
+function writeEmptyTranscript(transcriptPath) {
+  const entries = [
+    // User message
+    JSON.stringify({
+      message: { role: 'user', content: [{ type: 'text', text: 'Run a build command' }] },
+    }),
+    // Assistant text with no cognition
+    JSON.stringify({
+      message: {
+        role: 'assistant',
+        content: [{ type: 'text', text: 'I will run the build.' }],
+      },
+    }),
+  ];
+  writeFileSync(transcriptPath, entries.join('\n'));
+}
+
+// Write a transcript with a Stop-gate-triggering assistant response (long,
+// decision-signal, but no cognition).
+function writeNoCognitionStopTranscript(transcriptPath) {
+  const longText = 'I recommend shipping this feature immediately because the test suite is green and the build passed. Let me proceed with the deployment now. ' +
+    'The plan is as follows: first we build, then we deploy, then we verify. I would suggest we move forward without delay.';
+  const entries = [
+    JSON.stringify({
+      message: { role: 'user', content: [{ type: 'text', text: 'Should I ship?' }] },
+    }),
+    JSON.stringify({
+      message: {
+        role: 'assistant',
+        content: [{ type: 'text', text: longText }],
+      },
+    }),
+  ];
+  writeFileSync(transcriptPath, entries.join('\n'));
+}
+
+// ── Run hook helpers ────────────────────────────────────────────────────────
+// Use a non-destructive but non-trivial command that skips the verify path
+// and goes straight to cognition-missing, where lens labels appear.
+function runPreToolGate(transcriptPath, command = 'npm run build --workspace=packages/aria-connector') {
+  const event = JSON.stringify({
+    tool_name: 'Bash',
+    tool_input: { command },
+    transcript_path: transcriptPath,
+    session_id: `test-tier-${Date.now()}`,
+  });
+  return spawnSync(process.execPath, [PRE_TOOL_HOOK], {
+    input: event,
+    encoding: 'utf8',
+    timeout: 10000,
+    env: {
+      ...process.env,
+      HOME,
+      ARIA_COGNITION_PUSH: 'off',   // silence network push
+      ARIA_HARNESS_TOKEN: '',        // no outbound harness calls
+      ARIA_BINDING_ENABLED: 'false', // disable binding gate — isolate cognition test
+    },
+  });
+}
+
+function runStopGate(transcriptPath) {
+  const event = JSON.stringify({
+    tool_name: 'Stop',
+    transcript_path: transcriptPath,
+    session_id: `test-tier-${Date.now()}`,
+  });
+  return spawnSync(process.execPath, [STOP_HOOK], {
+    input: event,
+    encoding: 'utf8',
+    timeout: 15000,
+    env: {
+      ...process.env,
+      HOME,
+      ARIA_COGNITION_PUSH: 'off',
+      ARIA_HARNESS_TOKEN: '',
+    },
+  });
+}
+
+// ── Test utilities ──────────────────────────────────────────────────────────
+const tmpTranscript = `/tmp/test-tier-transcript-${Date.now()}.jsonl`;
+const tmpTranscriptStop = `/tmp/test-tier-stop-transcript-${Date.now()}.jsonl`;
+
+function cleanup() {
+  [tmpTranscript, tmpTranscriptStop].forEach((p) => {
+    try { if (existsSync(p)) unlinkSync(p); } catch {}
+  });
+  restorePacket();
+}
+
+// ── Suite ───────────────────────────────────────────────────────────────────
+
+console.log('\n=== Phase 11 #59 — Tier-aware lens labeling smoke tests ===\n');
+
+// Save existing packet so we can restore after test run.
+savePacket();
+
+// ── Test 1: pre-tool-gate, OWNER tier → canonical labels in block reason ──
+console.log('Test 1: aria-pre-tool-gate — OWNER tier shows canonical lens names');
+{
+  writeOwnerPacket();
+  writeEmptyTranscript(tmpTranscript);
+  const result = runPreToolGate(tmpTranscript);
+
+  // Gate should block (exit 2) — no cognition in transcript
+  assert(
+    'T1: gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  // Must mention at least one canonical label
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T1: block reason mentions canonical label (e.g. nur:)',
+    hasCanonical,
+    blockReason.slice(0, 400),
+  );
+
+  // The first visible lens label must be canonical.
+  const firstCanonicalIdx = blockReason.indexOf(`${CANONICAL[0]}:`);
+  assert(
+    'T1: first lens label is canonical (nur:)',
+    firstCanonicalIdx >= 0,
+    `firstCanonicalIdx=${firstCanonicalIdx}`,
+  );
+}
+
+// ── Test 2: pre-tool-gate, CLIENT tier → canonical labels in block reason ──
+console.log('\nTest 2: aria-pre-tool-gate — CLIENT tier keeps canonical lens labels');
+{
+  writeClientPacket();
+  writeEmptyTranscript(tmpTranscript);
+  const result = runPreToolGate(tmpTranscript);
+
+  assert(
+    'T2: gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T2: block reason mentions canonical label (e.g. nur:)',
+    hasCanonical,
+    blockReason.slice(0, 400),
+  );
+  assert(
+    'T2: first visible lens label is canonical (nur:)',
+    blockReason.includes(`${CANONICAL[0]}:`),
+    blockReason.slice(0, 400),
+  );
+}
+
+// ── Test 3: stop-gate, OWNER tier → canonical labels ──
+console.log('\nTest 3: aria-stop-gate — OWNER tier shows canonical lens names');
+{
+  writeOwnerPacket();
+  writeNoCognitionStopTranscript(tmpTranscriptStop);
+  const result = runStopGate(tmpTranscriptStop);
+
+  assert(
+    'T3: stop-gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T3: stop-gate block reason mentions canonical label',
+    hasCanonical,
+    blockReason.slice(0, 400),
+  );
+}
+
+// ── Test 4: stop-gate, CLIENT tier → canonical labels ──────────────────────
+console.log('\nTest 4: aria-stop-gate — CLIENT tier keeps canonical lens labels');
+{
+  writeClientPacket();
+  writeNoCognitionStopTranscript(tmpTranscriptStop);
+  const result = runStopGate(tmpTranscriptStop);
+
+  assert(
+    'T4: stop-gate blocks (exit 2)',
+    result.status === 2,
+    `exit=${result.status} stderr=${result.stderr?.slice(0, 200)}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T4: stop-gate block reason mentions canonical label',
+    hasCanonical,
+    blockReason.slice(0, 400),
+  );
+}
+
+// ── Test 5: packet missing → defaults to canonical labels (fail-safe) ─────
+console.log('\nTest 5: missing packet cache → defaults to canonical labels');
+{
+  // Remove the packet cache
+  try { unlinkSync(PACKET_PATH); } catch {}
+  writeEmptyTranscript(tmpTranscript);
+  const result = runPreToolGate(tmpTranscript);
+
+  assert(
+    'T5: gate blocks (exit 2) with no packet',
+    result.status === 2,
+    `exit=${result.status}`,
+  );
+
+  let blockReason = '';
+  try {
+    const parsed = JSON.parse(result.stdout);
+    blockReason = parsed.reason || '';
+  } catch {
+    blockReason = result.stdout || '';
+  }
+
+  const hasCanonical = CANONICAL.some((name) => blockReason.includes(`${name}:`));
+  assert(
+    'T5: defaults to canonical labels when packet is absent',
+    hasCanonical,
+    `canonical=${hasCanonical} reason=${blockReason.slice(0, 300)}`,
+  );
+}
+
+// ── Summary ─────────────────────────────────────────────────────────────────
+cleanup();
+console.log(`\n${'─'.repeat(60)}`);
+console.log(`Results: ${passed} passed, ${failed} failed`);
+if (failed > 0) {
+  console.error('\nSome tests FAILED — see FAIL lines above.');
+  process.exit(1);
+} else {
+  console.log('\nAll tests PASSED.');
+  process.exit(0);
+}

package/dist/runtime/manifest.json

@@ -1,6 +1,6 @@
 {
-  "bundledAt": "2026-05-01T20:07:31.761Z",
-  "sdkFiles": 6,
+  "bundledAt": "2026-05-03T03:42:17.303Z",
+  "sdkFiles": 9,
   "runtimeTemplate": "/home/hamzaibrahim1/rei-ai-brain/packages/aria-connector/runtime-src",
   "gateRuntimeSource": "/home/hamzaibrahim1/rei-ai-brain/packages/aria-gate-runtime/dist",
   "sdkGuideSource": "/home/hamzaibrahim1/rei-ai-brain/harness/packages/harness-http-client/CLAUDE.md",

package/dist/runtime/sdk/BUNDLED.json

@@ -1,5 +1,5 @@
 {
-  "bundledAt": "2026-05-01T20:07:31.757Z",
+  "bundledAt": "2026-05-03T03:42:17.293Z",
   "sdkSource": "/home/hamzaibrahim1/rei-ai-brain/harness/packages/harness-http-client/dist",
-  "files": 6
+  "files": 9
 }

package/dist/runtime/sdk/index.d.ts

@@ -2,6 +2,7 @@ export interface HarnessClientConfig {
     baseUrl: string;
     apiKey: string;
     harnessPacketUrl?: string;
+    gardenBaseUrl?: string;
     workspaceRoot?: string;
 }
 export interface OwnerTier {
@@ -103,12 +104,21 @@ export interface HarnessBindingContext {
     includeAegisLearnings?: boolean;
     extraBody?: Record<string, unknown>;
 }
+export interface HarnessEvidenceRef {
+    evidenceId: string;
+    kind: string;
+    at: string;
+    sha256: string;
+    preview: string;
+    metadata?: Record<string, unknown>;
+}
 export interface BoundHarnessPromptResult {
     prompt: string;
     packet: HarnessPacket;
     harnessText: string;
     bindingBody: Record<string, unknown>;
 }
+export declare function createHarnessEvidenceRef(kind: string, value: unknown, metadata?: Record<string, unknown>): HarnessEvidenceRef;
 export interface RecordDiscoveryArgs {
     /** Finding text (min 4 chars). */
     text: string;
@@ -161,6 +171,36 @@ export interface ActionCheck {
     reason?: string;
     requiredGates: string[];
 }
+export interface GardenContinuitySnapshot {
+    hydrated: boolean;
+    sessionId: string;
+    userId?: string;
+    query: string;
+    contextBlock: string;
+    memoryCount: number;
+    threadCount: number;
+    pulseCount: number;
+    snapshotMs: number;
+    postgresBound?: boolean;
+    qdrantBound?: boolean;
+    pulseLoopAlive?: boolean;
+}
+export interface GovernanceOutcomeInput {
+    sessionId: string;
+    userId?: string;
+    sourceRuntime: string;
+    action?: string;
+    outcome: string;
+    evidence?: unknown;
+    obligationId?: string;
+}
+export interface GovernanceOutcomeResult {
+    ok: boolean;
+    pulseId?: string;
+    ledgerId?: string;
+    threadId?: string;
+    message?: string;
+}
 /**
  * Result shape for all three Aristotle phases.
  * Mirrors `AristotleNoorWireResult` in aria-connector's aristotle-noor-wire.ts.
@@ -261,6 +301,7 @@ export declare class HTTPHarnessClient {
     private readonly baseUrl;
     private readonly apiKey;
     private readonly harnessPacketUrl;
+    private readonly gardenBaseUrl?;
     private readonly workspaceRoot;
     private cachedPacket;
     private packetLastFetched;
@@ -303,6 +344,12 @@ export declare class HTTPHarnessClient {
     validateOutput(text: string, sessionId: string): Promise<ValidationResult>;
     checkAction(action: 'deploy' | 'build' | 'write' | 'delete', target: string): Promise<ActionCheck>;
     gardenTurn(sessionId: string, message: string, response: string, userId?: string): Promise<void>;
+    hydrateGardenContinuity(sessionId: string, query: string, limits?: {
+        threadLimit?: number;
+        pulseLimit?: number;
+        userId?: string;
+    }): Promise<GardenContinuitySnapshot>;
+    persistGovernanceOutcome(input: GovernanceOutcomeInput): Promise<GovernanceOutcomeResult>;
     consult(args: {
         brief: string;
         sessionId: string;
@@ -487,3 +534,4 @@ export declare const harness: {
 export declare function bindingContext(role: string, sessionId: string, stage: string, intendedAction: string, rationale: string): HarnessBindingContext;
 export declare function getBoundHarnessAndPrompt(context: HarnessBindingContext, plan?: Partial<HarnessPlan>, client?: HTTPHarnessClient): Promise<BoundHarnessPromptResult>;
 export * from './runWithCognition.js';
+export * from './runWithGovernance.js';

package/dist/runtime/sdk/index.js

@@ -2,7 +2,7 @@ import { readFile } from 'node:fs/promises';
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir as _homedir } from 'node:os';
 import { resolve, isAbsolute } from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
 const CLOUD_RUN_SOUL_URL = 'https://arias-soul-6zp3gtk2ca-uc.a.run.app';
 const PUBLIC_HARNESS_URL = 'https://harness.ariasos.com';
 const LOCAL_HARNESS_CANDIDATES = [
@@ -29,6 +29,28 @@ function normalizeHarnessPacketPayload(payload) {
         ? current
         : {};
 }
+function stableEvidenceString(value) {
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function createHarnessEvidenceRef(kind, value, metadata) {
+    const raw = stableEvidenceString(value);
+    const sha256 = createHash('sha256').update(raw).digest('hex');
+    return {
+        evidenceId: `ev_${sha256.slice(0, 16)}`,
+        kind,
+        at: new Date().toISOString(),
+        sha256,
+        preview: raw.slice(0, 500),
+        ...(metadata && Object.keys(metadata).length > 0 ? { metadata } : {}),
+    };
+}
 // ── 8-Lens Cognition Block ─────────────────────────────────────────────────
 const EIGHT_LENS_BLOCK = `[ARIA SHELL PROTOCOL — You are a controlled surface]
 
@@ -65,6 +87,7 @@ export class HTTPHarnessClient {
     baseUrl;
     apiKey;
     harnessPacketUrl;
+    gardenBaseUrl;
     workspaceRoot;
     cachedPacket = null;
     packetLastFetched = 0;
@@ -77,6 +100,7 @@ export class HTTPHarnessClient {
         this.harnessPacketUrl = config.harnessPacketUrl ?? (isMountedRuntimeBaseUrl(this.baseUrl)
             ? `${this.baseUrl}/packet`
             : `${this.baseUrl}/api/harness/codex`);
+        this.gardenBaseUrl = (config.gardenBaseUrl || process.env.ARIA_GARDEN_BASE_URL || '').replace(/\/+$/, '') || undefined;
         this.workspaceRoot = config.workspaceRoot ?? process.cwd();
         this.preferredBaseUrl = this.baseUrl;
         this.baseUrlCandidates = this.buildBaseUrlCandidates(config.baseUrl);
@@ -643,6 +667,120 @@ export class HTTPHarnessClient {
             throw new Error(`garden/fire failed: ${res.status} ${res.statusText}`);
         }
     }
+    async hydrateGardenContinuity(sessionId, query, limits = {}) {
+        if (this.gardenBaseUrl) {
+            const params = new URLSearchParams({
+                session_id: sessionId,
+                user_id: limits.userId || '',
+                query,
+                thread_limit: String(limits.threadLimit ?? 5),
+                pulse_limit: String(limits.pulseLimit ?? 12),
+            });
+            const res = await this.fetchWithRetry(`${this.gardenBaseUrl}/continuity?${params}`, {
+                method: 'GET',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                const activeThreads = Array.isArray(data.activeThreads) ? data.activeThreads : [];
+                const recentPulses = Array.isArray(data.recentPulses) ? data.recentPulses : [];
+                const contextBlock = String(data.continuityBlock || data.continuity_block || data.gardenContextBlock || '');
+                return {
+                    hydrated: Boolean(data.ok) && (contextBlock.length > 0 || activeThreads.length > 0 || recentPulses.length > 0),
+                    sessionId: String(data.sessionId || data.session_id || sessionId),
+                    userId: String(data.userId || data.user_id || limits.userId || ''),
+                    query,
+                    contextBlock,
+                    memoryCount: recentPulses.length,
+                    threadCount: activeThreads.length,
+                    pulseCount: recentPulses.length,
+                    snapshotMs: Number(data.snapshotMs || data.snapshot_ms || Date.now()),
+                    postgresBound: Boolean(data.postgresBound ?? data.postgres_bound),
+                    qdrantBound: Boolean(data.qdrantBound ?? data.qdrant_bound),
+                    pulseLoopAlive: Boolean(data.pulseLoopAlive ?? data.pulse_loop_alive),
+                };
+            }
+            if (![404, 405, 501].includes(res.status)) {
+                throw new Error(`garden continuity failed: ${res.status} ${res.statusText}`);
+            }
+        }
+        const params = new URLSearchParams({
+            session_id: sessionId,
+            query,
+            thread_limit: String(limits.threadLimit ?? 5),
+            pulse_limit: String(limits.pulseLimit ?? 12),
+        });
+        const res = await this.fetchWithRetry(`${this.baseUrl}/api/garden/living?${params}`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`garden/living failed: ${res.status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        const activeThreads = Array.isArray(data.activeThreads) ? data.activeThreads : [];
+        const recentPulses = Array.isArray(data.recentPulses) ? data.recentPulses : Array.isArray(data.pulses) ? data.pulses : [];
+        const contextBlock = String(data.gardenContextBlock || data.garden_context_block || data.contextBlock || '');
+        return {
+            hydrated: contextBlock.length > 0 || activeThreads.length > 0 || recentPulses.length > 0,
+            sessionId,
+            userId: limits.userId,
+            query,
+            contextBlock,
+            memoryCount: recentPulses.length,
+            threadCount: activeThreads.length,
+            pulseCount: recentPulses.length,
+            snapshotMs: Number(data.snapshotMs || data.snapshot_ms || Date.now()),
+        };
+    }
+    async persistGovernanceOutcome(input) {
+        if (!input.sessionId || !input.sourceRuntime || !input.outcome) {
+            throw new Error('persistGovernanceOutcome requires sessionId, sourceRuntime, and outcome');
+        }
+        const body = {
+            session_id: input.sessionId,
+            user_id: input.userId,
+            source_runtime: input.sourceRuntime,
+            action: input.action || '',
+            outcome: input.outcome,
+            evidence: input.evidence ?? null,
+            obligation_id: input.obligationId || '',
+        };
+        const targets = this.gardenBaseUrl
+            ? [`${this.gardenBaseUrl}/governance-outcome`, `${this.baseUrl}/api/garden/governance-outcome`]
+            : [`${this.baseUrl}/api/garden/governance-outcome`];
+        let lastStatus = '';
+        for (const url of targets) {
+            const res = await this.fetchWithRetry(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(body),
+            });
+            if (res.ok) {
+                const data = (await res.json());
+                return {
+                    ok: Boolean(data.ok),
+                    pulseId: String(data.pulseId || data.pulse_id || ''),
+                    ledgerId: String(data.ledgerId || data.ledger_id || ''),
+                    threadId: String(data.threadId || data.thread_id || ''),
+                    message: typeof data.message === 'string' ? data.message : undefined,
+                };
+            }
+            lastStatus = `${res.status} ${res.statusText}`;
+            if (![404, 405, 501].includes(res.status))
+                break;
+        }
+        throw new Error(`persistGovernanceOutcome failed: ${lastStatus || 'no target available'}`);
+    }
     // ── Consult — delegate to Aria for direction or structured plan ─────────
     // Routes through /api/harness/delegate (the architect-mode endpoint that
     // serves preprompt-consult + Aria-as-commander binding plans). Caller
@@ -1572,4 +1710,5 @@ export async function getBoundHarnessAndPrompt(context, plan, client) {
     return sdk.getBoundHarnessAndPrompt(context, plan);
 }
 export * from './runWithCognition.js';
+export * from './runWithGovernance.js';
 //# sourceMappingURL=index.js.map