@deepstrike/sdk 0.2.39 → 0.2.40

package/dist/collaboration/modes/creator-verifier.js

@@ -1,4 +1,6 @@
-import { ContractDrivenHarness } from "../harness.js";
+import { CreatorVerifierBody, StructuredContractJudge } from "../harness.js";
+import { HandoffBus } from "../handoff.js";
+import { AttemptLoop } from "../../harness/harness.js";
 /**
  * CreatorVerifierMode — the simplest multi-agent collaboration pattern.
  *
@@ -31,14 +33,48 @@ export class CreatorVerifierMode {
     async run(contract) {
         this._total++;
         this.pool.ensureCoordinator(this.options.coordinatorSessionId);
-        const harness = new ContractDrivenHarness(this.pool, contract, {
-            maxAttempts: this.options.maxAttempts ?? 3,
+        const loop = new AttemptLoop({
+            body: new CreatorVerifierBody(this.pool, contract),
+            judge: new StructuredContractJudge(this.pool, contract),
+            stop: { maxAttempts: this.options.maxAttempts ?? 3 },
         });
-        const outcome = await harness.run();
-        if (!outcome.success) {
+        const attempt = await loop.run({
+            sessionId: crypto.randomUUID(),
+            goal: contract.goal,
+            criteria: contract.acceptance.map(criterion => ({
+                id: criterion.id,
+                text: criterion.text,
+                required: criterion.required,
+                weight: criterion.weight,
+                machineCheckable: criterion.machineCheckable,
+            })),
+        });
+        const checkResults = attempt.verdict?.details.map(detail => ({
+            criterionId: detail.criterion,
+            passed: detail.passed,
+            evidence: detail.feedback,
+        })) ?? [];
+        const success = attempt.outcome === "passed";
+        if (!success) {
             this._failed++;
         }
-        return outcome;
+        const blockedOn = success
+            ? []
+            : checkResults.filter(result => !result.passed).map(result => `[${result.criterionId}] ${result.evidence ?? "verification failed"}`);
+        return {
+            success,
+            artifact: attempt.result,
+            checkResults,
+            attemptsUsed: attempt.attempts,
+            totalTokensConsumed: attempt.totalTokens,
+            handoff: HandoffBus.fromContractOutcome({
+                contract,
+                checkResults,
+                artifact: attempt.result,
+                success,
+                ...(blockedOn.length ? { blockedOn } : {}),
+            }),
+        };
     }
     /** Aggregate drift metrics across all runs through this mode instance. */
     getMetrics() {

package/dist/collaboration/pool.d.ts

@@ -12,6 +12,12 @@ export interface CoordinatorConfig {
     opts: RuntimeOptions;
     sessionId: string;
 }
+export interface RoleExecutionInput {
+    sessionId: string;
+    goal: string;
+    contextInput?: string;
+    verificationContractId?: string;
+}
 export declare class AgentPool {
     private runners;
     private coordinator?;
@@ -31,6 +37,8 @@ export declare class AgentPool {
      * Maps legacy pool roles to kernel roles (executor → implement, etc.).
      */
     spawn(role: AgentRole | KernelAgentRole, goal: string, extra?: Partial<Omit<AgentRunSpec, "identity" | "role" | "goal">>): Promise<SubAgentResult>;
+    /** Execute a role in a caller-owned session so AttemptLoop can retain transcript across attempts. */
+    execute(role: AgentRole, input: RoleExecutionInput): Promise<SubAgentResult>;
     verify(ctx: IsolatedVerifierContext): Promise<string>;
     orchestrate(goal: string): Promise<string>;
 }

package/dist/collaboration/pool.js

@@ -62,6 +62,49 @@ export class AgentPool {
         };
         return spawnStandalone(this.coordinator.opts, this.coordinator.sessionId, spec);
     }
+    /** Execute a role in a caller-owned session so AttemptLoop can retain transcript across attempts. */
+    async execute(role, input) {
+        if (this.coordinator) {
+            const kernelRole = KERNEL_ROLE_MAP[role];
+            const spec = {
+                identity: agentIdentitySub(`${kernelRole}-${input.sessionId}`, input.sessionId, this.coordinator.sessionId),
+                role: kernelRole,
+                goal: input.goal,
+                ...(input.verificationContractId
+                    ? { verificationContractId: input.verificationContractId }
+                    : {}),
+            };
+            return spawnStandalone(this.coordinator.opts, this.coordinator.sessionId, spec, undefined, input.contextInput);
+        }
+        const runner = this.get(role);
+        if (input.contextInput)
+            runner.injectNote(input.contextInput);
+        let finalText = "";
+        let turnsUsed = 0;
+        let totalTokensUsed = 0;
+        let termination = "error";
+        for await (const event of runner.run({ sessionId: input.sessionId, goal: input.goal })) {
+            if (event.type === "text_delta")
+                finalText += event.delta;
+            if (event.type === "done") {
+                const done = event;
+                turnsUsed = done.iterations;
+                totalTokensUsed = done.totalTokens;
+                termination = done.status;
+            }
+        }
+        return {
+            agentId: `${KERNEL_ROLE_MAP[role]}-${input.sessionId}`,
+            result: {
+                termination,
+                turnsUsed,
+                totalTokensUsed,
+                ...(finalText
+                    ? { finalMessage: { role: "assistant", content: finalText, toolCalls: [] } }
+                    : {}),
+            },
+        };
+    }
     async verify(ctx) {
         const contractBlock = formatContractForSystemPrompt(ctx.contract);
         const auditGoal = [
@@ -71,9 +114,19 @@ export class AgentPool {
             ctx.artifact, "",
             "---", "",
             "Audit the artifact against every criterion in the contract above.",
-            "For each criterion, state whether it PASSED or FAILED and cite specific evidence.",
-            "List any anti-patterns you detected.",
-            "Conclude with an overall PASS or FAIL verdict.",
+            "Return only one JSON object with this exact shape:",
+            JSON.stringify({
+                passed: true,
+                overall_score: 1,
+                feedback: "overall verification feedback",
+                details: ctx.contract.acceptance.map(criterion => ({
+                    criterion: criterion.id,
+                    passed: true,
+                    score: 1,
+                    feedback: "specific evidence",
+                })),
+            }, null, 2),
+            "Every contract criterion id must appear exactly once in details. Do not emit prose or markdown.",
         ].join("\n");
         if (this.coordinator) {
             const result = await this.spawn("verify", auditGoal, {

package/dist/harness/harness.d.ts

@@ -1,49 +1,27 @@
 import type { RuntimeRunner } from "../runtime/runner.js";
-import { collectText } from "../runtime/runner.js";
-import type { StreamEvent } from "../types.js";
-export interface Criterion {
-    text: string;
-    required: boolean;
-    weight?: number;
-    /** I3.3 (A4): optional stable identifier from the host's contract layer (e.g. an
-     *  `acceptance[].id` field). The harness does not interpret it; it just threads it through to
-     *  `verdictFn` so the host can dispatch per-criterion deterministic checks by id. */
-    id?: string;
-    /** I3.3 (A4): host hint — when true, the host has a deterministic check for this criterion
-     *  and would short-circuit the LLM eval. The harness still defers to the host's `verdictFn`
-     *  for the actual decision; this is purely a transparency field on the request. */
-    machineCheckable?: boolean;
-}
-export interface CriterionResult {
-    criterion: string;
-    passed: boolean;
-    score: number;
-    feedback: string;
-}
-export interface HarnessRequest {
+import type { SessionEvent } from "../runtime/session-log.js";
+import type { WorkflowNodeSpec } from "../types/agent.js";
+import type { Criterion, Verdict } from "../runtime/eval.js";
+import type { AttemptJudge, JudgeResult } from "./judge.js";
+export type { Criterion, Verdict } from "../runtime/eval.js";
+export interface AttemptRequest {
+    sessionId?: string;
     goal: string;
     criteria?: Criterion[];
     extensions?: Record<string, unknown>;
+    /** Parent transcript inherited by the first attempt only. */
+    inheritEvents?: Array<{
+        seq: number;
+        event: SessionEvent;
+    }>;
 }
-export interface HarnessOutcome {
-    result: string;
-    passed: boolean;
-    iterations: number;
-    totalTokens: number;
-    status: string;
-    overallScore?: number;
-    feedback?: string;
-    details?: CriterionResult[];
-    /** R3-1: nodes the agent submitted via `submit_workflow_nodes` while running under the harness. */
-    submittedNodes?: import("../types/agent.js").WorkflowNodeSpec[];
-}
-export interface Verdict {
-    passed: boolean;
-    overallScore: number;
-    feedback: string;
-    details: CriterionResult[];
+export interface AttemptBodyContext extends AttemptRequest {
+    sessionId: string;
+    attempt: number;
+    /** Carry material delivered as context, never folded into `goal` by the default policy. */
+    contextInput?: string;
 }
-export type HarnessEvent = {
+export type AttemptProgressEvent = {
     type: "token";
     text: string;
 } | {
@@ -67,72 +45,94 @@ export type HarnessEvent = {
     isError: boolean;
 } | {
     type: "workflow_nodes_submitted";
-    nodes: import("../types/agent.js").WorkflowNodeSpec[];
-} | {
-    type: "supervising";
+    nodes: WorkflowNodeSpec[];
 } | {
-    type: "revising";
-    verdict: Verdict;
-} | {
-    type: "done";
-    verdict: Verdict;
-    iterations: number;
-    totalTokens: number;
-    status: string;
-} | {
-    type: "max_attempts_reached";
+    type: "body_error";
+    message: string;
 };
-export interface QualityGate {
-    evaluate(request: HarnessRequest, outcome: HarnessOutcome): Promise<boolean>;
+export interface AttemptBodyTerminal {
+    type: "body_done";
+    runStatus: string;
+    result: string;
+    turns: number;
+    totalTokens: number;
+    submittedNodes?: WorkflowNodeSpec[];
 }
-export declare class SinglePassHarness {
-    private runner;
-    constructor(runner: RuntimeRunner);
-    run(request: HarnessRequest): Promise<HarnessOutcome>;
-    stream(request: HarnessRequest): AsyncIterable<StreamEvent>;
+export type AttemptBodyEvent = AttemptProgressEvent | AttemptBodyTerminal;
+export interface AttemptBody {
+    run(context: AttemptBodyContext): AsyncIterable<AttemptBodyEvent>;
 }
-/**
- * @deprecated I3.4 (A1): prefer {@link HarnessLoop} with `verdictFn` for host-defined judgment.
- * `EvalLoopHarness.stream()` does NOT honor the `gate` passed via `request.gate` (only `.run()`
- * does), which is a long-standing footgun for streaming hosts. `HarnessLoop` runs the eval loop
- * uniformly across both stream and run, accepts an optional `verdictFn` for short-circuiting the
- * built-in LLM eval, and otherwise mirrors `EvalLoopHarness`'s behavior. New code should use
- * `HarnessLoop`; existing call sites can migrate by switching the class + (if applicable)
- * passing a `verdictFn` for the same gate logic. Slated for removal in a future major. */
-export declare class EvalLoopHarness {
-    private runner;
-    private gate;
-    private maxAttempts;
-    constructor(runner: RuntimeRunner, gate: QualityGate, maxAttempts?: number);
-    run(request: HarnessRequest): Promise<HarnessOutcome>;
-    stream(request: HarnessRequest): AsyncIterable<StreamEvent>;
+/** Adapts RuntimeRunner to the body slot without giving the loop knowledge of kernel events. */
+export declare class RuntimeAttemptBody implements AttemptBody {
+    private readonly runner;
+    constructor(runner: RuntimeRunner);
+    run(context: AttemptBodyContext): AsyncIterable<AttemptBodyEvent>;
 }
-/** I3.2 (A2/A3): host-supplied judgment for each attempt's result. Returning a `Verdict` short-
- *  circuits the built-in LLM eval (no `evalProvider.stream` call); returning `undefined` defers to
- *  the built-in eval (enables hybrid judgment: machine-checkable items deterministic, subjective
- *  items LLM). Pure addition — when not set, HarnessLoop.stream() is byte-equivalent to its prior
- *  behavior. The closure owns its own context (doc reader, deterministic checks, etc.); the SDK
- *  is intentionally agnostic about what it inspects. */
-export type VerdictFn = (ctx: {
+export type VerdictFn = (context: {
     goal: string;
     criteria: Criterion[];
     attempt: number;
     result: string;
 }) => Verdict | undefined | Promise<Verdict | undefined>;
-export interface HarnessLoopOptions {
-    maxAttempts?: number;
-    skillDir?: string;
-    verdictFn?: VerdictFn;
+export interface PreparedAttempt {
+    sessionId: string;
+    goal: string;
+    contextInput?: string;
+}
+export type CarryPolicy = (context: {
+    rootSessionId: string;
+    goal: string;
+    attempt: number;
+    previousVerdict?: Verdict;
+}) => PreparedAttempt | Promise<PreparedAttempt>;
+/** Default: retain the transcript and deliver judge feedback through the runner's signal input. */
+export declare const continueSession: CarryPolicy;
+/** Explicit isolation policy preserving the old fresh-session + goal-feedback behavior. */
+export declare const freshWithFeedback: CarryPolicy;
+export declare function freshWithDigest(digest: (verdict: Verdict, attempt: number) => string | Promise<string>): CarryPolicy;
+export interface StopPolicy {
+    maxAttempts: number;
+    maxTotalTokens?: number;
+    /** Useful for one-shot gates; retry loops normally leave this false. */
+    stopOnFailedVerdict?: boolean;
+}
+export type AttemptOutcomeKind = "passed" | "failed_judge" | "exhausted" | "run_error";
+export interface AttemptOutcome {
+    outcome: AttemptOutcomeKind;
+    runStatus: string;
+    verdict?: Verdict;
+    result: string;
+    attempts: number;
+    turns: number;
+    totalTokens: number;
+    submittedNodes?: WorkflowNodeSpec[];
+}
+export type AttemptLoopEvent = AttemptProgressEvent | {
+    type: "judging";
+    attempt: number;
+} | {
+    type: "retrying";
+    attempt: number;
+    verdict: Verdict;
+} | {
+    type: "completed";
+    outcome: AttemptOutcome;
+};
+export interface AttemptLoopOptions {
+    body: AttemptBody;
+    judge: AttemptJudge;
+    carry?: CarryPolicy;
+    stop: StopPolicy;
+    onPass?: (context: {
+        outcome: AttemptOutcome;
+        judgeResult: JudgeResult;
+    }) => Promise<void> | void;
 }
-export declare class HarnessLoop {
-    private runner;
-    private maxAttempts;
-    private skillDir?;
-    /** How each attempt is judged. Hybrid (host verdictFn → LLM eval) when a verdictFn is supplied,
-     *  otherwise the built-in LLM eval. The loop just calls `this.judge.judge(...)`. */
-    private judge;
-    constructor(runner: RuntimeRunner, evalProvider: import("../types.js").LLMProvider, options?: HarnessLoopOptions);
-    run(request: HarnessRequest): Promise<HarnessOutcome>;
-    stream(request: HarnessRequest): AsyncIterable<HarnessEvent>;
+/** One attempt engine. Body, judgment, carry, and stopping are independent policy slots. */
+export declare class AttemptLoop {
+    private readonly options;
+    private readonly carry;
+    constructor(options: AttemptLoopOptions);
+    run(request: AttemptRequest): Promise<AttemptOutcome>;
+    stream(request: AttemptRequest): AsyncIterable<AttemptLoopEvent>;
 }
-export { collectText };