@noetic-tools/core 0.0.1 → 0.1.1

package/dist/runtime/durable/harness-checkpoints.js

@@ -0,0 +1,104 @@
+import { CheckpointSchemaVersion } from '../../types/checkpoint.js';
+import { ContextImpl } from '../context-impl.js';
+//#endregion
+//#region captureCheckpoint
+/**
+ * Snapshot the execution state at a checkpoint boundary. No-op when no
+ * `CheckpointStore` is configured — zero-config harnesses preserve
+ * ephemeral semantics. Save failures are logged rather than thrown,
+ * because a checkpoint failing must never abort an otherwise-successful
+ * step.
+ *
+ * @internal
+ */
+export async function captureCheckpoint(h, ctx) {
+    const store = h.checkpointStore;
+    if (!store) {
+        return;
+    }
+    const impl = ctx instanceof ContextImpl ? ctx : null;
+    const frontier = impl ? impl.serialiseFrontier() : [];
+    const layers = {};
+    for (const layer of ctx.layers ?? []) {
+        const state = h.layerStateStore.get(ctx.id, layer.id);
+        if (state !== undefined) {
+            layers[layer.id] = state;
+        }
+    }
+    const snapshot = {
+        schemaVersion: CheckpointSchemaVersion,
+        executionId: ctx.id,
+        threadId: ctx.threadId,
+        resourceId: ctx.resourceId,
+        frontier,
+        layers,
+        cwd: {
+            current: ctx.cwdState.cwd,
+            previous: ctx.cwdState.previousCwd,
+        },
+        // Ask-user queue snapshot is empty at the core layer — the code-agent
+        // host is responsible for pushing pending prompts through this store
+        // via `AskUserService` integration. Carrying the shape from day one
+        // means future producers don't bump the schema version.
+        askUser: [],
+        itemLog: {
+            items: [
+                ...ctx.itemLog.items,
+            ],
+        },
+        capturedAt: new Date().toISOString(),
+    };
+    try {
+        await store.save(snapshot);
+    }
+    catch (err) {
+        console.warn(`AgentHarness.checkpoint: failed to persist snapshot for execution "${ctx.id}":`, err);
+    }
+}
+//#endregion
+//#region restoreFromCheckpoint
+/**
+ * Rebuild a `Context` from a previously-persisted snapshot. Returns
+ * `null` if no snapshot is recorded for `executionId`. Layer state is
+ * replayed into `layerStateStore` keyed by the original executionId so
+ * the restored context observes the pre-crash state through
+ * `readLayerState` and the memory projectors.
+ *
+ * Preserves the original executionId on the returned context via
+ * `Object.defineProperty` — adapter correlation across crash/restart
+ * requires a stable id.
+ *
+ * @internal
+ */
+export async function restoreFromCheckpoint(h, executionId) {
+    const store = h.checkpointStore;
+    if (!store) {
+        return null;
+    }
+    const snapshot = await store.load(executionId);
+    if (!snapshot) {
+        return null;
+    }
+    for (const [layerId, state] of Object.entries(snapshot.layers)) {
+        h.layerStateStore.set(executionId, layerId, state);
+    }
+    const items = h.itemSchemas.parseMany(snapshot.itemLog.items);
+    const cwdInit = snapshot.cwd?.current ?? undefined;
+    const ctx = h.createContext({
+        items,
+        threadId: snapshot.threadId,
+        resourceId: snapshot.resourceId,
+        cwdInit,
+        memory: h._memory,
+    });
+    if (ctx instanceof ContextImpl) {
+        Object.defineProperty(ctx, 'id', {
+            value: executionId,
+            configurable: false,
+            writable: false,
+            enumerable: true,
+        });
+    }
+    return ctx;
+}
+//#endregion

package/dist/runtime/durable/index.d.ts

