@aria_asi/cli 0.2.39 → 0.2.41

package/dist/runtime/sub-agent-enforcer.mjs

@@ -0,0 +1,201 @@
+#!/usr/bin/env node
+/**
+ * Sub-Agent Harness Enforcer
+ *
+ * When a sub-agent is spawned (task tool, Codex bridge, parallel worker),
+ * this module enforces the full harness stack on its context and output:
+ *
+ *   1. Pre-task: coach phase recorded, skills detected, axioms injected
+ *   2. Post-task: quality enforcement, doctrine trigger check, gate labels blocked
+ *   3. Coach ledger: sub-agent session tracked separately
+ *   4. Parent context: sub-agent output wrapped with enforcement provenance
+ *
+ * No sub-agent runs naked. Every one gets harness enforcement.
+ */
+
+import { createHash, randomUUID } from 'node:crypto';
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+// M0.F.X2 step 8 (2026-05-06): connector-side runtime-rails registry.
+// Same source pattern as apps-side sub-agent-enforcer.
+import {
+  INTERNAL_GATE_LABEL_PATTERN,
+  COLLAPSE_PLACEHOLDER_PATTERN,
+} from './runtime-rails/registry.mjs';
+
+const HOME = homedir();
+const STATE_DIR = join(HOME, '.aria', 'runtime', 'state');
+const SUBAGENT_LEDGER = join(STATE_DIR, 'subagent-enforcement.jsonl');
+
+function ensureDir() {
+  if (!existsSync(STATE_DIR)) mkdirSync(STATE_DIR, { recursive: true, mode: 0o700 });
+}
+
+function log(record) {
+  ensureDir();
+  try { appendFileSync(SUBAGENT_LEDGER, `${JSON.stringify(record)}\n`, { mode: 0o600 }); }
+  catch (err) {
+    process.stderr.write(`[connector:sub-agent-enforcer:ledger-write] caught: ${err instanceof Error ? err.message : String(err)}\n`);
+  }
+}
+
+// ── Quality patterns that sub-agents commonly violate ──────────────────────
+// M0.F.X2: GATE_LABEL_RX sourced from canonical registry. Combined check
+// in tripsSubAgentGate (matches internal-label OR collapse-placeholder).
+function tripsSubAgentGate(text) {
+  return INTERNAL_GATE_LABEL_PATTERN.test(text) || COLLAPSE_PLACEHOLDER_PATTERN.test(text);
+}
+const GATE_LABEL_RX = INTERNAL_GATE_LABEL_PATTERN; // legacy alias for downstream call sites
+
+const UNSAFE_COMPLETION_RX = /\b(?:done|complete|ready|fixed|shipped|all done|all phases complete)\b/i;
+
+const SUBAGENT_SAFE_FALLBACK =
+  '[Sub-agent enforcement applied — output was blocked or empty. Parent should re-query or re-spawn.]';
+
+// ── Coach Phase Record ─────────────────────────────────────────────────────
+
+const COACH_PHASES = ['pre_task', 'post_task', 'intra_task', 'claim_or_release'];
+
+export function recordSubAgentCoach(event) {
+  const record = {
+    coachEventId: randomUUID(),
+    sessionId: event.sessionId || 'subagent',
+    parentSessionId: event.parentSessionId || 'unknown',
+    phase: COACH_PHASES.includes(event.phase) ? event.phase : 'pre_task',
+    taskId: event.taskId || null,
+    subagentType: event.subagentType || 'unknown',
+    textPreview: String(event.text || '').slice(0, 500),
+    evidenceRefs: Array.isArray(event.evidenceRefs) ? event.evidenceRefs.slice(0, 10) : [],
+    decision: 'allow',
+    at: new Date().toISOString(),
+  };
+
+  // Check for common sub-agent failure patterns
+  const text = String(event.text || '');
+  if (GATE_LABEL_RX.test(text)) {
+    record.decision = 'repair_once';
+    record.reasons = ['gate_label_in_subagent_output'];
+  }
+  if (UNSAFE_COMPLETION_RX.test(text) && !/(?:exit\s*0|0\s+failures?|passed|verified)/i.test(text)) {
+    record.decision = 'repair_once';
+    record.reasons = [...(record.reasons || []), 'unsupported_completion_claim_in_subagent'];
+  }
+  if (!text || text.length < 20) {
+    record.decision = 'repair_once';
+    record.reasons = [...(record.reasons || []), 'subagent_output_too_short'];
+  }
+
+  log(record);
+  return record;
+}
+
+// ── Quality Enforcement on Sub-Agent Output ────────────────────────────────
+
+export function enforceSubAgentOutput(output, options = {}) {
+  const text = typeof output === 'string' ? output : (output?.text || output?.response || String(output || ''));
+  const subagentType = options.subagentType || 'unknown';
+  const sessionId = options.sessionId || 'subagent';
+
+  const violations = [];
+  if (!text || text.length < 10) violations.push('empty_output');
+  if (GATE_LABEL_RX.test(text)) violations.push('gate_label_leak');
+  if (UNSAFE_COMPLETION_RX.test(text) && !/(?:exit\s*0|0\s+failures?|passed|verified|test|ledger)/i.test(text)) {
+    violations.push('unsupported_completion_claim');
+  }
+
+  const enforced = violations.length > 0;
+  const finalText = enforced ? (options.safeFallback || SUBAGENT_SAFE_FALLBACK) : text;
+
+  if (enforced) {
+    log({
+      type: 'subagent_violation',
+      violationId: randomUUID(),
+      sessionId,
+      subagentType,
+      violations,
+      textPreview: text.slice(0, 200),
+      textHash: createHash('sha256').update(text).digest('hex').slice(0, 16),
+      enforced: true,
+      finalOutcome: 'safe_fallback',
+      at: new Date().toISOString(),
+    });
+  }
+
+  return {
+    finalText,
+    enforced,
+    violations,
+    originalLength: text.length,
+    finalLength: finalText.length,
+  };
+}
+
+// ── Pre-Task Injection: Build sub-agent system prompt with harness ─────────
+
+export function buildSubAgentHarnessPrompt(parentContext = {}) {
+  return [
+    '[SUB-AGENT HARNESS — This task is supervised by Aria Coach Kernel]',
+    '',
+    'Rules:',
+    '1. No internal gate labels may appear in your output (personal_mouth_*, code_no_tests, etc.)',
+    '2. No unsupported completion claims without measured evidence (exit codes, test results)',
+    '3. Your output will be quality-enforced before reaching the parent agent',
+    '4. The Coach kernel is monitoring this session',
+    '5. Truth over deception. No harm. Sacred trust. Power obligates service. Reflection before action.',
+    '',
+    parentContext.taskDescription
+      ? `Task: ${parentContext.taskDescription.slice(0, 300)}`
+      : '',
+    '[/SUB-AGENT HARNESS]',
+  ].filter(Boolean).join('\n');
+}
+
+// ── Sub-Agent Session Tracker ──────────────────────────────────────────────
+
+const activeSessions = new Map();
+
+export function trackSubAgentSession(taskId, metadata = {}) {
+  const session = {
+    taskId,
+    startedAt: new Date().toISOString(),
+    subagentType: metadata.subagentType || 'unknown',
+    parentSessionId: metadata.parentSessionId || 'unknown',
+    phase: 'pre_task',
+  };
+  activeSessions.set(taskId, session);
+  recordSubAgentCoach({
+    sessionId: taskId,
+    parentSessionId: metadata.parentSessionId,
+    subagentType: metadata.subagentType,
+    phase: 'pre_task',
+    taskId,
+    text: metadata.taskDescription || '',
+  });
+  return session;
+}
+
+export function completeSubAgentSession(taskId, output) {
+  const session = activeSessions.get(taskId);
+  if (!session) return null;
+  session.phase = 'post_task';
+  session.completedAt = new Date().toISOString();
+  const enforcement = enforceSubAgentOutput(output, {
+    subagentType: session.subagentType,
+    sessionId: taskId,
+  });
+  recordSubAgentCoach({
+    sessionId: taskId,
+    parentSessionId: session.parentSessionId,
+    subagentType: session.subagentType,
+    phase: 'post_task',
+    taskId,
+    text: enforcement.finalText,
+  });
+  activeSessions.delete(taskId);
+  return { ...session, enforcement };
+}
+
+export function getActiveSubAgentCount() {
+  return activeSessions.size;
+}

