@deepstrike/sdk 0.2.39 → 0.2.41

package/README.md

@@ -88,13 +88,13 @@ The root export is the **intent layer** — what you reach for to run an agent,
 
 | Import | Contains |
 |--------|----------|
-| `@deepstrike/sdk` | `runAgent` · `runFanout` · `RuntimeRunner` · `tool` · `LocalExecutionPlane` · `InMemorySessionLog`/`FileSessionLog` · `AnthropicProvider`/`OpenAIProvider`/`OpenAIResponsesProvider` · `createProvider` · `Governance` · `AgentPool` · core types |
+| `@deepstrike/sdk` | `runAgent` · `runFanout` · `RuntimeRunner` · `tool` · `LocalExecutionPlane` · `InMemorySessionLog`/`FileSessionLog` · `AnthropicProvider`/`OpenAIProvider`/`OpenAIResponsesProvider` · `createProvider` · `Governance` · `AgentPool` · `operationAbortSignal` · core types |
 | `@deepstrike/sdk/providers` | backend factories (`deepseek`, `kimi`, `qwen`, `glm`, `minimax`, `gemini`, `ollama`), profiles, `CircuitBreaker` |
 | `@deepstrike/sdk/workflow` | `SubAgentOrchestrator`, `spawnStandalone`, reducers, contracts, handoff/modes, agent + spec types |
 | `@deepstrike/sdk/planes` | `WorktreeExecutionPlane`, `ProcessSandboxPlane`, `McpProxyPlane`, `RemoteVpcPlane`, archive/credential stores |
-| `@deepstrike/sdk/memory` | `DreamStore`, `WorkingMemory`, `InMemoryDreamStore`, `KnowledgeSource` |
-| `@deepstrike/sdk/harness` | `SinglePassHarness`, `EvalLoopHarness`, `HarnessLoop`, `judge` |
-| `@deepstrike/sdk/os` | profiles, `KernelPrimitivesDashboard`, signals, `PermissionManager`, replay-testing utilities |
+| `@deepstrike/sdk/memory` | `DreamStore`, `WorkingMemory`, `InMemoryDreamStore`, `rankMemories`, `extractSessionMemories`, `KnowledgeSource` |
+| `@deepstrike/sdk/harness` | `AttemptLoop`, body/judge/carry policies, `judge` |
+| `@deepstrike/sdk/os` | profiles, `KernelPrimitivesDashboard`, `primitiveForKind` / `KernelPrimitive`, signals, `PermissionManager`, replay-testing utilities |
 
 > **Migration from 0.2.x:** the kernel-lowering converters (`*ToKernel`), low-level prompt/eval builders, and the `OpenAIChatProvider` alias are no longer exported from root; backend providers, planes, memory, harness, and OS utilities moved to the subpaths above. See [`MIGRATION-v0.2.300.md`](./MIGRATION-v0.2.300.md).
 
@@ -190,7 +190,7 @@ Tool calls, spawns, compression, and signals pass through one kernel gate with a
 Oversized tool results (> 50 KB) stay in context as a preview plus a `.spool/` reference — the model reads the full payload on demand via ordinary file tools. When pressure triggers semantic eviction, the SDK summarizes archived content into `DreamStore`. Long tasks survive token pressure instead of failing mid-run.
 
 **Safety and governance by default (OS native profile)**  
-Every run loads declarative `governancePolicy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`attentionPolicy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc `if` checks in your handlers.
+Every run loads declarative `governancePolicy` (deny / ask_user / rate-limit / param rules) and in-kernel signal routing (`signalPolicy`, default queue 64). Dangerous tools, external interrupts, and approval flows are policy — not ad-hoc `if` checks in your handlers.
 
 **Long-term memory as syscalls (Phase-7)**  
 `writeMemory` and `queryMemory` run outside the main tool loop: kernel validation before `DreamStore.commit`, search → `selectMemories` → `memory_retrieval_result` on query. Failed writes emit `memory_validation_failed` for audit; good memory is durable without polluting history.
