@deepstrike/sdk 0.2.35 → 0.2.37

package/README.md

@@ -187,7 +187,7 @@ The mechanisms above are not internal refactors — they change what you can bui
 Tool calls, spawns, compression, and signals pass through one kernel gate with an explicit lifecycle (Ready / Running / Blocked / Suspended). You implement I/O; the kernel decides *when* and *whether*. Node, Python, and Rust share the same decision path, so `wake(sessionId)` and cross-language tooling see consistent behavior.
 
 **Longer, sturdier sessions (Layer-1 spool + semantic page-out)**  
-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` and satisfies `page_in_requested` on the way back in. Long tasks survive token pressure instead of failing mid-run.
+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.
@@ -311,7 +311,7 @@ The kernel renders context as four LLM API slots — only **history** is compres
 | Slot | Source | Role |
 |------|--------|------|
 | `systemStable` | system partition | Identity, rules — never changes within a run |
-| `systemKnowledge` | knowledge partition | Preloaded memory, skill defs — low frequency |
+| `systemKnowledge` | knowledge partition | Skill bodies, `initialMemory`, host-pinned durable refs — keyed, boundary-evicted, budgeted |
 | `turns[0]` | `task_state` + signals | Goal, plan, progress, compression log, runtime signals |
 | `turns[1..N]` | history | Conversation transcript |
 
@@ -495,15 +495,15 @@ effort: 1
 2. Express each as a concise bullet
 ```
 
+A loaded skill's body is pinned into the durable `knowledge` slot (keyed `skill:<name>`) and its `allowed_tools` narrow the exposed toolset. Activation is **not** permanent: `runner.deactivateSkill(name)` re-widens the toolset at the next provider call and unpins the body at the next boundary, and `skillLeaseTurns` auto-deactivates every skill N turns after it loads — so a long multi-phase run doesn't monotonically accumulate early-phase skills. There is deliberately no model-facing unload (deactivation is host-driven only).
+
 ---
 
 ## Knowledge
 
-Implement `KnowledgeSource` to connect any RAG system. The kernel injects a `knowledge` meta-tool that the LLM calls on demand. Runtime retrieval results land in **history** as tool results.
-
-To inject durable knowledge at startup (Slot 2, cacheable on Anthropic), use `initialMemory` or `runner.pushKnowledge()`.
+Implement `KnowledgeSource` to connect any RAG system. The kernel injects a `knowledge` meta-tool that the LLM calls on demand. Runtime retrieval results land in **history** as tool results (single-use fact content that decays with the compression pyramid) — not in the durable `knowledge` partition.
 