@@ -0,0 +1,10 @@
+export type { CheckpointStore, CreateCheckpointStoreOptions } from './checkpoint-store.js';
+export { CheckpointKeys, createCheckpointStore } from './checkpoint-store.js';
+export type { DetachedSignal } from './detached-signal.js';
+export { createDetachedSignal } from './detached-signal.js';
+export type { AfterFirstTurnContext, RunnableLoopHarness, RunnableLoopOpts } from './runnable-loop.js';
+export { runnableLoop } from './runnable-loop.js';
+export type { SessionSeedHarness } from './session-seed.js';
+export { seedFromItems } from './session-seed.js';
+export type { CreateNudgeMessageOpts, StallNudgeOpts } from './stall-nudge.js';
+export { createNudgeMessage, createStallNudgeHook, DEFAULT_NUDGE_MESSAGE_TEXT, } from './stall-nudge.js';

package/dist/runtime/durable/index.js

@@ -0,0 +1,5 @@
+export { CheckpointKeys, createCheckpointStore } from './checkpoint-store.js';
+export { createDetachedSignal } from './detached-signal.js';
+export { runnableLoop } from './runnable-loop.js';
+export { seedFromItems } from './session-seed.js';
+export { createNudgeMessage, createStallNudgeHook, DEFAULT_NUDGE_MESSAGE_TEXT, } from './stall-nudge.js';

package/dist/runtime/durable/runnable-loop.d.ts

@@ -0,0 +1,100 @@
+/**
+ * Drive a generic agent-harness chat session for a detached runner.
+ *
+ * The loop is intentionally minimal. A "runnable" is any harness
+ * driven through the standard `execute()` path plus a single-shot
+ * `DetachedSignal` its terminal tool resolves:
+ *
+ *   1. **Resume spawn** — when `priorItems` is non-empty, seed the
+ *      session history and hand control straight to the caller's
+ *      signal. The agent's prior turns are already on record; the next
+ *      turn comes from external input (IPC `send` frame, autopilot
+ *      respawn, etc.) rather than being re-kicked here.
+ *   2. **Fresh spawn** — when `priorItems` is empty (or omitted) and
+ *      an `initialMessage` is supplied, execute that framing message
+ *      as the first turn. The harness's own stream pumps persist the
+ *      emitted items via whatever session store the caller wired up.
+ *   3. **Post-turn hook** — if `afterFirstTurn` is supplied, run it
+ *      once the first turn has settled microtasks. The hook sees
+ *      whether the signal already resolved during the turn so it can
+ *      short-circuit its own logic (e.g. the stall-nudge helper skips
+ *      its nudge when the agent already called a terminal tool).
+ *   4. **Await outcome** — finally, return `signal.done`. If no
+ *      terminal tool ever resolves it, the signal rejects externally
+ *      (SIGTERM handler, process abort) or simply never settles — the
+ *      caller owns that concern.
+ *
+ * The loop has no opinions about where `priorItems` come from, how the
+ * `initialMessage` is built, or what the terminal outcome looks like.
+ * Task-specific logic (chat.jsonl reads, role framing, stall
+ * escalation) lives in the caller and composes via the `afterFirstTurn`
+ * hook.
+ */
+import type { HarnessResponse } from '../../types/harness-result.js';
+import type { ExecuteInput, Item } from '../../types/items.js';
+import type { ExecuteOptions, SessionScope } from '../../types/runtime.js';
+import type { DetachedSignal } from './detached-signal.js';
+/**
+ * Minimum harness surface the loop calls into. Defining this
+ * structurally keeps the loop loosely coupled — the concrete
+ * `AgentHarness<P>` already satisfies the shape, as does a test stub
+ * that only stands up `seedSessionHistory` + `execute` + `getAgentResponse`.
+ *
+ * `getAgentResponse` is REQUIRED because `execute()` only enqueues a
+ * message and returns before the turn actually runs. The loop awaits
+ * `getAgentResponse(scope)` to observe real turn completion before
+ * handing to `afterFirstTurn` — without this, stall detection fires
+ * before the agent has produced any output and flags every run as
+ * stalled.
+ */
+export interface RunnableLoopHarness {
+    seedSessionHistory(threadId: string, items: ReadonlyArray<Item>): void;
+    execute(input: ExecuteInput, options?: ExecuteOptions): Promise<void>;
+    getAgentResponse(scope?: SessionScope): Promise<HarnessResponse>;
+}
+/**
+ * Read-only view the `afterFirstTurn` hook uses to decide whether the
+ * signal settled during the turn it just observed. Consumers call
+ * `signalSettled()` (not a direct property read) so a late-settle
+ * caused by microtask ordering still propagates.
+ */
+export interface AfterFirstTurnContext {
+    /** True if `signal.done` has resolved or rejected. */
+    signalSettled(): boolean;
+}
+export interface RunnableLoopOpts<TOutcome> {
+    readonly harness: RunnableLoopHarness;
+    readonly threadId: string;
+    /**
+     * Prior session items to seed before the first turn. When non-empty
+     * the loop skips `initialMessage` entirely (resume path); when empty
+     * or omitted it proceeds with the fresh-spawn sequence.
+     */
+    readonly priorItems?: ReadonlyArray<Item>;
+    /**
+     * Developer-role framing message that kicks off a fresh run. Omit to
+     * run the loop in "seed + wait" mode where the first turn is driven
+     * externally (e.g. by an IPC client's `send` frame).
+     */
+    readonly initialMessage?: ExecuteInput;
+    readonly signal: DetachedSignal<TOutcome>;
+    /**
+     * Optional post-turn hook. Only runs on the fresh-spawn path once
+     * `initialMessage` has settled microtasks. Receives a context whose
+     * `signalSettled()` query reflects whether the signal is already
+     * resolved/rejected so the hook can no-op when the agent already
+     * produced its terminal outcome.
+     */
+    readonly afterFirstTurn?: (ctx: AfterFirstTurnContext) => Promise<void>;
+}
+/**
+ * Execute the runnable-loop lifecycle and return the final outcome by
+ * awaiting the caller-provided signal. See the module doc for the full
+ * sequence; short version:
+ *
+ *   - `priorItems` present → seed + wait on signal.
+ *   - `initialMessage` present → seed (if any) + execute first turn +
+ *     run `afterFirstTurn` (if any) + wait on signal.
+ *   - Neither present → just wait on signal (pure listener mode).
+ */
+export declare function runnableLoop<TOutcome>(opts: RunnableLoopOpts<TOutcome>): Promise<TOutcome>;