@@ -204,7 +204,7 @@ Spool, page-out, signals, processes, budgets, and memory events land in `Session
 | You need… | Use… |
 |---|---|
 | Policy before tools run | `governancePolicy` (default: allow-all native profile) |
-| External interrupts | `signalSource` + in-kernel `attentionPolicy` |
+| External interrupts | `signalSource` + in-kernel `signalPolicy` |
 | Huge tool output | Automatic Layer-1 spool; optional custom `resultSpool` |
 | Durable recall across runs | `DreamStore` + semantic `page_out` via `dreamSummarizer` |
 | Programmatic memory I/O | `runner.writeMemory()` / `runner.queryMemory()` |
@@ -336,7 +336,7 @@ Full reference: [docs/concepts/context-slots-compression.md](../docs/concepts/co
 ```typescript
 import {
   DEFAULT_NATIVE_GOVERNANCE_POLICY,
-  DEFAULT_NATIVE_ATTENTION_POLICY,
+  DEFAULT_NATIVE_SIGNAL_POLICY,
 } from "@deepstrike/sdk"
 
 const runner = new RuntimeRunner({
@@ -348,7 +348,13 @@ const runner = new RuntimeRunner({
   maxTokens: 128_000,
   maxTurns: 25,
   timeoutMs: 60_000,
-  schedulerBudget: { maxWallMs: 300_000 },
+  schedulerPolicy: {
+    version: 1,
+    criticalPathWeight: 1_000_000,
+    fanoutWeight: 10_000,
+    ageWeight: 1_000,
+    tokenCostWeight: 1,
+  },
 
   // Resource quotas (M2) — enforced at the kernel syscall trap. Opt-in; omit for unbounded.
   resourceQuota: {
@@ -369,7 +375,12 @@ const runner = new RuntimeRunner({
 
   // Agent OS native profile (defaults shown)
   governancePolicy: DEFAULT_NATIVE_GOVERNANCE_POLICY,
-  attentionPolicy: DEFAULT_NATIVE_ATTENTION_POLICY, // SignalRouter queue size 64
+  signalPolicy: DEFAULT_NATIVE_SIGNAL_POLICY, // SignalRouter queue size 64
+  promptBudget: {
+    promptOverheadTokens: 20,
+    outputReserveTokens: 4096,
+    safetyMarginTokens: 256,
+  },
 
   // Host I/O
   extensions: { temperature: 0.1 },
@@ -404,7 +415,8 @@ const runner = new RuntimeRunner({
 | Option | Purpose |
 |--------|---------|
 | `governancePolicy` | Declarative deny / ask_user / rate-limit / param rules loaded into the kernel before `start_run` |
-| `attentionPolicy` | In-kernel signal router queue size (default 64) |
+| `signalPolicy` | Versioned in-kernel signal queue/TTL policy (default queue 64) |
+| `promptBudget` | Provider-envelope overhead, output reserve, and safety margin deducted from the context window |
 | `resourceQuota` | M2 declarative limits — `maxConcurrentSubagents` / `maxSpawnDepth` / `memoryWritesPerWindow` — enforced at the kernel syscall trap (`set_resource_quota`); over-quota spawns roll back, over-rate writes surface as `memory_validation_failed` |
 | `memoryPolicy` | Long-term memory config sent as `set_memory_policy` and **kernel-enforced**: `validationEnabled: false` admits writes without validation, `maxContentBytes` / `maxNameLength` override validation limits, `retrievalTopK` caps `query_memory` breadth; `memoryPath` / `staleWarningDays` are SDK-consumed (requires `dreamStore` + `agentId` to enable memory) |
 | `onPermissionRequest` | Resolves `tool_gated` + `suspended` → kernel `resume` with approved/denied call IDs |
@@ -528,7 +540,7 @@ const runner = new RuntimeRunner({
 `WorkingMemory` is an SDK helper — not the kernel working partition. Kernel task state lives in `task_state` and renders into Slot 3 (`turns[0]`).
 
 ```typescript
-import { WorkingMemory } from "@deepstrike/sdk"
+import { WorkingMemory } from "@deepstrike/sdk/memory"
 const mem = new WorkingMemory()
 mem.set("step", 1)
 mem.get("step")  // 1
@@ -538,13 +550,13 @@ mem.clear()
 ### DreamStore (long-term memory)
 
 ```typescript
-import type { DreamStore } from "@deepstrike/sdk"
+import type { DreamStore } from "@deepstrike/sdk/memory"
 
 class MyStore implements DreamStore {
   async loadSessions(agentId) { ... }
   async loadMemories(agentId) { ... }
   async commit(agentId, result, existing) { ... }
-  async search(agentId, query, topK) { ... }
+  async search(agentId, query) { ... } // Promise<MemoryRecall[]>
 }
 
 const runner = new RuntimeRunner({
@@ -577,21 +589,26 @@ Kernel-validated long-term memory I/O outside the main tool loop:
 
 ```typescript
 await runner.writeMemory({
-  metadata: {
-    name: "prefers-small-tests",
-    description: "User prefers focused unit tests",
-    kind: "feedback",
-    created_at: Date.now(),
-    updated_at: Date.now(),
-  },
+  record_id: crypto.randomUUID(),
+  scope: { tenant_id: "acme", namespace: "assistant" },
+  name: "prefers-small-tests",
+  kind: "feedback",
   content: "User prefers focused unit tests for SDK behavior.",
+  description: "Testing preference",
+  provenance: { author: "host", trust: "user_asserted", evidence_refs: [] },
+  created_at: Date.now(),
+  updated_at: Date.now(),
+  recall_count: 0,
+  confidence: 1,
+  links: [],
+  pinned: false,
 }, { sessionId: "my-session" })
 
 const hits = await runner.queryMemory({
-  current_context: "Need testing preferences",
-  active_tools: [],
-  already_surfaced: [],
+  scope: { tenant_id: "acme", namespace: "assistant" },
+  query: "Need testing preferences",
   top_k: 5,
+  kinds: ["feedback"],
 }, { sessionId: "my-session" })
 ```
 
@@ -676,14 +693,14 @@ const runner = new RuntimeRunner({
   executionPlane: plane,
   sessionLog,
   signalSource: gw,
-  attentionPolicy: { maxQueueSize: 64 },
+  signalPolicy: { queueMax: 64, ttlMs: 60_000 },
 })
 
 runner.interrupt() // cooperative abort → kernel timeout path
 gw.destroy()
 ```
 
-Each routed signal produces a `signal_disposed` session event (`category: "ipc"`).
+Each routed signal produces a correlated `signal_delivery_disposed` session event (`category: "ipc"`).
 
 ---
 
@@ -709,15 +726,25 @@ Requires an active parent run (`run()` / `wake()` in progress). The kernel emits
 ## Harness (evaluation framework)
 
 ```typescript
-import { SinglePassHarness, EvalLoopHarness, HarnessLoop } from "@deepstrike/sdk"
-
-const outcome = await new SinglePassHarness(runner).run({ goal: "Say hello" })
-
-const harness = new EvalLoopHarness(runner, {
-  async evaluate(_req, out) { return out.result.includes("hello") },
-}, 3)
-
-const loop = new HarnessLoop(runner, evalProvider, { maxAttempts: 3, skillDir: "./skills" })
+import {
+  AttemptLoop,
+  RuntimeAttemptBody,
+  LlmEvalJudge,
+  freshWithFeedback,
+} from "@deepstrike/sdk/harness"
+
+const loop = new AttemptLoop({
+  body: new RuntimeAttemptBody(runner),
+  judge: new LlmEvalJudge(evalProvider, false),
+  stop: { maxAttempts: 3 },
+  // carry defaults to continueSession: stable session + journaled feedback signal.
+  // Use `carry: freshWithFeedback` only when attempts must be isolated.
+})
+const outcome = await loop.run({
+  sessionId: "task-42",
+  goal: "Say hello",
+  criteria: [{ text: "result greets the user", required: true }],
+})
 
 const runnerWithHarness = new RuntimeRunner({
   provider,
@@ -727,6 +754,9 @@ const runnerWithHarness = new RuntimeRunner({
 })
 ```
 
+`AttemptOutcome` keeps run health (`runStatus`) separate from evaluation (`verdict`) and reports a
+terminal `outcome`: `passed`, `failed_judge`, `exhausted`, or `run_error`.
+
 ---
 
 ## Stream events

package/dist/collaboration/contract.d.ts

@@ -48,8 +48,8 @@ export declare class ContractBuilder {
 }
 /**
  * Render the contract as a markdown block for injection into a system prompt.
- * Used by ContractDrivenHarness to inject into the executor's system partition.
+ * Used by CreatorVerifierBody to inject into the executor's system partition.
  */
 export declare function formatContractForSystemPrompt(contract: VerificationContract): string;
-/** Derive a flat string[] of criterion texts for the existing HarnessLoop criteria API. */
+/** Derive a flat string[] of criterion texts for RuntimeRunner criteria input. */
 export declare function contractToCriteriaStrings(contract: VerificationContract): string[];

package/dist/collaboration/contract.js

@@ -35,7 +35,7 @@ export class ContractBuilder {
 }
 /**
  * Render the contract as a markdown block for injection into a system prompt.
- * Used by ContractDrivenHarness to inject into the executor's system partition.
+ * Used by CreatorVerifierBody to inject into the executor's system partition.
  */
 export function formatContractForSystemPrompt(contract) {
     const lines = [
@@ -59,7 +59,7 @@ export function formatContractForSystemPrompt(contract) {
     }
     return lines.join("\n");
 }
-/** Derive a flat string[] of criterion texts for the existing HarnessLoop criteria API. */
+/** Derive a flat string[] of criterion texts for RuntimeRunner criteria input. */
 export function contractToCriteriaStrings(contract) {
     return contract.acceptance.map(c => c.text);
 }

package/dist/collaboration/handoff.d.ts

@@ -1,12 +1,10 @@
 import type { ContractCheckResult, VerificationContract } from "./contract.js";
-import type { DreamResult } from "../memory/protocols.js";
 /**
  * HandoffArtifact — the single exchange token between sprints and agent instances.
  *
  * All handoff paths converge here:
- *   - ContractDrivenHarness completion  → HandoffBus.fromContractOutcome()
+ *   - CreatorVerifier AttemptLoop completion → HandoffBus.fromContractOutcome()
  *   - Sub-agent completion              → HandoffBus.fromSubAgentResult()
- *   - Dream consolidation               → HandoffBus.fromDream()
  *   - Context renewal (kernel)          → carried in kernel's HandoffArtifact type
  *
  * The invariant: a HandoffArtifact tells the next agent not only *what was done*
@@ -41,7 +39,7 @@ export interface ContractOutcomeInput {
  */
 export declare class HandoffBus {
     /**
-     * Build a HandoffArtifact from a ContractDrivenHarness outcome.
+     * Build a HandoffArtifact from a creator-verifier AttemptLoop outcome.
      * The artifact field is used as the progress summary.
      */
     static fromContractOutcome(input: ContractOutcomeInput): HandoffArtifact;
@@ -54,16 +52,6 @@ export declare class HandoffBus {
         finalMessage: string;
         sprint?: number;
     }): HandoffArtifact;
-    /**
-     * Build a HandoffArtifact from a dream consolidation result.
-     * Used when the idle pipeline produces new memories that should be
-     * carried into the next sprint's context.
-     */
-    static fromDream(opts: {
-        goal: string;
-        dreamResult: DreamResult;
-        sprint?: number;
-    }): HandoffArtifact;
     /**
      * Render the artifact as a compact injection string for the next agent's
      * working partition (not system — this is a handoff note, not a permanent rule).

package/dist/collaboration/handoff.js

@@ -7,7 +7,7 @@
  */
 export class HandoffBus {
     /**
-     * Build a HandoffArtifact from a ContractDrivenHarness outcome.
+     * Build a HandoffArtifact from a creator-verifier AttemptLoop outcome.
      * The artifact field is used as the progress summary.
      */
     static fromContractOutcome(input) {
@@ -46,22 +46,6 @@ export class HandoffBus {
             blockedOn: [],
         };
     }
-    /**
-     * Build a HandoffArtifact from a dream consolidation result.
-     * Used when the idle pipeline produces new memories that should be
-     * carried into the next sprint's context.
-     */
-    static fromDream(opts) {
-        return {
-            goal: opts.goal,
-            sprint: opts.sprint ?? 1,
-            progressSummary: `Memory consolidated: ${opts.dreamResult.entriesAdded} added, ${opts.dreamResult.entriesRemoved} removed.`,
-            openTasks: [],
-            contractStatus: [],
-            driftRate24h: 0,
-            blockedOn: [],
-        };
-    }
     /**
      * Render the artifact as a compact injection string for the next agent's
      * working partition (not system — this is a handoff note, not a permanent rule).

package/dist/collaboration/harness.d.ts

@@ -1,11 +1,8 @@
-import type { AgentPool, CoordinatorConfig } from "./pool.js";
-import type { VerificationContract, ContractCheckResult } from "./contract.js";
+import type { AttemptBody, AttemptBodyContext, AttemptBodyEvent } from "../harness/harness.js";
+import type { AttemptJudge, JudgeContext, JudgeResult } from "../harness/judge.js";
+import type { ContractCheckResult, VerificationContract } from "./contract.js";
 import type { HandoffArtifact } from "./handoff.js";
-export interface Violation {
-    criterionId: string;
-    text: string;
-    detail: string;
-}
+import type { AgentPool } from "./pool.js";
 export interface ContractOutcome {
     success: boolean;
     artifact: string;
@@ -14,45 +11,17 @@ export interface ContractOutcome {
     totalTokensConsumed: number;
     handoff: HandoffArtifact;
 }
-export interface ContractHarnessOptions {
-    maxAttempts?: number;
-    onViolation?: (violations: Violation[]) => void;
-    /** When set with pool.configureCoordinator(), enables kernel spawn path. */
-    coordinator?: CoordinatorConfig;
+/** The creator-verifier body owns execution only; verification is an AttemptJudge. */
+export declare class CreatorVerifierBody implements AttemptBody {
+    private readonly pool;
+    private readonly contract;
+    constructor(pool: AgentPool, contract: VerificationContract);
+    run(context: AttemptBodyContext): AsyncIterable<AttemptBodyEvent>;
 }
-/**
- * ContractDrivenHarness — the core multi-agent execution primitive.
- *
- * Differs from HarnessLoop in three ways:
- *   1. Executor and verifier are **separate Agent instances** — no shared history.
- *   2. Verifier receives only the artifact + contract, not the implementation transcript.
- *   3. Feedback returned to the executor is a structured list of Violations,
- *      not a free-text LLM summary.
- *
- * Protocol per attempt:
- *   executor.run(goal, contract) → artifact
- *   verifier.runIsolated(artifact, contract) → audit text
- *   parse audit text → ContractCheckResult[]
- *   all required criteria pass → Done
- *   violations remain → inject only violation list into next executor goal
- *   maxAttempts exceeded → produce HandoffArtifact with blocked_on
- */
-export declare class ContractDrivenHarness {
-    private pool;
-    private contract;
-    private maxAttempts;
-    private onViolation?;
-    constructor(pool: AgentPool, contract: VerificationContract, options?: ContractHarnessOptions);
-    stream(): AsyncIterable<ContractOutcome>;
-    run(): Promise<ContractOutcome>;
-    private _findViolations;
-    private _formatViolationsForFeedback;
-    /**
-     * Parse the verifier's free-text audit into structured ContractCheckResult[].
-     *
-     * The verifier is prompted to produce a structured PASS/FAIL per criterion.
-     * This parser handles the common patterns; callers can subclass and override
-     * for stricter parsing.
-     */
-    private _parseAuditText;
+/** Structured verifier output only. Free-text PASS/FAIL inference is intentionally unsupported. */
+export declare class StructuredContractJudge implements AttemptJudge {
+    private readonly pool;
+    private readonly contract;
+    constructor(pool: AgentPool, contract: VerificationContract);
+    judge(context: JudgeContext): Promise<JudgeResult>;
 }

package/dist/collaboration/harness.js

@@ -1,169 +1,68 @@
-import { collectText } from "../runtime/runner.js";
-import { formatContractForSystemPrompt, contractToCriteriaStrings } from "./contract.js";
-import { HandoffBus } from "./handoff.js";
-/**
- * ContractDrivenHarness — the core multi-agent execution primitive.
- *
- * Differs from HarnessLoop in three ways:
- *   1. Executor and verifier are **separate Agent instances** — no shared history.
- *   2. Verifier receives only the artifact + contract, not the implementation transcript.
- *   3. Feedback returned to the executor is a structured list of Violations,
- *      not a free-text LLM summary.
- *
- * Protocol per attempt:
- *   executor.run(goal, contract) → artifact
- *   verifier.runIsolated(artifact, contract) → audit text
- *   parse audit text → ContractCheckResult[]
- *   all required criteria pass → Done
- *   violations remain → inject only violation list into next executor goal
- *   maxAttempts exceeded → produce HandoffArtifact with blocked_on
- */
-export class ContractDrivenHarness {
+import { parseVerdict } from "../runtime/eval.js";
+import { formatContractForSystemPrompt } from "./contract.js";
+/** The creator-verifier body owns execution only; verification is an AttemptJudge. */
+export class CreatorVerifierBody {
     pool;
     contract;
-    maxAttempts;
-    onViolation;
-    constructor(pool, contract, options = {}) {
+    constructor(pool, contract) {
         this.pool = pool;
         this.contract = contract;
-        this.maxAttempts = options.maxAttempts ?? 3;
-        this.onViolation = options.onViolation;
-        if (options.coordinator) {
-            this.pool.configureCoordinator(options.coordinator.opts, options.coordinator.sessionId);
-        }
-    }
-    async *stream() {
-        yield await this.run();
     }
-    async run() {
-        let artifact = "";
-        let checkResults = [];
-        let attemptsUsed = 0;
-        let currentGoal = this.contract.goal;
-        for (let attempt = 1; attempt <= this.maxAttempts; attempt++) {
-            attemptsUsed = attempt;
-            // ── Phase 1: Executor ──────────────────────────────────────────────────
-            // Executor sees: contract block + goal. No verifier history.
-            const contractBlock = formatContractForSystemPrompt(this.contract);
-            const violationNote = attempt > 1
-                ? `\n\n[Previous attempt failed. Violations to fix:\n${this._formatViolationsForFeedback(checkResults)}]`
-                : "";
-            const executorGoal = `${contractBlock}\n\n---\n\n${currentGoal}${violationNote}`;
-            if (this.pool.usesSpawnPath()) {
-                const execResult = await this.pool.spawn("executor", executorGoal, {
-                    verificationContractId: this.contract.id,
-                });
-                artifact = execResult.result.finalMessage?.content ?? "";
-            }
-            else {
-                artifact = await collectText(this.pool.get("executor").run({
-                    sessionId: crypto.randomUUID(),
-                    goal: executorGoal,
-                    criteria: contractToCriteriaStrings(this.contract),
-                }));
-            }
-            // ── Phase 2: Verifier ──────────────────────────────────────────────────
-            // Verifier sees: artifact + contract only. No executor history.
-            const auditText = await this.pool.verify({ contract: this.contract, artifact });
-            // ── Phase 3: Parse audit → ContractCheckResult[] ──────────────────────
-            checkResults = this._parseAuditText(auditText);
-            const violations = this._findViolations(checkResults);
-            if (violations.length === 0) {
-                // All required criteria passed
-                return {
-                    success: true,
-                    artifact,
-                    checkResults,
-                    attemptsUsed,
-                    totalTokensConsumed: 0,
-                    handoff: HandoffBus.fromContractOutcome({
-                        contract: this.contract,
-                        checkResults,
-                        artifact,
-                        success: true,
-                    }),
-                };
-            }
-            this.onViolation?.(violations);
-        }
-        // Max attempts exhausted
-        const blockedOn = this._findViolations(checkResults).map(v => `[${v.criterionId}] ${v.text}: ${v.detail}`);
-        return {
-            success: false,
-            artifact,
-            checkResults,
-            attemptsUsed,
-            totalTokensConsumed: 0,
-            handoff: HandoffBus.fromContractOutcome({
-                contract: this.contract,
-                checkResults,
-                artifact,
-                success: false,
-                blockedOn,
-            }),
+    async *run(context) {
+        const contractBlock = formatContractForSystemPrompt(this.contract);
+        const result = await this.pool.execute("executor", {
+            sessionId: context.sessionId,
+            goal: `${contractBlock}\n\n---\n\n${context.goal}`,
+            ...(context.contextInput ? { contextInput: context.contextInput } : {}),
+            verificationContractId: this.contract.id,
+        });
+        const artifact = result.result.finalMessage?.content ?? "";
+        if (artifact)
+            yield { type: "token", text: artifact };
+        yield {
+            type: "body_done",
+            runStatus: String(result.result.termination),
+            result: artifact,
+            turns: result.result.turnsUsed,
+            totalTokens: result.result.totalTokensUsed,
+            ...(result.submittedNodes?.length ? { submittedNodes: result.submittedNodes } : {}),
         };
     }
-    _findViolations(results) {
-        const violations = [];
-        for (const result of results) {
-            if (!result.passed) {
-                const criterion = this.contract.acceptance.find(c => c.id === result.criterionId);
-                if (criterion?.required) {
-                    violations.push({
-                        criterionId: result.criterionId,
-                        text: criterion.text,
-                        detail: result.evidence ?? "no evidence provided",
-                    });
-                }
-            }
-        }
-        return violations;
-    }
-    _formatViolationsForFeedback(results) {
-        return this._findViolations(results)
-            .map(v => `- [${v.criterionId}] ${v.text}: ${v.detail}`)
-            .join("\n");
+}
+/** Structured verifier output only. Free-text PASS/FAIL inference is intentionally unsupported. */
+export class StructuredContractJudge {
+    pool;
+    contract;
+    constructor(pool, contract) {
+        this.pool = pool;
+        this.contract = contract;
     }
-    /**
-     * Parse the verifier's free-text audit into structured ContractCheckResult[].
-     *
-     * The verifier is prompted to produce a structured PASS/FAIL per criterion.
-     * This parser handles the common patterns; callers can subclass and override
-     * for stricter parsing.
-     */
-    _parseAuditText(auditText) {
-        const results = [];
-        const lower = auditText.toLowerCase();
-        for (const criterion of this.contract.acceptance) {
-            // Look for explicit "id: PASS" or "id: FAIL" patterns from the verifier prompt
-            const idPattern = new RegExp(`\\b${criterion.id.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}\\b[^\\n]*?(pass|fail)`, "i");
-            const match = auditText.match(idPattern);
-            if (match) {
-                const passed = match[1].toLowerCase() === "pass";
-                // Extract the line as evidence
-                const lineStart = auditText.lastIndexOf("\n", match.index ?? 0) + 1;
-                const lineEnd = auditText.indexOf("\n", match.index ?? 0);
-                const evidence = auditText.slice(lineStart, lineEnd > 0 ? lineEnd : undefined).trim();
-                results.push({ criterionId: criterion.id, passed, evidence });
-            }
-            else {
-                // Fallback: search for criterion text near PASS/FAIL keywords
-                const textIdx = lower.indexOf(criterion.text.toLowerCase().slice(0, 30));
-                if (textIdx !== -1) {
-                    const window = lower.slice(textIdx, textIdx + 200);
-                    const passed = window.includes("pass") && !window.includes("fail");
-                    results.push({ criterionId: criterion.id, passed, evidence: "inferred from context" });
-                }
-                else {
-                    // No mention found — conservative: treat as failed
-                    results.push({
-                        criterionId: criterion.id,
-                        passed: false,
-                        evidence: "criterion not mentioned in audit",
-                    });
-                }
-            }
+    async judge(context) {
+        const auditText = await this.pool.verify({ contract: this.contract, artifact: context.result });
+        const wire = JSON.parse(auditText);
+        if (typeof wire !== "object" || wire === null || Array.isArray(wire)) {
+            throw new Error("structured verifier output must be a JSON object");
         }
-        return results;
+        const parsed = parseVerdict(auditText);
+        const details = this.contract.acceptance.map(criterion => {
+            const detail = parsed.details.find(candidate => candidate.criterion === criterion.id || candidate.criterion === criterion.text);
+            return detail
+                ? { ...detail, criterion: criterion.id }
+                : {
+                    criterion: criterion.id,
+                    passed: false,
+                    score: 0,
+                    feedback: "criterion missing from structured verifier output",
+                };
+        });
+        const requiredPassed = this.contract.acceptance.every((criterion, index) => !criterion.required || details[index].passed);
+        return {
+            verdict: {
+                passed: parsed.passed && requiredPassed,
+                overallScore: parsed.overallScore,
+                feedback: parsed.feedback,
+                details,
+            },
+        };
     }
 }

package/dist/collaboration/index.d.ts

@@ -2,8 +2,8 @@ export type { AcceptanceCriterion, VerificationContract, ContractCheckResult, }
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./contract.js";
 export { AgentPool } from "./pool.js";
 export type { AgentRole, IsolatedVerifierContext } from "./pool.js";
-export { ContractDrivenHarness } from "./harness.js";
-export type { ContractOutcome, ContractHarnessOptions, Violation, } from "./harness.js";
+export { CreatorVerifierBody, StructuredContractJudge } from "./harness.js";
+export type { ContractOutcome } from "./harness.js";
 export { HandoffBus } from "./handoff.js";
 export type { HandoffArtifact, ContractOutcomeInput } from "./handoff.js";
 export { CreatorVerifierMode, OrchestrationMode } from "./modes/creator-verifier.js";

package/dist/collaboration/index.js

@@ -1,8 +1,7 @@
 export { ContractBuilder, formatContractForSystemPrompt, contractToCriteriaStrings, } from "./contract.js";
 // AgentPool
 export { AgentPool } from "./pool.js";
-// ContractDrivenHarness
-export { ContractDrivenHarness } from "./harness.js";
+export { CreatorVerifierBody, StructuredContractJudge } from "./harness.js";
 // HandoffBus
 export { HandoffBus } from "./handoff.js";
 // Collaboration modes