-Before tool execution the kernel may emit `page_in_requested`; the SDK satisfies it from `DreamStore`, `KnowledgeSource`, and a local semantic page-out cache, then feeds `page_in` back to the kernel.
+To inject durable knowledge at startup (Slot 2, cacheable on Anthropic), use `initialMemory` or `runner.pushKnowledge(content, tokens?, { key, pinned })`. A **keyed** entry upserts on a repeated key and can be removed with `runner.removeKnowledge(key)`; both take effect at the next compaction/renewal boundary (where the `system[1]` cache prefix is rewritten anyway). Set `knowledgeBudgetRatio` (default 0.25 of `maxTokens`, 0 disables) to cap the partition — over budget, the oldest unpinned, non-skill entries are evicted at boundaries while `pinned: true` entries survive.
 
 ```typescript
 const runner = new RuntimeRunner({

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 export { runAgent, runFanout } from "./runtime/facade.js";
+export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
+export type { LoopSpec, LoopOutcome } from "./runtime/loop-driver.js";
 export type { RunAgentOptions, RunFanoutOptions } from "./runtime/facade.js";
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 export type { RuntimeOptions } from "./runtime/runner.js";

package/dist/index.js

@@ -12,6 +12,8 @@
 // ╚══════════════════════════════════════════════════════════════════════════╝
 // ── Start here: the canonical entry points ─────────────────────────────────
 export { runAgent, runFanout } from "./runtime/facade.js";
+// ③ dynamic loop agents: self-pacing rounds over the kernel pacing trap.
+export { runLoop, LoopDriver, foldLoopState } from "./runtime/loop-driver.js";
 export { RuntimeRunner, collectText } from "./runtime/runner.js";
 // ── Execution plane + session log (the defaults) ────────────────────────────
 export { LocalExecutionPlane } from "./runtime/execution-plane.js";

package/dist/os/public.d.ts

@@ -1,6 +1,6 @@
 export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "../runtime/os-profile.js";
 export type { NativeOsProfile, OsProfileId } from "../runtime/os-profile.js";
-export { rebuildOsSnapshotFromSessionEvents, sessionLogHasRequiredCategories } from "../runtime/os-snapshot.js";
+export { rebuildOsSnapshotFromSessionEvents } from "../runtime/os-snapshot.js";
 export type { OsSnapshot } from "../runtime/os-snapshot.js";
 export type { KernelEventCategory } from "../runtime/kernel-event-log.js";
 export { KernelPrimitivesDashboard } from "../runtime/kernel-primitives-dashboard.js";

package/dist/os/public.js

@@ -1,7 +1,7 @@
 // `@deepstrike/sdk/os` — Agent-OS diagnostics, profiles, signal/permission machinery, replay-testing,
 // and the scheduler/quota/policy types referenced by advanced `RuntimeOptions` fields.
 export { DEFAULT_NATIVE_ATTENTION_POLICY, DEFAULT_NATIVE_GOVERNANCE_POLICY, assertNativeProfile, osProfile, } from "../runtime/os-profile.js";
-export { rebuildOsSnapshotFromSessionEvents, sessionLogHasRequiredCategories } from "../runtime/os-snapshot.js";
+export { rebuildOsSnapshotFromSessionEvents } from "../runtime/os-snapshot.js";
 export { KernelPrimitivesDashboard } from "../runtime/kernel-primitives-dashboard.js";
 // Signals + SDK-side permissions.
 export { ScheduledPrompt } from "../signals/scheduled.js";

package/dist/runtime/facade.js

@@ -15,6 +15,7 @@
 import { RuntimeRunner, collectText } from "./runner.js";
 import { LocalExecutionPlane } from "./execution-plane.js";
 import { InMemorySessionLog } from "./session-log.js";
+import { fanoutSynthesize } from "../types/agent.js";
 /**
  * Run a single agent to completion and return its final text — `RuntimeRunner` + `run` + `collectText`
  * in one call. Register tools by passing `tools`; everything else has a working default.
@@ -46,17 +47,16 @@ export async function runFanout(opts) {
         maxTokens: opts.maxTokens ?? 32_000,
         ...(opts.maxTurns !== undefined ? { maxTurns: opts.maxTurns } : {}),
     });
-    const workerRole = opts.workerRole ?? "explore";
-    const spec = {
-        nodes: [
-            ...opts.tasks.map(task => ({ task, role: workerRole })),
-            {
-                task: opts.synthesize,
-                role: opts.synthesisRole ?? "plan",
-                dependsOn: opts.tasks.map((_, i) => i),
-            },
-        ],
-    };
+    // W-N8: build the spec via the ONE fanout template (it pins the pattern's isolation /
+    // context-inheritance choices — read-only system-only workers, full-context synthesizer — which
+    // this facade used to silently drop), then apply the caller's role overrides on top.
+    const spec = fanoutSynthesize(opts.tasks, opts.synthesize);
+    if (opts.workerRole) {
+        for (const node of spec.nodes.slice(0, opts.tasks.length))
+            node.role = opts.workerRole;
+    }
+    if (opts.synthesisRole)
+        spec.nodes[spec.nodes.length - 1].role = opts.synthesisRole;
     const outcome = await runner.runWorkflow(spec, opts.sessionId ? { sessionId: opts.sessionId } : undefined);
     // The synthesis node is the last spec node; the kernel ids nodes `wf-node{index}`. Prefer that id,
     // but fall back to the last completed node's output so a kernel id-scheme change can't silently

package/dist/runtime/kernel-event-log.d.ts

@@ -3,12 +3,6 @@ import type { SessionEvent } from "./session-log.js";
 /** Agent OS kernel event category (Phase 5). */
 export type KernelEventCategory = "syscall" | "sched" | "mm" | "proc" | "ipc";
 export declare function categoryForKind(kind: string): KernelEventCategory;
-export declare function withCategory<T extends {
-    kind: string;
-}>(event: T): T & {
-    category: KernelEventCategory;
-    primitive: KernelPrimitive;
-};
 type CompressionAction = Extract<SessionEvent, {
     kind: "compressed";
 }>["action"];

package/dist/runtime/kernel-event-log.js

@@ -22,33 +22,16 @@ export function categoryForKind(kind) {
             return "sched";
     }
 }
-export function withCategory(event) {
-    const category = categoryForKind(event.kind);
-    return {
-        ...event,
-        category,
-        primitive: primitiveForCategory(category),
-    };
-}
 export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
     const t = obs.turn ?? turn;
     const compressionAction = opts.compressionAction ?? (() => undefined);
     switch (obs.kind) {
-        case "page_out":
-            return withCategory({
-                kind: "page_out",
-                turn: t,
-                action: compressionAction(obs.action),
-                summary: obs.summary,
-                tier_hint: obs.tier_hint ?? "durable",
-                message_count: Array.isArray(obs.archived) ? obs.archived.length : 0,
-            });
         case "compressed": {
             const latest = opts.latestSeq ?? -1;
             const start = opts.nextArchiveStart ?? 0;
             if (latest < start)
                 return null;
-            return withCategory({
+            return {
                 kind: "compressed",
                 turn: t,
                 archived_seq_range: [start, latest],
@@ -57,24 +40,24 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 summary_tokens: obs.summary ? Math.max(1, Math.ceil(obs.summary.length / 4)) : undefined,
                 archive_ref: opts.archiveRef,
                 preserved_refs: opts.preservedRefs ?? [],
-            });
+            };
         }
         case "renewed":
-            return withCategory({
+            return {
                 kind: "context_renewed",
                 turn: t,
                 sprint: obs.sprint ?? 0,
                 handoff_ref: "",
-            });
+            };
         case "rollbacked":
-            return withCategory({
+            return {
                 kind: "rollbacked",
                 turn: t,
                 checkpoint_history_len: obs.checkpoint_history_len ?? 0,
                 reason: obs.reason,
-            });
+            };
         case "capability_changed":
-            return withCategory({
+            return {
                 kind: "capability_changed",
                 turn: t,
                 added: obs.added ?? [],
@@ -84,36 +67,29 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 ...(obs.version != null && { version: obs.version }),
                 ...(obs.mounted_by != null && { mounted_by: obs.mounted_by }),
                 ...(obs.mount_reason != null && { mount_reason: obs.mount_reason }),
-            });
+            };
         case "milestone_advanced":
-            return withCategory({
+            return {
                 kind: "milestone_advanced",
                 turn: t,
                 phase_id: obs.phase_id ?? "",
                 capabilities_unlocked: obs.capabilities_unlocked ?? [],
-            });
+            };
         case "milestone_blocked":
-            return withCategory({
+            return {
                 kind: "milestone_blocked",
                 turn: t,
                 phase_id: obs.phase_id ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
-            });
-        case "milestone_evidence":
-            return withCategory({
-                kind: "milestone_evidence",
-                turn: t,
-                phase_id: obs.phase_id ?? "",
-                evidence: obs.evidence ?? [],
-            });
+            };
         case "checkpoint_taken":
-            return withCategory({
+            return {
                 kind: "checkpoint_taken",
                 turn: t,
                 history_len: obs.history_len ?? 0,
-            });
+            };
         case "agent_process_changed":
-            return withCategory({
+            return {
                 kind: "agent_process_changed",
                 turn: t,
                 agent_id: obs.agent_id ?? "",
@@ -126,47 +102,47 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 ...(obs.result_termination
                     ? { result_termination: obs.result_termination }
                     : {}),
-            });
+            };
         case "tool_gated":
-            return withCategory({
+            return {
                 kind: "tool_gated",
                 turn: t,
                 call_id: obs.call_id ?? "",
                 tool: obs.tool ?? "",
                 reason: typeof obs.reason === "string" ? obs.reason : "",
-            });
+            };
         case "signal_disposed":
-            return withCategory({
+            return {
                 kind: "signal_disposed",
                 turn: t,
                 signal_id: obs.signal_id ?? "",
                 disposition: obs.disposition ?? "",
                 queue_depth: obs.queue_depth ?? 0,
-            });
+            };
         case "budget_exceeded":
-            return withCategory({
+            return {
                 kind: "budget_exceeded",
                 turn: t,
                 budget: obs.budget ?? "",
-            });
+            };
         case "suspended":
-            return withCategory({
+            return {
                 kind: "suspended",
                 turn: t,
                 reason: typeof obs.reason === "string" ? obs.reason : "",
                 pending_calls: obs.pending_calls ?? [],
-            });
+            };
         case "resumed":
-            return withCategory({
+            return {
                 kind: "resumed",
                 turn: t,
                 approved: obs.approved ?? [],
                 denied: obs.denied ?? [],
-            });
+            };
         case "page_in_requested":
             return null;
         case "large_result_spooled":
-            return withCategory({
+            return {
                 kind: "large_result_spooled",
                 turn: t,
                 call_id: obs.call_id ?? "",
@@ -174,51 +150,51 @@ export function kernelObservationToSessionEvent(obs, turn, opts = {}) {
                 original_size: obs.original_size ?? 0,
                 preview_size: obs.preview_size ?? 0,
                 spool_ref: opts.spoolRef,
-            });
+            };
         case "memory_written":
-            return withCategory({
+            return {
                 kind: "memory_written",
                 turn: t,
                 memory_id: obs.memory_id ?? "",
                 memory_kind: obs.memory_kind ?? "",
                 size_bytes: obs.size_bytes ?? 0,
-            });
+            };
         case "memory_queried":
-            return withCategory({
+            return {
                 kind: "memory_queried",
                 turn: t,
                 query_context: obs.query_context ?? "",
                 requested_k: obs.requested_k ?? 0,
                 requires_async_response: obs.requires_async_response ?? false,
-            });
+            };
         case "memory_validation_failed":
-            return withCategory({
+            return {
                 kind: "memory_validation_failed",
                 turn: t,
                 memory_id: obs.memory_id ?? "",
                 error: obs.error ?? "",
-            });
+            };
         case "workflow_batch_spawned": {
             // Batch metadata persisted for resume recovery; individual nodes are
             // recorded when they complete (via workflow_node_completed).
             const nodes = obs.nodes ?? [];
-            return withCategory({
+            return {
                 kind: "workflow_batch_spawned",
                 turn: t,
                 node_count: nodes.length,
                 node_ids: nodes.map((n) => n.agent_id ?? ""),
-            });
+            };
         }
         case "workflow_completed": {
             const completed = obs.completed ?? [];
             const failed = obs.failed ?? [];
-            return withCategory({
+            return {
                 kind: "workflow_completed",
                 turn: t,
                 completed,
                 failed,
                 total_nodes: completed.length + failed.length,
-            });
+            };
         }
         default:
             return null;

package/dist/runtime/kernel-step.d.ts

@@ -11,10 +11,19 @@ export interface KernelRuntimeHandle {
     drainNewMessages(): Message[];
     preservedRefs(): string[];
 }
+export interface PaceDecision {
+    action: "continue" | "sleep" | "stop";
+    delayMs?: number;
+    reason: string;
+    /** Set when the kernel trap coerced the model's proposal (clamped delay / forced stop). */
+    coercedFrom?: string;
+}
 export interface KernelLoopResult {
     termination: string;
     turnsUsed: number;
     totalTokensUsed: number;
+    /** ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs). */
+    paceDecision?: PaceDecision;
 }
 export type MilestoneVerifierKind = {
     kind: "machine_check";
@@ -65,6 +74,8 @@ export interface KernelObservation {
     phase_id?: string;
     capabilities_unlocked?: string[];
     evidence?: string[];
+    removed_keys?: string[];
+    tokens_freed?: number;
     reason?: RollbackReason | string;
     agent_id?: string;
     parent_session_id?: string;

package/dist/runtime/kernel-step.js

@@ -240,12 +240,24 @@ function mapKernelAction(raw) {
             };
         case "done": {
             const result = raw.result ?? {};
+            const pace = result.pace_decision;
             return {
                 kind: "done",
                 result: {
                     termination: String(result.termination ?? "error"),
                     turnsUsed: Number(result.turns_used ?? 0),
                     totalTokensUsed: Number(result.total_tokens_used ?? 0),
+                    // ③ loop-agent: the kernel-adjudicated after-round decision (absent on non-loop runs).
+                    ...(pace
+                        ? {
+                            paceDecision: {
+                                action: (pace.action ?? "stop"),
+                                delayMs: pace.delay_ms,
+                                reason: pace.reason ?? "",
+                                coercedFrom: pace.coerced_from,
+                            },
+                        }
+                        : {}),
                 },
             };
         }

package/dist/runtime/large-result-spool.d.ts

@@ -77,6 +77,13 @@ export declare class LargeResultSpool {
      * Read a spooled result back from disk.
      */
     readSpooledResult(spoolRef: string): Promise<string>;
+    /**
+     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
+     * `call_id`, not the content-hashed file name `persistOutput` chose). Scans the spool directory
+     * for the `${callId}-*.txt` naming convention; returns `undefined` if nothing was ever spooled
+     * for that call (e.g. it never actually exceeded the threshold, or the spool dir was cleaned up).
+     */
+    findByCallId(callId: string): Promise<string | undefined>;
     /**
      * Clean up old spool files (optional maintenance).
      */

package/dist/runtime/large-result-spool.js

@@ -140,6 +140,31 @@ omitted: ${omitted} chars
             throw new Error(`Failed to read spooled result: ${error}`);
         }
     }
+    /**
+     * O7: locate a spooled output by the tool call's id (the `read_result` meta-tool only knows
+     * `call_id`, not the content-hashed file name `persistOutput` chose). Scans the spool directory
+     * for the `${callId}-*.txt` naming convention; returns `undefined` if nothing was ever spooled
+     * for that call (e.g. it never actually exceeded the threshold, or the spool dir was cleaned up).
+     */
+    async findByCallId(callId) {
+        let files;
+        try {
+            files = await fs.readdir(this.spoolDir);
+        }
+        catch {
+            return undefined;
+        }
+        const prefix = `${callId}-`;
+        const match = files.find(f => f.startsWith(prefix) && f.endsWith('.txt'));
+        if (!match)
+            return undefined;
+        try {
+            return await fs.readFile(path.join(this.spoolDir, match), 'utf-8');
+        }
+        catch {
+            return undefined;
+        }
+    }
     /**
      * Clean up old spool files (optional maintenance).
      */

package/dist/runtime/loop-driver.d.ts

@@ -0,0 +1,108 @@
+/**
+ * ③ Dynamic loop-agent engineering system — the SDK driver.
+ *
+ * A loop agent is NOT a new execution engine:
+ * - a ROUND is exactly one bounded `RuntimeRunner.run()` (compaction, RepeatFuse,
+ *   criteria gate, and budget verdicts all apply per round for free);
+ * - CONTINUITY is the session log replayed under ONE stable sessionId;
+ * - LIFETIME GOVERNANCE is the RunGroup the rounds are members of;
+ * - the only new decision — what happens AFTER a round — is the model-proposed,
+ *   kernel-adjudicated `pace` verb (see the kernel pacing trap). The kernel never
+ *   sleeps; all timers and judge calls live here, in SDK I/O land.
+ *
+ * Durable pacing: every round appends `round_started` / `round_paced` to the loop's
+ * session log, so `LoopDriver.resume()`-style recovery is a fold over the log
+ * (the SessionLogGroupBudgetStore pattern) — zero new storage. A stateless host
+ * reads `wake_at_ms` from the fold and re-arms via its own cron/queue; an
+ * in-process host lets `run()` sleep inline.
+ */
+import type { RuntimeRunner } from "./runner.js";
+import type { SessionEvent } from "./session-log.js";
+import type { PaceDecision } from "./kernel-step.js";
+import type { StreamEvent } from "../types.js";
+export interface LoopSpec {
+    /** Stable loop id = the ONE session id every round replays (transcript continuity). */
+    loopId: string;
+    goal: string;
+    criteria?: string[];
+    /** Hard round cap; the kernel coerces continue/sleep to stop at the cap. */
+    maxRounds?: number;
+    /** Sleep clamp bounds (ms), enforced in-kernel. */
+    minSleepMs?: number;
+    maxSleepMs?: number;
+    /** "stop" (goal loop, default) | "sleep" (cron loop) when a round never calls pace. */
+    defaultAction?: "stop" | "sleep";
+    /** Cross-round done-gate: judges a stop proposal; a failing verdict overrides
+     *  stop→continue at most `maxVerdictOverrides` times, its feedback becoming the
+     *  next round's steering note. The in-kernel O4 criteria gate is the per-round rung
+     *  of the same ladder — this is the cross-round rung. */
+    verdictFn?: (ctx: {
+        loopId: string;
+        round: number;
+        reason: string;
+    }) => Promise<{
+        pass: boolean;
+        feedback?: string;
+    }> | {
+        pass: boolean;
+        feedback?: string;
+    };
+    maxVerdictOverrides?: number;
+    /** Sleep implementation (injectable for tests / stateless hosts). Default: setTimeout.
+     *  Return `false` to hand the wake to an external scheduler and end `run()` dormant. */
+    sleeper?: (delayMs: number, wakeAtMs: number) => Promise<boolean>;
+    /** Per-round event tap (streaming passthrough). */
+    onEvent?: (round: number, event: StreamEvent) => void;
+}
+export interface LoopOutcome {
+    loopId: string;
+    roundsCompleted: number;
+    stopped: boolean;
+    /** "stopped" | "dormant" (sleeper handed off to an external scheduler) */
+    state: "stopped" | "dormant";
+    lastPace?: PaceDecision;
+    lastStatus?: string;
+    /** Absolute wake time when dormant. */
+    wakeAtMs?: number;
+}
+/** Fold the loop's session log into resumable pacing state — zero new storage. DW-5: the judge's
+ *  override budget folds too, so a crash/restart can't grant the verdictFn fresh overrides. */
+export declare function foldLoopState(events: Array<{
+    seq: number;
+    event: SessionEvent;
+}>): {
+    roundsCompleted: number;
+    pendingWakeAtMs?: number;
+    lastPace?: {
+        action: string;
+        reason: string;
+    };
+    overridesUsed: number;
+};
+/**
+ * DW-6 completion→wake bridge, composed from two existing seams (zero new mechanism): a `sleeper`
+ * that races the timer against an L0 recipient-addressed signal on the shared gateway. Ingest a
+ * signal with `recipient: loopId` (a subagent/workflow completion, a webhook) and the sleeping loop
+ * wakes into its next round immediately — where the SAME queued signal then reaches the model
+ * through the kernel's normal signal path, so the wake reason is visible in-round.
+ */
+export declare function signalAwareSleeper(gateway: {
+    onSignal(listener: (sig: {
+        recipient?: string;
+    }) => void): () => void;
+}, loopId: string): NonNullable<LoopSpec["sleeper"]>;
+export declare class LoopDriver {
+    private readonly runner;
+    private readonly spec;
+    private overridesUsed;
+    constructor(runner: RuntimeRunner, spec: LoopSpec);
+    /**
+     * Drive rounds until the loop stops or goes dormant. Resumable by construction:
+     * the round count and any pending wake are folded from the session log, so
+     * calling `run()` again after a crash / on a stateless host continues in place.
+     */
+    run(): Promise<LoopOutcome>;
+    private sleep;
+}
+/** Facade: run a self-pacing loop agent (joins runAgent/runFanout as an entry point). */
+export declare function runLoop(runner: RuntimeRunner, spec: LoopSpec): Promise<LoopOutcome>;