package/dist/runtime/durable/runnable-loop.js

@@ -0,0 +1,90 @@
+/**
+ * Drive a generic agent-harness chat session for a detached runner.
+ *
+ * The loop is intentionally minimal. A "runnable" is any harness
+ * driven through the standard `execute()` path plus a single-shot
+ * `DetachedSignal` its terminal tool resolves:
+ *
+ *   1. **Resume spawn** — when `priorItems` is non-empty, seed the
+ *      session history and hand control straight to the caller's
+ *      signal. The agent's prior turns are already on record; the next
+ *      turn comes from external input (IPC `send` frame, autopilot
+ *      respawn, etc.) rather than being re-kicked here.
+ *   2. **Fresh spawn** — when `priorItems` is empty (or omitted) and
+ *      an `initialMessage` is supplied, execute that framing message
+ *      as the first turn. The harness's own stream pumps persist the
+ *      emitted items via whatever session store the caller wired up.
+ *   3. **Post-turn hook** — if `afterFirstTurn` is supplied, run it
+ *      once the first turn has settled microtasks. The hook sees
+ *      whether the signal already resolved during the turn so it can
+ *      short-circuit its own logic (e.g. the stall-nudge helper skips
+ *      its nudge when the agent already called a terminal tool).
+ *   4. **Await outcome** — finally, return `signal.done`. If no
+ *      terminal tool ever resolves it, the signal rejects externally
+ *      (SIGTERM handler, process abort) or simply never settles — the
+ *      caller owns that concern.
+ *
+ * The loop has no opinions about where `priorItems` come from, how the
+ * `initialMessage` is built, or what the terminal outcome looks like.
+ * Task-specific logic (chat.jsonl reads, role framing, stall
+ * escalation) lives in the caller and composes via the `afterFirstTurn`
+ * hook.
+ */
+//#endregion
+//#region Public API
+/**
+ * Execute the runnable-loop lifecycle and return the final outcome by
+ * awaiting the caller-provided signal. See the module doc for the full
+ * sequence; short version:
+ *
+ *   - `priorItems` present → seed + wait on signal.
+ *   - `initialMessage` present → seed (if any) + execute first turn +
+ *     run `afterFirstTurn` (if any) + wait on signal.
+ *   - Neither present → just wait on signal (pure listener mode).
+ */
+export async function runnableLoop(opts) {
+    const prior = opts.priorItems;
+    if (prior !== undefined && prior.length > 0) {
+        opts.harness.seedSessionHistory(opts.threadId, prior);
+        return opts.signal.done;
+    }
+    if (opts.initialMessage === undefined) {
+        return opts.signal.done;
+    }
+    // Track signal settlement without blocking so the `afterFirstTurn`
+    // hook can detect a synchronous resolve that fired during `execute()`
+    // without racing the deferred.
+    let signalSettled = false;
+    void opts.signal.done.then(() => {
+        signalSettled = true;
+    }, () => {
+        signalSettled = true;
+    });
+    await opts.harness.execute(opts.initialMessage, {
+        threadId: opts.threadId,
+    });
+    // `execute()` only enqueues the framing message; the turn itself runs
+    // asynchronously through the session runner. Await `getAgentResponse`
+    // to observe REAL turn completion before dispatching `afterFirstTurn`.
+    // Without this the stall-nudge hook fires before any turn output and
+    // always classifies the run as stalled. We race against `signal.done`
+    // so a terminal tool that resolves the signal mid-turn still short-
+    // circuits the wait — in that case `getAgentResponse` may not have
+    // settled yet and we skip the post-turn hook entirely since the
+    // terminal outcome has already fired.
+    await Promise.race([
+        opts.harness
+            .getAgentResponse({
+            threadId: opts.threadId,
+        })
+            .catch(() => undefined),
+        opts.signal.done.catch(() => undefined),
+    ]);
+    if (opts.afterFirstTurn !== undefined) {
+        await opts.afterFirstTurn({
+            signalSettled: () => signalSettled,
+        });
+    }
+    return opts.signal.done;
+}
+//#endregion

