indusagi-coding-agent 0.2.4 → 0.2.5

package/dist/types/boot/runners/addon-wiring.test.d.ts

@@ -1,19 +0,0 @@
-/**
- * Addon wiring — boot-time activation of the addon host (item #19).
- *
- * These tests exercise the two seams this module adds to the boot path WITHOUT a
- * real conductor, real jiti, or disk: a fake {@link ModuleLoader} maps a source
- * path to a scripted {@link AddonManifest}, the host loads it through
- * `explicitPaths` (which never touches the filesystem), and the resulting bundle
- * is folded around a synthetic tool deck.
- *
- * Four concerns:
- *   1. An `enter` block short-circuits the call — the wrapper returns an
- *      `isError` result carrying the gate reason and the real `execute` NEVER
- *      runs.
- *   2. An `exit` rewrite replaces the tool's result.
- *   3. A tool no interceptor matches is returned IDENTITY-equal (the empty-bundle
- *      / no-addons path is a perfect no-op).
- *   4. Contributed addon tools are concatenated, de-duped against the deck.
- */
-export {};

package/dist/types/boot/runners/checkpoint.d.ts

@@ -1,133 +0,0 @@
-/**
- * Per-session file-checkpoint store — the product half of rewind (#24).
- *
- * The framework's mutating file tools (write/edit) consult a host-injected handle
- * on `ctx.framework` under the string-literal key {@link CHECKPOINT_HANDLE_KEY}.
- * Immediately before a file is written — and after the read-before-edit gate has
- * passed — the framework reads the file's CURRENT on-disk content and hands it to
- * the handle as `record(absPath, previous)`, where `previous` is the old bytes or
- * `null` when the file did not yet exist. This module supplies the missing host
- * piece: a store that files those pre-mutation snapshots against the transcript
- * node that was active when the mutation happened, so a later rewind to that node
- * can roll the working tree back to exactly that point.
- *
- * Design notes:
- *   - **Keyed by the ACTIVE transcript node id.** Each snapshot is filed under the
- *     id the conductor pins as the active node (the head leaf at turn start). All
- *     of a turn's edits therefore land under ONE node id; navigating back to that
- *     node and restoring reverts the whole turn's file changes at once.
- *   - **First-seen wins per path within a node.** If the same file is edited twice
- *     in one turn, only the FIRST snapshot (the content as it was when the node
- *     became active) is kept. Overwriting it would lose the true pre-turn state,
- *     so a second `record` of the same path under the same node is ignored. This
- *     also makes the framework's pre-write `record` idempotent across the multiple
- *     mutations one tool call may perform.
- *   - **`null` previous means "file was absent".** Restoring a node whose snapshot
- *     marks a file `null` DELETES that file (it did not exist at that point), so a
- *     rewind that created a file is undone by removing it.
- *   - **Duck-typed handle.** The store implements exactly the framework's
- *     `CheckpointHandle` shape (`record(absPath, previous: string | null): void`)
- *     so the host injector and the framework consumer agree by STRING KEY and
- *     STRUCTURAL SHAPE — no cross-package type import. `ctx.framework` is an open
- *     record, so the injection typechecks immediately; the framework consumption
- *     activates after the framework is rebuilt and the product refreshed.
- *   - **One instance PER SESSION** (minted in `session.ts`), shared across the
- *     write/edit cards through the single `ctx.framework` bag, and handed to the
- *     conductor so the conductor can advance the active node id as the head moves.
- *
- * Mirrors the read-edit-gate's `ReadStateStore` conventions (`READ_STATE_HANDLE_KEY`,
- * `createReadStateStore`); both coexist in the SAME `ctx.framework` open bag.
- */
-/**
- * The string-literal key under which the host wires this store onto the deck's
- * `ctx.framework` bag.
- *
- * Mirrors the existing `DELEGATE_HANDLE_KEY = "delegate"`,
- * `MEMORY_HANDLE_KEY = "memoryStore"`, and `READ_STATE_HANDLE_KEY = "readState"`
- * conventions. The framework's mutating file tools read
- * `ctx.framework["checkpoint"]` by the same literal, so the two sides agree by
- * string rather than by a shared imported symbol.
- */
-export declare const CHECKPOINT_HANDLE_KEY: "checkpoint";
-/**
- * One file's pre-mutation snapshot: the path that was mutated and the content it
- * held immediately before. `previous === null` records that the file did not
- * exist on disk before the mutation, so restoring this snapshot deletes it.
- */
-export interface FileSnapshot {
-    readonly path: string;
-    readonly previous: string | null;
-}
-/**
- * Per-session file-checkpoint store, keyed by transcript node id.
- *
- * For each node id it holds a map of normalized absolute path → the FIRST-seen
- * pre-mutation content for that path under that node. The framework calls
- * {@link record} (via the duck-typed handle) before every write; the host pins
- * the active node id with {@link setActiveNodeId} as the conductor's head moves;
- * and {@link restore} rolls the working tree back to a node's recorded state.
- */
-export declare class CheckpointStore {
-    /** node id → (normalized abs path → first-seen pre-mutation content). */
-    private readonly byNode;
-    /** The transcript node the next {@link record} files its snapshot under. */
-    private current;
-    /** Normalize an absolute path into the store's canonical per-node key. */
-    private key;
-    /** The node id new snapshots are currently filed under (`null` until pinned). */
-    activeNodeId(): string | null;
-    /**
-     * Pin the transcript node subsequent {@link record} calls file snapshots under.
-     *
-     * The conductor calls this as its head advances (at turn start), so all of a
-     * turn's edits key to the node that was active before the turn ran. Passing the
-     * same id again is harmless.
-     *
-     * @param id the active transcript node id, or `null` to fall back to the root
-     */
-    setActiveNodeId(id: string | null): void;
-    /** The node id snapshots are filed under right now (active id or the root). */
-    private resolveNodeId;
-    /**
-     * Capture the pre-mutation content of `absPath` under the active node.
-     *
-     * The framework's duck-typed `CheckpointHandle` entry point. Called once per
-     * mutated path immediately before the write lands, with the file's OLD on-disk
-     * content (or `null` when the file did not exist). First-seen wins: a later
-     * `record` of the same path under the same node is ignored so the snapshot
-     * reflects the file's state when the node became active, not a mid-turn rewrite.
-     *
-     * @param absPath  absolute path of the file about to be written
-     * @param previous the file's content before this mutation, or `null` if absent
-     */
-    record(absPath: string, previous: string | null): void;
-    /**
-     * The recorded snapshots for a node, or `[]` when nothing was tracked there.
-     *
-     * Each entry pairs the normalized absolute path with the content it held before
-     * the node's first mutation of it (`null` = the file was absent).
-     *
-     * @param nodeId the transcript node to read snapshots for
-     */
-    snapshotFor(nodeId: string): readonly FileSnapshot[];
-    /** Whether a node has ANY recorded file snapshot (the picker's restore gate). */
-    hasSnapshot(nodeId: string): boolean;
-    /**
-     * Roll the working tree back to a node's recorded state.
-     *
-     * For each path the node tracked: when its snapshot is a string, the file is
-     * rewritten with that pre-mutation content (creating parent directories as
-     * needed); when the snapshot is `null` the file is DELETED (it did not exist at
-     * that point). Returns the absolute paths that were restored, in record order.
-     *
-     * A safe no-op when the node has no snapshot — navigating to a node that never
-     * mutated files restores nothing. Per-path failures are swallowed so one
-     * unwritable path never aborts the rest of the restore.
-     *
-     * @param nodeId the transcript node whose file state to restore to
-     * @returns the absolute paths that were written or deleted
-     */
-    restore(nodeId: string): string[];
-}
-/** Mint a fresh, empty per-session checkpoint store. */
-export declare function createCheckpointStore(): CheckpointStore;