package/dist/runtime/task-project-ledger.mjs

@@ -64,6 +64,8 @@ function markGate(ledger, gateId, status, evidence = undefined) {
 
 function hasPromptIntent(event = {}) {
   return Boolean(firstString(
+    event.goal,
+    event.taskGoal,
     event.prompt,
     event.userPrompt,
     event.user_input,
@@ -80,7 +82,9 @@ function hasPromptIntent(event = {}) {
 function hasVerificationEvidence(evidence = {}, event = {}) {
   if (evidence.warning_clean === true || evidence.verification === true || evidence.validation_run === true) return true;
   if (event.verified === true || event.validation?.ok === true || event.test?.ok === true) return true;
-  const text = firstString(event.verification, event.validation, event.testResult, event.commandResult, evidence.commandResult, evidence.outputPreview);
+  if (evidence.qa?.ok === true || evidence.qaLearningLoop?.ok === true || event.qa?.ok === true || event.qaLearningLoop?.ok === true) return true;
+  if (['verified', 'verified_narrowly'].includes(String(evidence.endPhaseQaAutofire?.verdict || event.endPhaseQaAutofire?.verdict || ''))) return true;
+  const text = firstString(event.verification, event.validation, event.testResult, event.commandResult, event.evidence, evidence.commandResult, evidence.outputPreview, evidence.evidence);
   return /\b(?:ok|passed|pass|success|succeeded|exit\s*0|0\s*failures?)\b/i.test(text);
 }
 

package/dist/sdk/BUNDLED.json

@@ -1,5 +1,5 @@
 {
-  "bundledAt": "2026-05-04T05:01:08.180Z",
-  "sdkSource": "/home/hamzaibrahim1/rei-ai-brain/harness/packages/harness-http-client/dist",
+  "bundledAt": "2026-05-18T23:57:27.383Z",
+  "sdkSource": "/tmp/aria-connector-publish-a1e3272/harness/packages/harness-http-client/dist",
   "files": 12
 }

package/dist/sdk/index.d.ts

@@ -144,18 +144,29 @@ export interface RecordDiscoveryResult {
 }
 export interface VerifyClaimArgs {
     claim: string;
-    evidence: string | null;
-    sessionId: string;
+    evidence?: unknown;
+    evidenceRefs?: unknown[];
+    refs?: unknown[];
+    commands?: Array<Record<string, unknown>>;
+    sessionId?: string;
     turnId?: string;
-    source?: 'pre-text-gate' | 'manual' | 'sub-agent';
+    source?: 'pre-text-gate' | 'manual' | 'sub-agent' | 'mounted-runtime' | string;
     context?: Record<string, unknown>;
+    syncUpstream?: boolean;
+    requireGrounded?: boolean;
 }
 export interface VerifyClaimResult {
     ok: boolean;
     verdict: 'grounded' | 'ungrounded' | 'partially-grounded';
-    evidenceRefs: string[];
+    grounded?: boolean;
+    evidenceRefs: Array<string | HarnessEvidenceRef | Record<string, unknown>>;
     storedAt?: string;
     cognitionCorpusId?: string;
+    receiptId?: string;
+    ledgerPath?: string;
+    upstreamSynced?: boolean;
+    upstream?: unknown;
+    warnings?: string[];
     error?: string;
 }
 export interface ValidationResult {
@@ -205,6 +216,61 @@ export interface GovernanceOutcomeResult {
     threadId?: string;
     message?: string;
 }
+export type GardenPulseSurface = 'telegram' | 'discord' | 'web' | 'cli' | 'mac' | 'autonomy' | 'openclaw' | 'harness_codex' | 'harness_delegate' | 'orchestrate' | 'unknown';
+export type GardenPulseScope = 'interactive_session' | 'worker_internal' | 'ambient_signal';
+export interface GardenRecallOptions {
+    /** Session ID for sameSession tier. Omit to skip that tier. */
+    sessionId?: string | null;
+    /** Surface for sameSurface tier. Omit to skip that tier. */
+    surface?: GardenPulseSurface | null;
+    /** Max rows in sameSession bucket. Default 15, max 50. */
+    sameSessionLimit?: number;
+    /** Max rows in sameSurface bucket. Default 5, max 25. */
+    sameSurfaceLimit?: number;
+    /** Max rows in crossSurface bucket. Default 3, max 25. */
+    crossSurfaceLimit?: number;
+    /** Include worker_internal scope. Default false (interactive surfaces filter it out). */
+    includeWorkerScope?: boolean;
+}
+export interface GardenRecallPulse {
+    id: string;
+    type: string;
+    content: string;
+    intensity: number;
+    timestampMs: number;
+    sessionId?: string;
+    userId?: string;
+    projectId?: string;
+    tags: string[];
+    scope: GardenPulseScope;
+    surface?: GardenPulseSurface;
+    pulseClass: string;
+}
+export interface GardenRecallBundle {
+    ok: boolean;
+    clientId: string;
+    sameSession: GardenRecallPulse[];
+    sameSurface: GardenRecallPulse[];
+    crossSurface: GardenRecallPulse[];
+    snapshotMs: number;
+}
+export type GardenAwakenMode = 'strategic' | 'interactive' | 'background';
+export interface GardenAwakenOptions {
+    /** Recall mode. Affects how the query seed is built and prioritized. */
+    mode?: GardenAwakenMode;
+    /** Allow synchronous manifold/qdrant calls (vs deferred). Default false. */
+    allowSync?: boolean;
+}
+export interface GardenAwakenResult {
+    ok: boolean;
+    clientId: string;
+    query: string;
+    mode: GardenAwakenMode | null;
+    /** The `<GARDEN_CONTEXT>...</GARDEN_CONTEXT>` block. Empty string when no hits. */
+    contextBlock: string;
+    hasContext: boolean;
+    snapshotMs: number;
+}
 /**
  * Result shape for all three Aristotle phases.
  * Mirrors `AristotleNoorWireResult` in aria-connector's aristotle-noor-wire.ts.
@@ -350,12 +416,61 @@ 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>;
+    /**
+     * Tiered garden recall — reads from postgres `garden_pulse` in three buckets:
+     * sameSession (highest weight), sameSurface (medium), crossSurface (ambient).
+     * Backs `POST /api/garden/recall`, which wraps `selectGardenRecall`
+     * (the production tiered read API as of 2026-05-12).
+     *
+     * Worker scope is filtered out by default so interactive surfaces never see
+     * worker pollution. Pass `includeWorkerScope: true` for debug/audit reads.
+     *
+     * Errors propagate (per no-graceful-degradation doctrine) — caller decides
+     * whether to retry, log, or surface.
+     */
+    gardenRecall(opts?: GardenRecallOptions): Promise<GardenRecallBundle>;
+    /**
+     * Semantic garden recall — reads from qdrant `garden-pulses` (federated
+     * through the unified manifold). Returns the `<GARDEN_CONTEXT>...</GARDEN_CONTEXT>`
+     * block that aria-soul already injects server-side for in-process callers;
+     * this exposes the same primitive to external SDK consumers.
+     *
+     * Backs `POST /api/garden/awaken`, which wraps `awakenAria`
+     * (`apps/arias-soul/api/lib/true-garden.ts:245`).
+     *
+     * `mode: 'strategic'` rebuilds a compact recall seed when the query is
+     * >1800 chars (per `buildStrategicRecallSeed`). Default mode is
+     * interactive-shaped.
+     */
+    gardenAwaken(query: string, opts?: GardenAwakenOptions): Promise<GardenAwakenResult>;
     hydrateGardenContinuity(sessionId: string, query: string, limits?: {
         threadLimit?: number;
         pulseLimit?: number;
         userId?: string;
     }): Promise<GardenContinuitySnapshot>;
     persistGovernanceOutcome(input: GovernanceOutcomeInput): Promise<GovernanceOutcomeResult>;
+    /**
+     * Atlas architecture snapshot — proxies through aria-soul's
+     * `/api/architecture` route to the Doctrine-Bound Code Atlas daemon.
+     *
+     * Returns the substrate-by-substrate map of the indexed codebase:
+     * counts per kind, top-N nodes by edge degree, active gate hooks,
+     * recently-touched regions, freshness (snapshot_id + git_sha + age).
+     *
+     * `view='session-context'` returns the compact ≤2KB orientation
+     * instead of the full top-down map — useful for session-start
+     * substrate injection.
+     *
+     * Errors propagate per no-graceful-degradation doctrine — caller
+     * decides whether to retry, log, or degrade.
+     */
+    atlasArchitecture(opts?: {
+        view?: 'architecture' | 'session-context';
+    }): Promise<{
+        ok: boolean;
+        view: string;
+        atlas: unknown;
+    }>;
     consult(args: {
         brief: string;
         sessionId: string;

package/dist/sdk/index.js

@@ -680,6 +680,93 @@ export class HTTPHarnessClient {
             throw new Error(`garden/fire failed: ${res.status} ${res.statusText}`);
         }
     }
+    /**
+     * Tiered garden recall — reads from postgres `garden_pulse` in three buckets:
+     * sameSession (highest weight), sameSurface (medium), crossSurface (ambient).
+     * Backs `POST /api/garden/recall`, which wraps `selectGardenRecall`
+     * (the production tiered read API as of 2026-05-12).
+     *
+     * Worker scope is filtered out by default so interactive surfaces never see
+     * worker pollution. Pass `includeWorkerScope: true` for debug/audit reads.
+     *
+     * Errors propagate (per no-graceful-degradation doctrine) — caller decides
+     * whether to retry, log, or surface.
+     */
+    async gardenRecall(opts = {}) {
+        const res = await this.fetchWithRetry(`${this.baseUrl}/api/garden/recall`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                sessionId: opts.sessionId ?? null,
+                surface: opts.surface ?? null,
+                sameSessionLimit: opts.sameSessionLimit,
+                sameSurfaceLimit: opts.sameSurfaceLimit,
+                crossSurfaceLimit: opts.crossSurfaceLimit,
+                includeWorkerScope: opts.includeWorkerScope === true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`garden/recall failed: ${res.status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        const sameSession = Array.isArray(data.sameSession) ? data.sameSession : [];
+        const sameSurface = Array.isArray(data.sameSurface) ? data.sameSurface : [];
+        const crossSurface = Array.isArray(data.crossSurface) ? data.crossSurface : [];
+        return {
+            ok: Boolean(data.ok),
+            clientId: String(data.client_id || data.clientId || ''),
+            sameSession,
+            sameSurface,
+            crossSurface,
+            snapshotMs: Number(data.snapshotMs || data.snapshot_ms || Date.now()),
+        };
+    }
+    /**
+     * Semantic garden recall — reads from qdrant `garden-pulses` (federated
+     * through the unified manifold). Returns the `<GARDEN_CONTEXT>...</GARDEN_CONTEXT>`
+     * block that aria-soul already injects server-side for in-process callers;
+     * this exposes the same primitive to external SDK consumers.
+     *
+     * Backs `POST /api/garden/awaken`, which wraps `awakenAria`
+     * (`apps/arias-soul/api/lib/true-garden.ts:245`).
+     *
+     * `mode: 'strategic'` rebuilds a compact recall seed when the query is
+     * >1800 chars (per `buildStrategicRecallSeed`). Default mode is
+     * interactive-shaped.
+     */
+    async gardenAwaken(query, opts = {}) {
+        if (!query || typeof query !== 'string') {
+            throw new Error('gardenAwaken: query is required (non-empty string)');
+        }
+        const res = await this.fetchWithRetry(`${this.baseUrl}/api/garden/awaken`, {
+            method: 'POST',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                query,
+                mode: opts.mode,
+                allowSync: opts.allowSync === true,
+            }),
+        });
+        if (!res.ok) {
+            throw new Error(`garden/awaken failed: ${res.status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        return {
+            ok: Boolean(data.ok),
+            clientId: String(data.client_id || data.clientId || ''),
+            query: String(data.query || query),
+            mode: data.mode ?? null,
+            contextBlock: String(data.contextBlock || data.context_block || ''),
+            hasContext: Boolean(data.hasContext ?? false),
+            snapshotMs: Number(data.snapshotMs || data.snapshot_ms || Date.now()),
+        };
+    }
     async hydrateGardenContinuity(sessionId, query, limits = {}) {
         if (this.gardenBaseUrl) {
             const params = new URLSearchParams({
@@ -794,6 +881,41 @@ export class HTTPHarnessClient {
         }
         throw new Error(`persistGovernanceOutcome failed: ${lastStatus || 'no target available'}`);
     }
+    /**
+     * Atlas architecture snapshot — proxies through aria-soul's
+     * `/api/architecture` route to the Doctrine-Bound Code Atlas daemon.
+     *
+     * Returns the substrate-by-substrate map of the indexed codebase:
+     * counts per kind, top-N nodes by edge degree, active gate hooks,
+     * recently-touched regions, freshness (snapshot_id + git_sha + age).
+     *
+     * `view='session-context'` returns the compact ≤2KB orientation
+     * instead of the full top-down map — useful for session-start
+     * substrate injection.
+     *
+     * Errors propagate per no-graceful-degradation doctrine — caller
+     * decides whether to retry, log, or degrade.
+     */
+    async atlasArchitecture(opts = {}) {
+        const view = opts.view ?? 'architecture';
+        const path = `/api/architecture${view === 'session-context' ? '?view=session-context' : ''}`;
+        const res = await this.fetchWithRetry(`${this.baseUrl}${path}`, {
+            method: 'GET',
+            headers: {
+                Authorization: `Bearer ${this.apiKey}`,
+                Accept: 'application/json',
+            },
+        });
+        if (!res.ok) {
+            throw new Error(`atlasArchitecture failed: ${res.status} ${res.statusText}`);
+        }
+        const data = (await res.json());
+        return {
+            ok: Boolean(data.ok),
+            view: String(data.view || view),
+            atlas: data.atlas ?? null,
+        };
+    }
     // ── 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
@@ -1255,31 +1377,35 @@ export class HTTPHarnessClient {
         }
     }
     // ── verifyClaim ──────────────────────────────────────────────────────────
-    // POST /api/harness/verify-claim — persists a claim/evidence pair to
-    // aria_cognition_corpus and returns a verdict. Fail-soft: if the server-side
-    // handler is not yet deployed, returns an optimistic verdict rather than
-    // blocking the caller.
+    // Mounted runtimes own local claim receipts at /verify-claim. Server harnesses
+    // persist replicated receipts at /api/harness/verify-claim. Transport failure
+    // is never treated as grounded evidence.
     async verifyClaim(args) {
         if (!args.claim || args.claim.length < 4) {
             return { ok: false, verdict: 'ungrounded', evidenceRefs: [], error: 'claim too short' };
         }
         try {
-            const url = `${this.baseUrl}/api/harness/verify-claim`;
-            const resp = await fetch(url, {
+            const path = isMountedRuntimeBaseUrl(this.baseUrl) ? '/verify-claim' : '/api/harness/verify-claim';
+            const url = this.baseUrl + path;
+            const resp = await this.fetchWithRetry(url, {
                 method: 'POST',
                 headers: {
-                    Authorization: `Bearer ${this.apiKey}`,
+                    Authorization: 'Bearer ' + this.apiKey,
                     'Content-Type': 'application/json',
                 },
                 body: JSON.stringify(args),
             });
             if (!resp.ok) {
-                // Fail-soft: return optimistic verdict so the caller doesn't block on missing endpoint
+                let detail = resp.statusText || '';
+                try {
+                    detail = (await resp.text()).slice(0, 200) || detail;
+                }
+                catch { }
                 return {
                     ok: false,
-                    verdict: args.evidence ? 'grounded' : 'ungrounded',
+                    verdict: 'ungrounded',
                     evidenceRefs: [],
-                    error: `verify-claim endpoint HTTP ${resp.status} (server-side handler may not be deployed yet)`,
+                    error: 'verify-claim endpoint HTTP ' + resp.status + (detail ? ': ' + detail : ''),
                 };
             }
             return await resp.json();
@@ -1287,9 +1413,9 @@ export class HTTPHarnessClient {
         catch (err) {
             return {
                 ok: false,
-                verdict: args.evidence ? 'grounded' : 'ungrounded',
+                verdict: 'ungrounded',
                 evidenceRefs: [],
-                error: `verify-claim fetch failed: ${err.message}`,
+                error: 'verify-claim fetch failed: ' + err.message,
             };
         }
     }