package/dist/runtime/durable/session-seed.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Seed an agent harness's session history from a pre-parsed `Item[]`.
+ *
+ * Callers who have chat history on disk (JSONL, DB, etc.) read + parse
+ * the persisted format into `Item[]` themselves — this helper is
+ * deliberately path-free so it composes with any storage layer.
+ *
+ * The helper is a thin typed wrapper around `harness.seedSessionHistory`
+ * and exists so the runnable-loop (and any other caller that wants to
+ * restore a prior session) has one documented, named entrypoint rather
+ * than reaching for the harness method inline.
+ */
+import type { Item } from '../../types/items.js';
+/**
+ * Minimum harness surface `seedFromItems` requires. Defined structurally
+ * so tests (and out-of-process children) can pass a stub without casts;
+ * `AgentHarness<P>` from core satisfies the shape directly.
+ */
+export interface SessionSeedHarness {
+    seedSessionHistory(threadId: string, items: ReadonlyArray<Item>): void;
+}
+/**
+ * Seed `harness`'s session for `threadId` with the given items so the
+ * next `execute()` call sees them in the item log. No-op when `items`
+ * is empty (the harness call itself is also safe to make with an empty
+ * array; short-circuiting here keeps the intent crisp).
+ */
+export declare function seedFromItems(harness: SessionSeedHarness, threadId: string, items: ReadonlyArray<Item>): void;

package/dist/runtime/durable/session-seed.js

@@ -0,0 +1,27 @@
+/**
+ * Seed an agent harness's session history from a pre-parsed `Item[]`.
+ *
+ * Callers who have chat history on disk (JSONL, DB, etc.) read + parse
+ * the persisted format into `Item[]` themselves — this helper is
+ * deliberately path-free so it composes with any storage layer.
+ *
+ * The helper is a thin typed wrapper around `harness.seedSessionHistory`
+ * and exists so the runnable-loop (and any other caller that wants to
+ * restore a prior session) has one documented, named entrypoint rather
+ * than reaching for the harness method inline.
+ */
+//#endregion
+//#region Public API
+/**
+ * Seed `harness`'s session for `threadId` with the given items so the
+ * next `execute()` call sees them in the item log. No-op when `items`
+ * is empty (the harness call itself is also safe to make with an empty
+ * array; short-circuiting here keeps the intent crisp).
+ */
+export function seedFromItems(harness, threadId, items) {
+    if (items.length === 0) {
+        return;
+    }
+    harness.seedSessionHistory(threadId, items);
+}
+//#endregion

