@deepstrike/sdk 0.2.38 → 0.2.40

package/dist/runtime/session-log.d.ts

@@ -1,5 +1,11 @@
 import type { KernelPrimitive } from "./kernel-event-log.js";
 import type { ContentPart, ProviderReplay, ToolCall, ToolErrorKind } from "../types.js";
+import type { MemoryRecall, MemoryScope } from "../memory/protocols.js";
+import type { DurableAppendReceipt, KernelGenesisReceipt, KernelOperationGenesis, KernelTransaction } from "./kernel-transaction-log.js";
+export interface KernelTransactionEntry {
+    log_seq: number;
+    transaction: KernelTransaction;
+}
 export type RollbackReason = {
     kind: "fatal_tool_error";
     tool_name: string;
@@ -79,7 +85,6 @@ export type SessionEvent = {
     action?: "snip_compact" | "micro_compact" | "context_collapse" | "auto_compact";
     summary?: string;
     summary_tokens?: number;
-    archive_ref?: string;
     preserved_refs?: string[];
 } | {
     kind: "page_out";
@@ -88,6 +93,7 @@ export type SessionEvent = {
     summary?: string;
     tier_hint?: string;
     message_count?: number;
+    archive_ref?: string;
 } | {
     kind: "page_in";
     turn: number;
@@ -137,8 +143,11 @@ export type SessionEvent = {
     tool: string;
     reason: string;
 } | {
-    kind: "signal_disposed";
+    kind: "signal_delivery_disposed";
     turn: number;
+    operation_id: string;
+    delivery_id: string;
+    attempt: number;
     signal_id: string;
     disposition: string;
     queue_depth: number;
@@ -146,6 +155,22 @@ export type SessionEvent = {
     kind: "budget_exceeded";
     turn: number;
     budget: string;
+    operation_id: string;
+    reservation_id?: string;
+} | {
+    kind: "budget_usage_reported";
+    turn: number;
+    operation_id: string;
+    reservation_id: string;
+    tokens: number;
+    subagents: number;
+    rounds: number;
+} | {
+    kind: "operation_cancelled";
+    turn: number;
+    operation_id: string;
+    reason: "user" | "deadline" | "lease_lost" | "host_shutdown";
+    pending_call_ids: string[];
 } | {
     kind: "milestone_advanced";
     turn: number;
@@ -189,37 +214,49 @@ export type SessionEvent = {
 } | {
     kind: "memory_written";
     turn: number;
-    memory_id: string;
+    record_id: string;
+    scope: MemoryScope;
     memory_kind: string;
+    name: string;
     size_bytes: number;
 } | {
     kind: "memory_queried";
     turn: number;
-    query_context: string;
+    scope: MemoryScope;
+    query: string;
     requested_k: number;
     requires_async_response: boolean;
 } | {
     kind: "memory_validation_failed";
     turn: number;
-    memory_id: string;
+    record_id: string;
+    error: string;
+} | {
+    kind: "memory_write_failed";
+    turn: number;
+    record_id: string;
+    error: string;
+} | {
+    kind: "memory_query_failed";
+    turn: number;
+    scope: MemoryScope;
+    query: string;
     error: string;
 } | {
     kind: "memory_retrieval_result";
-    selected_memory_ids: string[];
-    selection_rationale: string;
+    hits: MemoryRecall[];
 } | {
     kind: "workflow_node_completed";
     turn: number;
     agent_id: string;
+    status: import("../types/agent.js").WorkflowNodeStatus;
     termination: string;
     /** W-1: result-borne control signals, persisted so resume replays control flow faithfully —
      *  a classifier re-prunes its rejected branches, a recorded loop stop is honored. */
     classify_branch?: string;
     tournament_winner?: string;
     loop_continue?: boolean;
-    /** W-1: the node's final output text — resume re-seeds the driver's outputs map from it so
-     *  post-resume reduce/judge/dependent nodes still see their dependencies' outputs. */
-    output?: string;
+    output?: import("../types.js").Message;
 } | {
     kind: "workflow_nodes_submitted";
     turn: number;
@@ -239,8 +276,7 @@ export type SessionEvent = {
 } | {
     kind: "workflow_completed";
     turn: number;
-    completed: string[];
-    failed: string[];
+    node_outcomes: import("../types/agent.js").KernelWorkflowNodeOutcome[];
     total_nodes: number;
 } | {
     kind: "run_terminal";
@@ -283,19 +319,35 @@ export interface SessionLog {
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
+    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
+    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
+    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
+    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
+    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
 }
 export declare class InMemorySessionLog implements SessionLog {
     private store;
+    private seqCounters;
+    private genesisStore;
+    private transactionStore;
+    private operationKey;
+    private nextSeq;
     append(sessionId: string, event: SessionEvent): Promise<number>;
     read(sessionId: string, fromSeq?: number, primitiveFilter?: KernelPrimitive): Promise<Array<{
         seq: number;
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
+    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
+    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
+    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
+    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
+    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
 }
 export declare class FileSessionLog implements SessionLog {
     private dir;
     private seqCounters;
+    private readonly appends;
     constructor(dir: string);
     private path;
     private nextSeq;
@@ -305,4 +357,11 @@ export declare class FileSessionLog implements SessionLog {
         event: SessionEvent;
     }>>;
     latestSeq(sessionId: string): Promise<number>;
+    appendKernelGenesis(sessionId: string, genesis: KernelOperationGenesis): Promise<KernelGenesisReceipt>;
+    readKernelGenesis(sessionId: string, operationId: string): Promise<KernelOperationGenesis | undefined>;
+    compareAndAppendKernelTransaction(sessionId: string, expectedTransactionHead: string, transaction: KernelTransaction): Promise<DurableAppendReceipt>;
+    readKernelTransactions(sessionId: string, operationId: string, fromStepSeq?: number): Promise<KernelTransactionEntry[]>;
+    kernelTransactionHead(sessionId: string, operationId: string): Promise<string | undefined>;
+    private appendRecord;
+    private readRecords;
 }

package/dist/runtime/session-log.js

@@ -1,15 +1,28 @@
-import { createWriteStream, createReadStream } from "node:fs";
-import { mkdir } from "node:fs/promises";
+import { createReadStream } from "node:fs";
+import { access, mkdir, open as openFile } from "node:fs/promises";
 import { join } from "node:path";
 import { createInterface } from "node:readline";
 import { primitiveForKind } from "./kernel-event-log.js";
+import { KeyedSerialExecutor } from "./reliability.js";
+import { KernelLogConflictError, KernelLogIntegrityError, verifyKernelOperationGenesis, verifyKernelTransaction, verifyKernelTransactionSuccessor, } from "./kernel-transaction-log.js";
 export class InMemorySessionLog {
     store = new Map();
+    seqCounters = new Map();
+    genesisStore = new Map();
+    transactionStore = new Map();
+    operationKey(sessionId, operationId) {
+        return `${sessionId}\u0000${operationId}`;
+    }
+    nextSeq(sessionId) {
+        const seq = this.seqCounters.get(sessionId) ?? 0;
+        this.seqCounters.set(sessionId, seq + 1);
+        return seq;
+    }
     async append(sessionId, event) {
         if (!this.store.has(sessionId))
             this.store.set(sessionId, []);
         const entries = this.store.get(sessionId);
-        const seq = entries.length;
+        const seq = this.nextSeq(sessionId);
         entries.push({ seq, event });
         return seq;
     }
@@ -24,8 +37,53 @@ export class InMemorySessionLog {
         });
     }
     async latestSeq(sessionId) {
-        const entries = this.store.get(sessionId);
-        return entries ? entries.length - 1 : -1;
+        return (this.seqCounters.get(sessionId) ?? 0) - 1;
+    }
+    async appendKernelGenesis(sessionId, genesis) {
+        verifyKernelOperationGenesis(genesis);
+        const operationKey = this.operationKey(sessionId, genesis.operation_id);
+        const existing = this.genesisStore.get(operationKey);
+        if (existing) {
+            if (existing.genesis.genesis_digest !== genesis.genesis_digest) {
+                throw new KernelLogConflictError("session already has a different kernel operation genesis");
+            }
+            return { log_seq: existing.log_seq, genesis_digest: genesis.genesis_digest };
+        }
+        const log_seq = this.nextSeq(sessionId);
+        this.genesisStore.set(operationKey, { log_seq, genesis });
+        return { log_seq, genesis_digest: genesis.genesis_digest };
+    }
+    async readKernelGenesis(sessionId, operationId) {
+        return this.genesisStore.get(this.operationKey(sessionId, operationId))?.genesis;
+    }
+    async compareAndAppendKernelTransaction(sessionId, expectedTransactionHead, transaction) {
+        verifyKernelTransaction(transaction);
+        const operationKey = this.operationKey(sessionId, transaction.operation_id);
+        const genesis = this.genesisStore.get(operationKey)?.genesis;
+        if (!genesis)
+            throw new KernelLogIntegrityError("kernel transaction requires a durable genesis");
+        if (transaction.operation_id !== genesis.operation_id) {
+            throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
+        }
+        const head = await this.kernelTransactionHead(sessionId, transaction.operation_id);
+        if (head !== expectedTransactionHead || transaction.previous_transaction_digest !== head) {
+            throw new KernelLogConflictError("kernel transaction head changed before compare-and-append");
+        }
+        const entries = this.transactionStore.get(operationKey) ?? [];
+        verifyKernelTransactionSuccessor(entries.at(-1)?.transaction, transaction);
+        const log_seq = this.nextSeq(sessionId);
+        entries.push({ log_seq, transaction });
+        this.transactionStore.set(operationKey, entries);
+        return { log_seq, transaction_digest: transaction.transaction_digest };
+    }
+    async readKernelTransactions(sessionId, operationId, fromStepSeq = 1) {
+        return (this.transactionStore.get(this.operationKey(sessionId, operationId)) ?? []).filter(entry => entry.transaction.step_seq >= fromStepSeq);
+    }
+    async kernelTransactionHead(sessionId, operationId) {
+        const operationKey = this.operationKey(sessionId, operationId);
+        const entries = this.transactionStore.get(operationKey) ?? [];
+        return entries.at(-1)?.transaction.transaction_digest
+            ?? this.genesisStore.get(operationKey)?.genesis.genesis_digest;
     }
 }
 // Single-writer per session. Safe for concurrent appends within one instance.
@@ -34,6 +92,7 @@ export class FileSessionLog {
     dir;
     // Lazy-initialized per-session counter. Avoids re-reading the file on every append.
     seqCounters = new Map();
+    appends = new KeyedSerialExecutor();
     constructor(dir) {
         this.dir = dir;
     }
@@ -42,54 +101,155 @@ export class FileSessionLog {
     }
     async nextSeq(sessionId) {
         if (!this.seqCounters.has(sessionId)) {
-            const existing = await this.read(sessionId);
-            this.seqCounters.set(sessionId, existing.length);
+            const existing = await this.readRecords(sessionId);
+            this.seqCounters.set(sessionId, existing.reduce((next, record) => Math.max(next, record.seq + 1), 0));
         }
         const seq = this.seqCounters.get(sessionId);
         this.seqCounters.set(sessionId, seq + 1);
         return seq;
     }
     async append(sessionId, event) {
-        await mkdir(this.dir, { recursive: true });
-        const seq = await this.nextSeq(sessionId);
-        await new Promise((resolve, reject) => {
-            const ws = createWriteStream(this.path(sessionId), { flags: "a" });
-            ws.write(JSON.stringify({ seq, event }) + "\n", err => {
-                if (err)
-                    reject(err);
-                else
-                    resolve();
-            });
-            ws.end();
+        return this.appends.run(sessionId, async () => {
+            const seq = await this.nextSeq(sessionId);
+            await this.appendRecord(sessionId, { seq, event });
+            return seq;
         });
-        return seq;
     }
     async read(sessionId, fromSeq = 0, primitiveFilter) {
         const results = [];
+        for (const record of await this.readRecords(sessionId)) {
+            if (!("event" in record) || record.seq < fromSeq)
+                continue;
+            if (primitiveFilter && primitiveForKind(record.event.kind) !== primitiveFilter)
+                continue;
+            results.push({ seq: record.seq, event: record.event });
+        }
+        return results;
+    }
+    async latestSeq(sessionId) {
+        const records = await this.readRecords(sessionId);
+        return records.reduce((latest, record) => Math.max(latest, record.seq), -1);
+    }
+    async appendKernelGenesis(sessionId, genesis) {
+        return this.appends.run(sessionId, async () => {
+            verifyKernelOperationGenesis(genesis);
+            const existing = (await this.readRecords(sessionId)).find((record) => "record_type" in record
+                && record.record_type === "kernel_genesis"
+                && record.genesis.operation_id === genesis.operation_id);
+            if (existing) {
+                if (existing.genesis.genesis_digest !== genesis.genesis_digest) {
+                    throw new KernelLogConflictError("session already has a different kernel operation genesis");
+                }
+                return { log_seq: existing.seq, genesis_digest: genesis.genesis_digest };
+            }
+            const log_seq = await this.nextSeq(sessionId);
+            await this.appendRecord(sessionId, {
+                seq: log_seq,
+                record_type: "kernel_genesis",
+                genesis,
+            });
+            return { log_seq, genesis_digest: genesis.genesis_digest };
+        });
+    }
+    async readKernelGenesis(sessionId, operationId) {
+        const record = (await this.readRecords(sessionId)).find((entry) => "record_type" in entry
+            && entry.record_type === "kernel_genesis"
+            && entry.genesis.operation_id === operationId);
+        return record?.genesis;
+    }
+    async compareAndAppendKernelTransaction(sessionId, expectedTransactionHead, transaction) {
+        return this.appends.run(sessionId, async () => {
+            verifyKernelTransaction(transaction);
+            const records = await this.readRecords(sessionId);
+            const genesisRecord = records.find((record) => "record_type" in record
+                && record.record_type === "kernel_genesis"
+                && record.genesis.operation_id === transaction.operation_id);
+            if (!genesisRecord)
+                throw new KernelLogIntegrityError("kernel transaction requires a durable genesis");
+            if (transaction.operation_id !== genesisRecord.genesis.operation_id) {
+                throw new KernelLogIntegrityError("kernel transaction operation_id does not match genesis");
+            }
+            const transactions = records.filter((record) => "record_type" in record
+                && record.record_type === "kernel_transaction"
+                && record.transaction.operation_id === transaction.operation_id);
+            const head = transactions.at(-1)?.transaction.transaction_digest
+                ?? genesisRecord.genesis.genesis_digest;
+            if (head !== expectedTransactionHead || transaction.previous_transaction_digest !== head) {
+                throw new KernelLogConflictError("kernel transaction head changed before compare-and-append");
+            }
+            verifyKernelTransactionSuccessor(transactions.at(-1)?.transaction, transaction);
+            const log_seq = await this.nextSeq(sessionId);
+            await this.appendRecord(sessionId, {
+                seq: log_seq,
+                record_type: "kernel_transaction",
+                transaction,
+            });
+            return { log_seq, transaction_digest: transaction.transaction_digest };
+        });
+    }
+    async readKernelTransactions(sessionId, operationId, fromStepSeq = 1) {
+        return (await this.readRecords(sessionId))
+            .filter((record) => "record_type" in record
+            && record.record_type === "kernel_transaction"
+            && record.transaction.operation_id === operationId
+            && record.transaction.step_seq >= fromStepSeq)
+            .map(record => ({ log_seq: record.seq, transaction: record.transaction }));
+    }
+    async kernelTransactionHead(sessionId, operationId) {
+        const records = await this.readRecords(sessionId);
+        const transaction = records.filter((record) => "record_type" in record
+            && record.record_type === "kernel_transaction"
+            && record.transaction.operation_id === operationId).at(-1);
+        if (transaction)
+            return transaction.transaction.transaction_digest;
+        return records.find((record) => "record_type" in record
+            && record.record_type === "kernel_genesis"
+            && record.genesis.operation_id === operationId)?.genesis.genesis_digest;
+    }
+    async appendRecord(sessionId, record) {
+        await mkdir(this.dir, { recursive: true });
+        const path = this.path(sessionId);
+        let isNewFile = false;
+        try {
+            await access(path);
+        }
+        catch {
+            isNewFile = true;
+        }
+        const file = await openFile(path, "a");
+        try {
+            await file.appendFile(`${JSON.stringify(record)}\n`, "utf8");
+            await file.sync();
+        }
+        finally {
+            await file.close();
+        }
+        if (isNewFile) {
+            const directory = await openFile(this.dir, "r");
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+        }
+    }
+    async readRecords(sessionId) {
+        const records = [];
         try {
             const rl = createInterface({
                 input: createReadStream(this.path(sessionId)),
                 crlfDelay: Infinity,
             });
             for await (const line of rl) {
-                if (!line.trim())
-                    continue;
-                const entry = JSON.parse(line);
-                if (entry.seq >= fromSeq) {
-                    if (primitiveFilter && primitiveForKind(entry.event.kind) !== primitiveFilter)
-                        continue;
-                    results.push(entry);
-                }
+                if (line.trim())
+                    records.push(JSON.parse(line));
             }
         }
         catch (err) {
             if (err.code !== "ENOENT")
                 throw err;
         }
-        return results;
-    }
-    async latestSeq(sessionId) {
-        const entries = await this.read(sessionId);
-        return entries.length - 1;
+        return records;
     }
 }

package/dist/runtime/session-repair.d.ts

@@ -1,5 +1,6 @@
-import type { ProviderReplay, ToolCall } from "../types.js";
+import type { Message, ProviderReplay, ToolCall } from "../types.js";
 import type { SessionEvent } from "./session-log.js";
+import type { WorkflowNodeStatus } from "../types/agent.js";
 export { REPLAY_CONTENT_MAX_BYTES as RECOVERY_CONTENT_MAX_BYTES } from "./replay-sanitize.js";
 /**
  * Normalize a persisted llm_completed event for recovery.
@@ -46,33 +47,36 @@ export declare function buildRunTerminalEvent(input: {
 export declare function buildWorkflowNodeCompletedEvent(input: {
     turn: number;
     agentId: string;
+    status: WorkflowNodeStatus;
     termination: string;
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: string;
+    output?: Message;
 }): Extract<SessionEvent, {
     kind: "workflow_node_completed";
 }>;
 /** One recovered node completion: the agent id plus its persisted control signals and output. */
-export interface RecoveredNodeCompletion {
+export interface RecoveredNodeOutcome {
     agentId: string;
+    status: WorkflowNodeStatus;
+    termination: string;
     classifyBranch?: string;
     tournamentWinner?: string;
     loopContinue?: boolean;
-    output?: string;
+    output?: Message;
 }
 /**
  * Recover completed workflow node records from a session event stream. Scans for
  * workflow_node_completed events with termination "completed" and returns them WITH their
  * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
- * `resumed_results` so a classifier re-prunes and a loop stop is honored, and re-seeds the
+ * `resumed_outcomes` so a classifier re-prunes and a loop stop is honored, and re-seeds the
  * driver's outputs map from the persisted output text.
  */
-export declare function recoverCompletedWorkflowNodes(events: Array<{
+export declare function recoverWorkflowNodeOutcomes(events: Array<{
     seq: number;
     event: SessionEvent;
-}>): RecoveredNodeCompletion[];
+}>): RecoveredNodeOutcome[];
 /** R3-1: build workflow_nodes_submitted for persistence after a runtime submission, so resume can
  *  re-apply it. `nodes` is the kernel-shape (snake_case) submitted node array. */
 export declare function buildWorkflowNodesSubmittedEvent(input: {

package/dist/runtime/session-repair.js

@@ -60,6 +60,7 @@ export function buildWorkflowNodeCompletedEvent(input) {
         kind: "workflow_node_completed",
         turn: input.turn,
         agent_id: input.agentId,
+        status: input.status,
         termination: input.termination,
         ...(input.classifyBranch !== undefined ? { classify_branch: input.classifyBranch } : {}),
         ...(input.tournamentWinner !== undefined ? { tournament_winner: input.tournamentWinner } : {}),
@@ -71,15 +72,17 @@ export function buildWorkflowNodeCompletedEvent(input) {
  * Recover completed workflow node records from a session event stream. Scans for
  * workflow_node_completed events with termination "completed" and returns them WITH their
  * result-borne control signals (W-1) — resumeWorkflow lowers these to the kernel's
- * `resumed_results` so a classifier re-prunes and a loop stop is honored, and re-seeds the
+ * `resumed_outcomes` so a classifier re-prunes and a loop stop is honored, and re-seeds the
  * driver's outputs map from the persisted output text.
  */
-export function recoverCompletedWorkflowNodes(events) {
+export function recoverWorkflowNodeOutcomes(events) {
     const completed = [];
     for (const { event } of events) {
-        if (event.kind === "workflow_node_completed" && event.termination === "completed") {
+        if (event.kind === "workflow_node_completed") {
             completed.push({
                 agentId: event.agent_id,
+                status: event.status,
+                termination: event.termination,
                 ...(event.classify_branch !== undefined ? { classifyBranch: event.classify_branch } : {}),
                 ...(event.tournament_winner !== undefined ? { tournamentWinner: event.tournament_winner } : {}),
                 ...(event.loop_continue !== undefined ? { loopContinue: event.loop_continue } : {}),
@@ -111,11 +114,11 @@ export function recoverSubmittedWorkflowNodes(events) {
         if (event.kind === "workflow_nodes_submitted") {
             submissions.push(event.nodes);
             submitters.push(event.submitter_agent_id);
-            // Absent on legacy logs → order-only replay (bases array stays parallel-short only
-            // if ALL records carry it; a mixed log degrades to order-only for safety).
-            if (event.base_index !== undefined)
-                bases.push(event.base_index);
+            if (event.base_index === undefined) {
+                throw new Error("workflow_nodes_submitted is missing required base_index");
+            }
+            bases.push(event.base_index);
         }
     }
-    return { submissions, bases: bases.length === submissions.length ? bases : [], submitters };
+    return { submissions, bases, submitters };
 }

package/dist/runtime/sub-agent-orchestrator.d.ts

@@ -1,7 +1,8 @@
 import type { StreamEvent } from "../types.js";
-import type { AgentRunSpec, AgentProcessChangedObservation, SubAgentResult } from "../types/agent.js";
+import type { AgentRunSpec, AgentProcessChangedObservation, LoopResult, SubAgentResult } from "../types/agent.js";
 import type { RuntimeOptions } from "./runner.js";
 import type { SessionLog } from "./session-log.js";
+import type { AttemptOutcome } from "../harness/harness.js";
 export interface SubAgentRunContext {
     parentOpts: RuntimeOptions;
     parentSessionId: string;
@@ -27,6 +28,8 @@ export interface SubAgentRunContext {
      *  `InterruptNow` → `AgentPreempted`), the orchestrator interrupts the child runner, cancelling its
      *  in-flight LLM call. */
     abortSignal?: AbortSignal;
+    /** AttemptLoop carry material; injected through the child's journaled signal channel. */
+    contextInput?: string;
 }
 /** M1/G3 intelligence routing: resolve the provider for a sub-agent from its spec's `modelHint`.
  *  Falls back to the parent provider when there is no hint or no `providerFor` hook resolves it. */
@@ -42,5 +45,6 @@ export declare class SubAgentOrchestrator {
     run(ctx: SubAgentRunContext): Promise<SubAgentResult>;
 }
 export declare const defaultSubAgentOrchestrator: SubAgentOrchestrator;
+export declare function attemptOutcomeToLoopResult(outcome: AttemptOutcome): LoopResult;
 /** Kernel spawn without an active parent run loop (harness / coordinator use). */
-export declare function spawnStandalone(parentOpts: RuntimeOptions, parentSessionId: string, spec: AgentRunSpec, orchestrator?: SubAgentOrchestrator): Promise<SubAgentResult>;
+export declare function spawnStandalone(parentOpts: RuntimeOptions, parentSessionId: string, spec: AgentRunSpec, orchestrator?: SubAgentOrchestrator, contextInput?: string): Promise<SubAgentResult>;