package/dist/types/boot/runners/checkpoint.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * CheckpointStore unit tests — the product half of rewind (#24).
- *
- * Cover the store's contract in isolation (no framework tools):
- *   - per-node FIRST-SEEN snapshot (a path's snapshot within one node is never
- *     overwritten by a later record);
- *   - keying follows the active node id (set via `setActiveNodeId`);
- *   - `restore` writes the recorded old content back AND deletes files whose
- *     snapshot was `null` (absent at that point);
- *   - `restore` of an untracked node is a safe no-op.
- */
-export {};

package/dist/types/boot/runners/delegate-runner.d.ts

@@ -1,109 +0,0 @@
-/**
- * Boot helper: a live {@link DelegateRunner} that makes the `task` tool real.
- *
- * The `task` capability ({@link "../../capability-deck/cards/task-card"}) advertises
- * sub-agent delegation but only *runs* it when a {@link DelegateRunner} is wired
- * into the deck context under {@link DELEGATE_HANDLE_KEY}; absent one it degrades
- * to a typed `STUB_NOTE`. This module supplies that runner.
- *
- * Each delegated objective spins a *fresh, isolated* framework {@link Agent} (the
- * same `facade/bot` Agent the conductor already drives — NOT the swarm `Crew` nor
- * `runtime/createAgent`) bound to the parent's model id and credential resolver,
- * given a survey-style system prompt and a deck that DELIBERATELY excludes the
- * `task` card. That exclusion is the recursion guard: a sub-agent with no `task`
- * tool cannot spawn its own sub-agents. The runner submits one prompt, lets the
- * sub-agent run its own tool loop to completion, then extracts the final
- * assistant turn's text as the single report handed back to the parent.
- *
- * The runner never throws out of `run()`: a model that does not resolve, a
- * sub-agent error, or an empty transcript all map to a `{ ok:false, report }`
- * result so a delegation failure surfaces to the parent agent as an ordinary
- * tool error rather than crashing the turn. Cancellation is forwarded: an
- * already-aborted signal short-circuits, and an abort raised mid-run calls
- * `agent.abort()`.
- *
- * The `spawn`/`tools` options are pure test seams — they let a unit test drive
- * the runner with an in-memory fake instead of a real network round-trip.
- */
-import { type AgentMessage, type SessionPermissionPolicy } from "../../conductor";
-import { type AgentTool } from "../../capability-deck";
-import type { DelegateRunner } from "../../capability-deck/cards/task-card";
-/**
- * The minimal sub-agent surface the runner drives.
- *
- * A real framework {@link Agent} satisfies this structurally; a test passes a
- * lightweight fake via {@link DelegateRunnerOptions.spawn}. Only the pieces the
- * runner touches are named — submit a prompt, abort, and read the resulting
- * transcript/error afterward.
- */
-export interface DelegateSubAgent {
-    prompt(input: string): Promise<void>;
-    abort(): void;
-    readonly state: {
-        messages: readonly AgentMessage[];
-        error?: string;
-    };
-    /**
-     * Optional event subscription (the real framework `Agent` provides it). The
-     * runner uses it to recompute live token spend as the sub-agent works; a test
-     * fake may omit it, in which case no progress is reported.
-     */
-    subscribe?(listener: () => void): () => void;
-}
-/** Configuration for {@link createDelegateRunner}. */
-export interface DelegateRunnerOptions {
-    /** The model id the sub-agent runs under (the parent's resolved model). */
-    readonly modelId: string;
-    /** The working directory the sub-agent's deck is scoped to. */
-    readonly cwd: string;
-    /** The system prompt that shapes the sub-agent's behaviour. */
-    readonly system: string;
-    /**
-     * Per-call credential resolver, forwarded to the framework `Agent` unchanged
-     * (OAuth-only providers, short-lived token rotation). Omitted from the agent
-     * options entirely when undefined so the framework env-var lookup still wins.
-     */
-    readonly getApiKey?: (provider: string) => Promise<string | undefined> | string | undefined;
-    /**
-     * Test seam: build the sub-agent from the objective instead of constructing a
-     * real framework `Agent`. When omitted the runner uses `new Agent`.
-     */
-    readonly spawn?: (objective: string, context?: string) => DelegateSubAgent;
-    /**
-     * Test seam: the tool deck the sub-agent runs with. When omitted the runner
-     * provisions the read-only `'authoring'` profile (which already excludes the
-     * `task` card — the recursion guard).
-     */
-    readonly tools?: () => AgentTool[];
-    /**
-     * Resolve the current server-tier gateway routing map (provider -> gateway
-     * base url). Called FRESH on every `run()` — never cached — so a mid-session
-     * `/login` (to "Indus Server"), including one that lands after this runner was
-     * constructed but before a given delegated call, is always picked up. This
-     * mirrors {@link getApiKey}, which is likewise invoked per-request rather than
-     * resolved once at construction.
-     */
-    readonly getGatewayBaseUrls?: () => Promise<Record<string, string>>;
-    /**
-     * The parent session's live permission policy: the SAME mutable rule list the
-     * parent gate reads plus a live getter onto the conductor's current mode. When
-     * present, every spawned sub-agent runs under a RESOLVER-LESS gate built from
-     * it — deny/ask rules, plan-mode enforcement, and the catastrophic-bash
-     * blocklist apply per inner tool call, and a mid-run mode switch (Shift+Tab)
-     * retargets the very next delegated tool call. A sub-agent cannot prompt, so
-     * an `ask` decision deterministically denies with an actionable message.
-     * Absent (a bare test construction), the sub-agent runs ungated as before.
-     */
-    readonly permissionPolicy?: SessionPermissionPolicy;
-}
-/**
- * Build a live {@link DelegateRunner} the host wires into the deck context.
- *
- * The model is resolved once up front; if the id resolves to nothing the runner
- * still builds but every `run()` reports `{ ok:false }` rather than throwing, so
- * a misconfigured model can never crash the parent's turn.
- *
- * @param opts the model id, cwd, system prompt, and optional credential/test seams
- * @returns a runner satisfying the task card's {@link DelegateRunner} contract
- */
-export declare function createDelegateRunner(opts: DelegateRunnerOptions): DelegateRunner;

package/dist/types/boot/runners/delegate-runner.test.d.ts

@@ -1,13 +0,0 @@
-/**
- * Delegate-runner wiring (#10 / fixes #9).
- *
- * Proves the chain that makes the advertised `task` tool functional: a live
- * {@link createDelegateRunner} spins an isolated sub-agent, runs one objective,
- * and reports back the sub-agent's final assistant text; and the `task` card,
- * given that runner under {@link DELEGATE_HANDLE_KEY}, delegates for real instead
- * of returning its `STUB_NOTE`.
- *
- * Every test drives the runner through the `opts.spawn` / `opts.tools` seams so
- * no model is resolved and no network is touched.
- */
-export {};

package/dist/types/boot/runners/index.d.ts

@@ -1,13 +0,0 @@
-/**
- * Runners subsystem — public barrel.
- *
- * Surfaces the runner registry and the individual placeholder runners. Boot
- * consumers dispatch through {@link selectRunner} / {@link RUNNERS}; the named
- * runners are exported for tests and for explicit wiring.
- */
-export { replRunner } from "./repl-runner";
-export { oneshotRunner } from "./oneshot-runner";
-export { linkRunner } from "./link-runner";
-export { RUNNERS, selectRunner } from "./registry";
-export { createReadStateStore, READ_STATE_HANDLE_KEY, ReadStateStore, } from "./read-state";
-export { createCheckpointStore, CHECKPOINT_HANDLE_KEY, CheckpointStore, } from "./checkpoint";

package/dist/types/boot/runners/link-runner.d.ts

@@ -1,20 +0,0 @@
-/**
- * Runner: `link` — headless JSON-RPC link for a driving parent process.
- *
- * Drives the Phase-8 link channel: it assembles a {@link SessionConductor} for
- * the invocation and serves the declarative {@link SESSION_OPS} registry over the
- * process stdio pair via {@link createLinkServer}. Every framed request is
- * dispatched through the registry (data-driven, not a command switch) and the
- * reply is framed back; the runner resolves the success exit code once the
- * inbound stream ends.
- */
-import type { Runner } from "../contract";
-/**
- * The headless-link runner.
- *
- * {@link Runner.accepts} matches invocations whose resolved mode is `link`.
- * {@link Runner.run} assembles the conductor, starts a link server reading framed
- * requests from stdin and writing framed replies to stdout, and resolves the
- * success exit code when the inbound stream is exhausted.
- */
-export declare const linkRunner: Runner;

package/dist/types/boot/runners/memdir.d.ts

@@ -1,103 +0,0 @@
-/**
- * Durable cross-session memory — a disk-backed working-memory store and the
- * project-context document that carries it into each session's system prompt.
- *
- * The `memory` capability ({@link "../../capability-deck/cards/memory-card"})
- * already reads a host-injected store from `ctx.framework[MEMORY_HANDLE_KEY]` and
- * falls back to an in-process buffer when none is wired. This module supplies the
- * missing piece: a synchronous {@link DiskMemoryStore} that persists the agent's
- * note to a per-cwd `MEMORY.md` under the profile directory, so a fact written in
- * one session is still there the next time the agent runs in the same directory.
- *
- * The same file is loaded into the briefing as a {@link ContextDoc} ({@link
- * loadMemoryDoc}) so the model *sees* its prior memory at the top of a fresh
- * session, not only when it explicitly calls the `memory` tool. The body is
- * line-and-byte capped by {@link truncateEntrypointContent} so a runaway memory
- * file cannot bloat the prompt.
- *
- * Design notes:
- *   - The store is STRICTLY SYNCHRONOUS — the {@link MemoryStore} contract the
- *     card validates is sync (`read`/`replace`/`append` return `void`/`string`),
- *     and an async store would silently fail that validation and degrade to the
- *     in-memory fallback.
- *   - The memory directory is scoped UNDER `workspace.profileDir`, NOT the cwd, so
- *     persisting memory never writes files into the user's working tree.
- *   - The cwd is slugged with the SAME regex as {@link "./session".sessionScopeDir}
- *     so the per-cwd partitioning lines up with the session layout.
- *   - Files are written `0o600` (owner-only), matching the auth vault — the memory
- *     note can hold sensitive project facts.
- */
-import type { ContextDoc } from "../../briefing";
-import { MEMORY_HANDLE_KEY, type MemoryStore } from "../../capability-deck";
-import type { Workspace } from "../contract";
-/** The on-disk filename the durable memory note is stored under. */
-export declare const MEMORY_ENTRYPOINT = "MEMORY.md";
-/** Maximum number of lines of the memory note inlined into the prompt. */
-export declare const MAX_ENTRYPOINT_LINES = 200;
-/**
- * Maximum bytes of the memory note inlined into the prompt.
- *
- * ~125 chars/line at 200 lines: this catches long-line indexes that slip past
- * the line cap (a few very long lines can be far larger than 200 short ones).
- */
-export declare const MAX_ENTRYPOINT_BYTES = 25000;
-/**
- * Cap the memory note to {@link MAX_ENTRYPOINT_LINES} and
- * {@link MAX_ENTRYPOINT_BYTES}, appending a warning naming which cap fired.
- *
- * Line-truncates first (a natural boundary), then byte-truncates at the last
- * newline before the cap so a line is never cut mid-way. Content within both
- * caps is returned trimmed and unchanged.
- *
- * @param raw the raw memory-file text
- * @returns the prompt-safe body (possibly with a trailing truncation warning)
- */
-export declare function truncateEntrypointContent(raw: string): string;
-/**
- * The per-cwd memory directory under the profile dir: `<profileDir>/memory/--<slug>--`.
- *
- * The cwd is slugged — every non-alphanumeric run collapsed to a single dash —
- * and wrapped in `--…--` markers, the SAME scheme `sessionScopeDir` uses for the
- * session transcript layout, so the two partitionings line up. The directory
- * lives under `workspace.profileDir`, never inside the repo, so persisted memory
- * never pollutes the user's working tree.
- *
- * @param workspace the resolved on-disk layout (supplies the profile dir)
- * @param cwd       the run's working directory
- */
-export declare function memoryDirFor(workspace: Workspace, cwd: string): string;
-/**
- * A synchronous, disk-backed {@link MemoryStore} persisting the working-memory
- * note to `<memDir>/MEMORY.md`.
- *
- * Satisfies the `memory` card's narrow three-method port. STRICTLY synchronous:
- * the card validates that each of `read`/`replace`/`append` is a function and
- * calls them inline, so any async variant would break the contract and silently
- * fall back to the in-memory store. Writes create the directory and use mode
- * `0o600` (owner-only), matching the auth vault.
- */
-export declare class DiskMemoryStore implements MemoryStore {
-    private readonly memDir;
-    private readonly file;
-    constructor(memDir: string);
-    /** The current note, or `""` when no file has been written yet. */
-    read(): string;
-    /** Overwrite the note, creating the memory directory as needed (mode 0o600). */
-    replace(content: string): void;
-    /** Add a single line to the end of the note (composed of read + replace). */
-    append(line: string): void;
-}
-/**
- * Load the per-cwd memory note as a {@link ContextDoc} for the briefing's
- * `# Project context` section, or `undefined` when there is nothing to show.
- *
- * An absent file, an empty/whitespace-only note, or any read error yields
- * `undefined` (no project-context block); a non-empty note is capped by
- * {@link truncateEntrypointContent} before inlining. The doc's `path` is the
- * bare `MEMORY.md` label, not the on-disk location, so the heading reads cleanly.
- *
- * @param memDir the per-cwd memory directory from {@link memoryDirFor}
- */
-export declare function loadMemoryDoc(memDir: string): ContextDoc | undefined;
-/** Re-exported so hosts wiring a store can use one import. */
-export { MEMORY_HANDLE_KEY };

package/dist/types/boot/runners/memdir.test.d.ts

@@ -1,12 +0,0 @@
-/**
- * Durable cross-session memory (memdir, #27).
- *
- * Proves the disk-backed memory chain: {@link memoryDirFor} scopes a per-cwd
- * directory under the profile (never the cwd); {@link DiskMemoryStore} round-trips
- * the `memory` card's sync `read`/`replace`/`append` to `<memDir>/MEMORY.md` with
- * owner-only perms; and {@link loadMemoryDoc} surfaces that file as a briefing
- * {@link ContextDoc} (capped by {@link truncateEntrypointContent}) — absent or
- * empty for a fresh cwd. Together they let a fact written in one session reappear
- * in the next session's prompt.
- */
-export {};

package/dist/types/boot/runners/oneshot-runner.d.ts

@@ -1,19 +0,0 @@
-/**
- * Runner: `oneshot` — single non-interactive request to stdout.
- *
- * Drives the Phase-8 oneshot channel: it assembles a {@link SessionConductor}
- * for the invocation, builds a {@link ChannelContext} over `process.stdout`
- * (clean text, or a streamed NDJSON event log), runs every prompt to settlement
- * via {@link runOneshot}, and resolves the channel exit code. The output shape is
- * NDJSON when the invocation carries a `json` flag, otherwise clean text.
- */
-import type { Runner } from "../contract";
-/**
- * The one-shot runner.
- *
- * {@link Runner.accepts} matches invocations whose resolved mode is `oneshot`.
- * {@link Runner.run} assembles the conductor and channel context, then delegates
- * the run to {@link runOneshot} and returns its exit code. With no request text
- * it writes a short notice and exits non-zero rather than mounting an empty run.
- */
-export declare const oneshotRunner: Runner;

package/dist/types/boot/runners/read-state.d.ts

@@ -1,82 +0,0 @@
-/**
- * Per-session read-state store — the product half of the read-before-edit gate
- * (read-edit-gate, #11).
- *
- * The framework's file tools (read/write/edit) consult a host-injected handle on
- * `ctx.framework` under the string-literal key {@link READ_STATE_HANDLE_KEY} to
- * decide whether an edit/write may proceed: a file must have been read before it
- * is mutated, and an edit is refused when the file changed on disk since that
- * read. This module supplies the missing host piece — an in-memory map of which
- * files have been read this session and the stat fingerprint at read time — so
- * the gate has somewhere to record and look up that state.
- *
- * Design notes:
- *   - The store is a thin wrapper over a `Map`, keyed by `path.normalize(absPath)`
- *     so a write and a later lookup of the SAME file agree on one key regardless
- *     of how the path was spelled (trailing slashes, `.`/`..` segments).
- *   - One instance is created PER SESSION (in `session.ts` `selectTools`) and
- *     shared across the read/write/edit cards through the single `ctx.framework`
- *     bag, so a read recorded by one tool is visible to the gate in another.
- *   - The record carries the stat fields the framework gate compares against:
- *     `mtimeMs` (the file's last-modified time at read), `size`, an optional
- *     `contentHash` for a content-equality fallback, and `readAt` (when the host
- *     recorded the read). The framework's own stat result exposes the modified
- *     time as `modifiedMs`; the host normalizes it into `mtimeMs` on the way in,
- *     so this record is the single agreed shape.
- *   - The handle key is a bare string literal (mirroring the deck's
- *     `DELEGATE_HANDLE_KEY` / `MEMORY_HANDLE_KEY`) so the framework consumer and
- *     this product injector agree WITHOUT a cross-package type import. `ctx.framework`
- *     is an open record, so the injection typechecks immediately.
- */
-/**
- * The string-literal key under which the host wires this store onto the deck's
- * `ctx.framework` bag.
- *
- * Mirrors the existing `DELEGATE_HANDLE_KEY = "delegate"` and
- * `MEMORY_HANDLE_KEY = "memoryStore"` conventions. The framework's file tools
- * read `ctx.framework["readState"]` by the same literal, so the two sides agree
- * by string rather than by a shared imported symbol.
- */
-export declare const READ_STATE_HANDLE_KEY: "readState";
-/**
- * One file's read fingerprint, recorded when the agent reads it this session.
- *
- *   - `mtimeMs` — the file's last-modified time (ms) at read. The gate refuses an
- *     edit when the on-disk mtime has advanced past this. (The framework's stat
- *     result names this `modifiedMs`; the host maps it to `mtimeMs` here.)
- *   - `size` — the file's byte length at read, a cheap secondary change signal.
- *   - `contentHash` — optional digest of the content read, for a content-equality
- *     fallback when the mtime advanced but the bytes are unchanged.
- *   - `readAt` — when the host recorded this read (ms since epoch).
- */
-export interface ReadStateRecord {
-    readonly mtimeMs: number;
-    readonly size: number;
-    readonly contentHash?: string;
-    readonly readAt: number;
-}
-/**
- * In-memory map of read files for one session, keyed by normalized absolute path.
- *
- * The framework gate `set`s a record after every read and after every successful
- * mutation, and `get`s/`has`-checks it before an edit. Keys are normalized in one
- * place ({@link ReadStateStore.key}) so writes and lookups of the same file land
- * on the same entry no matter how the caller spelled the path.
- */
-export declare class ReadStateStore {
-    private readonly entries;
-    /** Normalize an absolute path into the store's canonical key. */
-    private key;
-    /** The recorded read fingerprint for a path, or `undefined` if never read. */
-    get(absPath: string): ReadStateRecord | undefined;
-    /** Record (or replace) the read fingerprint for a path; returns this store. */
-    set(absPath: string, value: ReadStateRecord): this;
-    /** Whether a path has a recorded read fingerprint this session. */
-    has(absPath: string): boolean;
-    /** Drop a path's recorded read fingerprint; returns whether one existed. */
-    delete(absPath: string): boolean;
-    /** Forget every recorded read for this session. */
-    clear(): void;
-}
-/** Mint a fresh, empty per-session read-state store. */
-export declare function createReadStateStore(): ReadStateStore;

package/dist/types/boot/runners/read-state.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Per-session read-state store (read-edit-gate, #11, product half).
- *
- * Proves the in-memory map the read-before-edit gate records into: records are
- * keyed by `path.normalize(absPath)` (so differently-spelled paths to the same
- * file collapse to one entry), `get`/`set`/`has`/`delete`/`clear` round-trip the
- * `{ mtimeMs, size, contentHash?, readAt }` record, the handle key matches the
- * literal the framework consumer reads, and each session gets its own store.
- */
-export {};

package/dist/types/boot/runners/registry.d.ts

@@ -1,30 +0,0 @@
-/**
- * Runner registry — the table-driven replacement for a mode `if/else` ladder.
- *
- * The boot pipeline ends by handing the resolved {@link Invocation} to exactly
- * one {@link Runner}. Rather than branch on the mode string at the call site,
- * dispatch is data: {@link RUNNERS} lists every available runner in priority
- * order, and {@link selectRunner} returns the first whose {@link Runner.accepts}
- * predicate matches. Adding or reordering modes is a one-line edit to the table,
- * never a change to control flow.
- *
- * The interactive REPL is both first in the table and the guaranteed fallback:
- * if no runner claims an invocation, {@link selectRunner} returns it, so a bare
- * command line lands in the interactive session.
- */
-import type { Invocation, Runner } from "../contract";
-/**
- * Every runner the boot layer can dispatch to, in match-priority order.
- *
- * {@link selectRunner} scans this list front-to-back and returns the first
- * accepting runner; `replRunner` leads the list and also serves as the default.
- */
-export declare const RUNNERS: readonly Runner[];
-/**
- * Choose the runner for a parsed {@link Invocation}.
- *
- * Returns the first runner in {@link RUNNERS} that {@link Runner.accepts | accepts}
- * the invocation; if none does, falls back to the interactive REPL runner so
- * dispatch is total and a runner is always returned.
- */
-export declare function selectRunner(inv: Invocation): Runner;

package/dist/types/boot/runners/repl-runner.d.ts

@@ -1,19 +0,0 @@
-/**
- * Runner: `repl` — interactive terminal session.
- *
- * Mounts the Phase-7 console for a live session: it assembles a
- * {@link SessionConductor} for the invocation and renders the interactive surface
- * via {@link mountConsole}, seeding it with the positional prompt when one was
- * supplied. The runner resolves the success exit code once the surface is
- * dismissed.
- */
-import type { Runner } from "../contract";
-/**
- * The interactive-REPL runner.
- *
- * {@link Runner.accepts} matches invocations whose resolved mode is `repl`; it is
- * also the registry default, so it is reached for the empty / interactive command
- * line. {@link Runner.run} assembles the conductor, honours `--resume` /
- * `--continue`, and mounts the console.
- */
-export declare const replRunner: Runner;