package/dist/runtime/durable/stall-nudge.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Two-strike stall-nudge helper composable with `runnableLoop`.
+ *
+ * A runner's first turn can end without settling the outcome signal
+ * and without the agent asking for external input — i.e. the agent
+ * stopped without calling either a terminal tool or an ask-user-style
+ * tool. That's a soft failure: rather than wait forever, we nudge the
+ * agent once to remind it of its options. If the second turn also
+ * ends in the same stalled shape we escalate: the caller-supplied
+ * `onStall` callback records the escalation (task pause, metrics,
+ * whatever the domain demands) and we settle the signal ourselves with
+ * a canonical "stalled" outcome so the parent unwinds cleanly.
+ *
+ * The helper factors the state machine out of the loop so callers can
+ * opt in per-runner. Task-specific concerns (how "pending external
+ * input" is detected, how escalation is recorded, what outcome
+ * represents a stalled failure) stay with the caller and flow in via
+ * the config.
+ */
+import type { InputMessageItem } from '../../types/items.js';
+import type { DetachedSignal } from './detached-signal.js';
+import type { AfterFirstTurnContext, RunnableLoopHarness } from './runnable-loop.js';
+/**
+ * Default developer-role text sent when the agent finishes a turn
+ * without calling a terminal tool or an ask-user tool. Kept short and
+ * unambiguous — the agent should be reminded of its options without
+ * being lectured. Callers may override via `createNudgeMessage(text)`.
+ */
+export declare const DEFAULT_NUDGE_MESSAGE_TEXT = "You finished a turn without calling a terminal tool or AskUserQuestion. If you need user input or instruction to continue, call AskUserQuestion now. Otherwise call your terminal tool to complete this phase.";
+export interface CreateNudgeMessageOpts {
+    /** Unique id for the message so item-log dedupe can distinguish re-spawns. */
+    readonly id: string;
+    /** Override the developer-role text. Defaults to `DEFAULT_NUDGE_MESSAGE_TEXT`. */
+    readonly text?: string;
+}
+export interface StallNudgeOpts<TOutcome> {
+    readonly harness: RunnableLoopHarness;
+    readonly threadId: string;
+    readonly signal: DetachedSignal<TOutcome>;
+    /**
+     * The framing message sent as the nudge. Use `createNudgeMessage`
+     * for the canonical developer-role item, or pass your own when a
+     * domain needs a custom shape.
+     */
+    readonly nudgeMessage: InputMessageItem;
+    /**
+     * True when the agent intentionally awaits external input (e.g. an
+     * outstanding ask-user request). When true the nudge is suppressed
+     * — the agent is not stalled, it is waiting for us.
+     */
+    hasPendingExternal(): boolean;
+    /**
+     * Record-side-effect callback fired when the agent stalls a second
+     * time. Use this to mark the task paused, emit a metric, append an
+     * event log entry — whatever the domain needs before the signal
+     * settles.
+     */
+    onStall(): Promise<void>;
+    /** Build the outcome value the signal resolves to on stall escalation. */
+    buildStalledOutcome(): TOutcome;
+}
+/**
+ * Build the canonical developer-role nudge message item. Callers who
+ * want a custom framing build their own `InputMessageItem`; this
+ * helper exists so the common case stays one line.
+ */
+export declare function createNudgeMessage(opts: CreateNudgeMessageOpts): InputMessageItem;
+/**
+ * Build a `runnableLoop`-compatible `afterFirstTurn` hook that
+ * implements the two-strike nudge state machine described in the
+ * module doc. The hook is a no-op when:
+ *
+ *   - the signal already settled (agent called a terminal tool), or
+ *   - the caller reports pending external input (`hasPendingExternal`
+ *     returns true — e.g. an outstanding ask-user request).
+ *
+ * Otherwise it sends the nudge message via `harness.execute`, waits
+ * for microtasks to flush, and re-checks the same two conditions. If
+ * the agent still hasn't progressed, the hook fires `onStall` and
+ * resolves the signal with `buildStalledOutcome()`.
+ */
+export declare function createStallNudgeHook<TOutcome>(opts: StallNudgeOpts<TOutcome>): (ctx: AfterFirstTurnContext) => Promise<void>;

package/dist/runtime/durable/stall-nudge.js

@@ -0,0 +1,87 @@
+/**
+ * Two-strike stall-nudge helper composable with `runnableLoop`.
+ *
+ * A runner's first turn can end without settling the outcome signal
+ * and without the agent asking for external input — i.e. the agent
+ * stopped without calling either a terminal tool or an ask-user-style
+ * tool. That's a soft failure: rather than wait forever, we nudge the
+ * agent once to remind it of its options. If the second turn also
+ * ends in the same stalled shape we escalate: the caller-supplied
+ * `onStall` callback records the escalation (task pause, metrics,
+ * whatever the domain demands) and we settle the signal ourselves with
+ * a canonical "stalled" outcome so the parent unwinds cleanly.
+ *
+ * The helper factors the state machine out of the loop so callers can
+ * opt in per-runner. Task-specific concerns (how "pending external
+ * input" is detected, how escalation is recorded, what outcome
+ * represents a stalled failure) stay with the caller and flow in via
+ * the config.
+ */
+//#region Constants
+/**
+ * Default developer-role text sent when the agent finishes a turn
+ * without calling a terminal tool or an ask-user tool. Kept short and
+ * unambiguous — the agent should be reminded of its options without
+ * being lectured. Callers may override via `createNudgeMessage(text)`.
+ */
+export const DEFAULT_NUDGE_MESSAGE_TEXT = 'You finished a turn without calling a terminal tool or AskUserQuestion. If you need user input or instruction to continue, call AskUserQuestion now. Otherwise call your terminal tool to complete this phase.';
+//#endregion
+//#region Public API
+/**
+ * Build the canonical developer-role nudge message item. Callers who
+ * want a custom framing build their own `InputMessageItem`; this
+ * helper exists so the common case stays one line.
+ */
+export function createNudgeMessage(opts) {
+    return {
+        id: opts.id,
+        type: 'message',
+        role: 'developer',
+        status: 'completed',
+        content: [
+            {
+                type: 'input_text',
+                text: opts.text ?? DEFAULT_NUDGE_MESSAGE_TEXT,
+            },
+        ],
+    };
+}
+/**
+ * Build a `runnableLoop`-compatible `afterFirstTurn` hook that
+ * implements the two-strike nudge state machine described in the
+ * module doc. The hook is a no-op when:
+ *
+ *   - the signal already settled (agent called a terminal tool), or
+ *   - the caller reports pending external input (`hasPendingExternal`
+ *     returns true — e.g. an outstanding ask-user request).
+ *
+ * Otherwise it sends the nudge message via `harness.execute`, waits
+ * for microtasks to flush, and re-checks the same two conditions. If
+ * the agent still hasn't progressed, the hook fires `onStall` and
+ * resolves the signal with `buildStalledOutcome()`.
+ */
+export function createStallNudgeHook(opts) {
+    return async (ctx) => {
+        if (ctx.signalSettled()) {
+            return;
+        }
+        if (opts.hasPendingExternal()) {
+            return;
+        }
+        // First stall — send one nudge.
+        await opts.harness.execute(opts.nudgeMessage, {
+            threadId: opts.threadId,
+        });
+        await Promise.resolve();
+        if (ctx.signalSettled()) {
+            return;
+        }
+        if (opts.hasPendingExternal()) {
+            return;
+        }
+        // Second stall — escalate and settle.
+        await opts.onStall();
+        opts.signal.resolve(opts.buildStalledOutcome());
+    };
+}
+//#endregion

package/dist/runtime/event-broadcaster.d.ts

@@ -1,4 +1,4 @@
-import type { StreamEvent } from '../types/harness-result';
+import type { StreamEvent } from '../types/harness-result.js';
 interface EventBroadcasterOpts {
     maxBufferSize?: number;
 }

package/dist/runtime/in-memory-storage.d.ts

@@ -1,4 +1,4 @@
-import type { StorageAdapter } from '../types/memory';
+import type { StorageAdapter } from '../types/memory.js';
 /**
  * @public Process-local, Map-backed StorageAdapter.
  *

package/dist/runtime/in-memory-storage.js

@@ -1,4 +1,4 @@
-import { frameworkCast } from '../interpreter/framework-cast';
+import { frameworkCast } from '../util/framework-cast.js';
 //#region Public API
 /**
  * @public Process-local, Map-backed StorageAdapter.

package/dist/runtime/item-log-impl.d.ts

@@ -1,6 +1,6 @@
-import type { ItemSchemaRegistry } from '../schemas/item';
-import type { ItemLog } from '../types/context';
-import type { Item } from '../types/items';
+import type { ItemSchemaRegistry } from '../schemas/item.js';
+import type { ItemLog } from '../types/context-parts/item-log.js';
+import type { Item } from '../types/items.js';
 export declare class ItemLogImpl implements ItemLog {
     private readonly itemSchemas;
     private readonly _items;

package/dist/runtime/item-log-impl.js

@@ -1,4 +1,4 @@
-import { defaultItemSchemaRegistry } from '../schemas/item';
+import { defaultItemSchemaRegistry } from '../schemas/item.js';
 export class ItemLogImpl {
     itemSchemas;
     _items = [];

package/dist/runtime/message-queue.d.ts

@@ -1,5 +1,5 @@
-import type { ExecuteInput } from '../types/items';
-import type { DeliveryMode, ExecuteOptions } from '../types/runtime';
+import type { ExecuteInput } from '../types/items.js';
+import type { DeliveryMode, ExecuteOptions } from '../types/runtime.js';
 /** @internal A message accepted by `AgentHarness.execute()` and held until the
  *  session runner processes it. The effective `DeliveryMode` is resolved at
  *  enqueue time so the runner never has to look at harness defaults again. */

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

@@ -1,10 +1,10 @@
-import type { Context } from '../types/context';
-import type { HarnessResponse } from '../types/harness-result';
-import type { Item } from '../types/items';
-import type { HarnessStatus } from '../types/runtime';
-import { EventBroadcaster } from './event-broadcaster';
-import type { QueuedMessage } from './message-queue';
-import { MessageQueue } from './message-queue';
+import type { Context } from '../types/context.js';
+import type { HarnessResponse } from '../types/harness-result.js';
+import type { Item } from '../types/items.js';
+import type { HarnessStatus } from '../types/runtime.js';
+import { EventBroadcaster } from './event-broadcaster.js';
+import type { QueuedMessage } from './message-queue.js';
+import { MessageQueue } from './message-queue.js';
 /** @internal Callback the harness supplies to run a single turn against a
  *  prepared context. The runner invokes this once per turn; it returns the
  *  final text as a string and must append any produced items to `ctx.itemLog`. */

package/dist/runtime/session-runner.js

@@ -1,6 +1,6 @@
-import { emitFrameworkEvent } from './broadcaster-utils';
-import { EventBroadcaster } from './event-broadcaster';
-import { MessageQueue } from './message-queue';
+import { emitFrameworkEvent } from './broadcaster-utils.js';
+import { EventBroadcaster } from './event-broadcaster.js';
+import { MessageQueue } from './message-queue.js';
 //#endregion
 //#region Helpers
 function inputToItems(input) {

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

@@ -1,6 +1,6 @@
-import type { ItemSchemaRegistry } from '../schemas/item';
-import type { StreamingItem } from '../types/harness-result';
-import type { EventBroadcaster } from './event-broadcaster';
+import type { ItemSchemaRegistry } from '../schemas/item.js';
+import type { StreamingItem } from '../types/harness-result.js';
+import type { EventBroadcaster } from './event-broadcaster.js';
 /** @internal Yield text deltas from the session broadcaster. */
 export declare function filterTextStream(broadcaster: EventBroadcaster): AsyncIterable<string>;
 /** @internal Yield reasoning-token deltas from the session broadcaster. */

package/dist/runtime/session-streams.js

@@ -1,4 +1,4 @@
-import { defaultItemSchemaRegistry } from '../schemas/item';
+import { defaultItemSchemaRegistry } from '../schemas/item.js';
 //#endregion
 //#region Helpers
 function isItemRecord(value) {