indusagi-coding-agent 0.2.4 → 0.2.8

package/dist/types/conductor/signal-hub/hub.d.ts

@@ -1,83 +0,0 @@
-/**
- * SignalHub — the conductor's product-event fan-out.
- *
- * A tiny, synchronous publish/subscribe bus over the {@link SessionSignal}
- * stream. The conductor owns one hub per session: behavior modules (the turn
- * loop, the persistence layer, the auto-condense pass) push signals in via
- * {@link SignalHub.emit}, and every registered consumer handler receives them in
- * registration order.
- *
- * Design (deliberately the conductor's own, not the framework's loop emitter):
- *   - Handlers live in an insertion-ordered `Set`, so registration order is the
- *     delivery order and duplicate handler identities collapse to one slot.
- *   - {@link SignalHub.subscribe} returns an unsubscribe thunk; calling it (even
- *     during a dispatch, even more than once) is safe and idempotent.
- *   - {@link SignalHub.emit} fans out over a *snapshot* of the handler set, so a
- *     handler that subscribes or unsubscribes mid-dispatch never corrupts the
- *     in-progress iteration — the change takes effect on the next emit.
- *   - A throwing handler is isolated: its error is routed to the optional
- *     {@link SignalHubOptions.onHandlerError} sink and the remaining handlers
- *     still run. One bad consumer never silences the others.
- *
- * The hub is transport-agnostic: it knows nothing about the framework `Agent`,
- * persistence, or how signals are produced. The {@link module:translate}
- * translator is what turns raw framework events into the {@link SessionSignal}s
- * that flow through here.
- */
-import type { SessionSignal, SignalHandler } from "../contract";
-/** Tuning hooks for a {@link SignalHub}. All optional. */
-export interface SignalHubOptions {
-    /**
-     * Invoked when a subscribed handler throws during {@link SignalHub.emit}.
-     *
-     * Lets the owner observe/log faults in consumer code without aborting the
-     * fan-out. If omitted, handler errors are swallowed so a misbehaving consumer
-     * cannot break signal delivery to the others. This sink is itself guarded —
-     * if it throws, the throw is ignored.
-     *
-     * @param error   the value the handler threw
-     * @param signal  the signal that was being delivered when it threw
-     */
-    readonly onHandlerError?: (error: unknown, signal: SessionSignal) => void;
-}
-/**
- * A synchronous fan-out bus for {@link SessionSignal}s.
- *
- * Construct one per session; subscribe consumers; emit signals. Not a framework
- * type and not wired to one — purely the conductor's own event surface.
- */
-export declare class SignalHub {
-    /** Insertion-ordered live set of subscribed handlers. */
-    private readonly handlers;
-    private readonly onHandlerError?;
-    constructor(options?: SignalHubOptions);
-    /**
-     * Register a handler to receive every subsequently emitted signal.
-     *
-     * Registering the same function reference twice is a no-op (the `Set`
-     * collapses it). The returned thunk removes the handler; it is idempotent and
-     * safe to call during a dispatch.
-     *
-     * @param handler the consumer callback
-     * @returns an unsubscribe function
-     */
-    subscribe(handler: SignalHandler): () => void;
-    /**
-     * Fan a signal out to every currently-subscribed handler, in registration
-     * order.
-     *
-     * Iterates a snapshot of the handler set, so subscribe/unsubscribe performed
-     * by a handler mid-dispatch affects only later emits. A throwing handler is
-     * isolated via {@link SignalHubOptions.onHandlerError}; the remaining handlers
-     * still run.
-     *
-     * @param signal the signal to deliver
-     */
-    emit(signal: SessionSignal): void;
-    /** Number of currently-subscribed handlers. */
-    get size(): number;
-    /** Remove every handler. Subsequent {@link emit} calls deliver to no one. */
-    clear(): void;
-    /** Route a handler error to the sink, guarding the sink itself. */
-    private report;
-}

package/dist/types/conductor/signal-hub/index.d.ts

@@ -1,19 +0,0 @@
-/**
- * signal-hub — the conductor's product-event hub + framework-event translator.
- *
- * Two cooperating pieces sitting between the framework `Agent` loop and the
- * conductor's consumers:
- *
- *   - {@link SignalHub} — a synchronous, insertion-ordered fan-out bus over the
- *     {@link SessionSignal} stream. Behavior modules emit into it; UI/print/RPC
- *     consumers subscribe to it.
- *   - {@link translateAgentEvent} — the pure projection that turns a single
- *     framework {@link AgentEvent} into the zero-or-more {@link SessionSignal}s
- *     that flow through the hub. {@link TRANSLATOR_TABLE} is the underlying,
- *     exhaustiveness-checked dispatch table (exported for inspection/testing).
- *
- * Typical wiring: subscribe the framework loop, run each raw event through
- * `translateAgentEvent`, and `emit` the results on a `SignalHub`.
- */
-export { SignalHub, type SignalHubOptions } from "./hub";
-export { translateAgentEvent, TRANSLATOR_TABLE } from "./translate";

package/dist/types/conductor/signal-hub/translate.d.ts

@@ -1,77 +0,0 @@
-/**
- * translateAgentEvent — the framework-event → {@link SessionSignal} projector.
- *
- * The framework `Agent` emits a fine-grained {@link AgentEvent} stream for its
- * own loop (lifecycle, per-turn, per-message, per-tool). The conductor does not
- * leak that union to consumers; it projects each framework event down to zero or
- * more *product-level* {@link SessionSignal}s, which then flow through the
- * {@link SignalHub}. This module is that projection — and nothing else: it is a
- * pure, side-effect-free function over a single event.
- *
- * Why a table, not a `switch`:
- *   - The mapping is keyed on the framework event's `type` discriminant, so it is
- *     expressed as a {@link TranslatorTable} — one entry per `AgentEventType`.
- *     The table type is `{ [K in AgentEventType]: (ev) => SessionSignal[] }`, so
- *     adding a framework event variant is a compile error until a rule exists for
- *     it. Exhaustiveness is enforced by the type system, not by a `default` arm.
- *   - Each rule receives the precisely-narrowed event member (via
- *     {@link ExtractAgentEvent}) and returns the signals it produces.
- *
- * Mapping rules (framework `type` → product signals):
- *   - `agent_start` / `turn_start` / `message_start` / `agent_end`
- *                                → `[]`  (loop bookkeeping; not product-visible)
- *   - `message_end`              → one `prompt` { text } for a *user* message
- *                                   (the turn is now committed), one `fault` for
- *                                   an errored *assistant* message, else `[]`
- *   - `tool_execution_start`     → one `tool_start`  { id, name }
- *   - `tool_execution_update`    → one `tool_update` { id, name, details } — the
- *                                   running tool's partial-result detail (e.g. the
- *                                   live `◆ Workflow` snapshot) re-projected so the
- *                                   console can update the transcript in place
- *   - `tool_execution_end`       → one `tool_end`    { id, ok: !isError }
- *   - `turn_end`                 → one `turn_end`    { usage }
- *   - `message_update`           → delegated to the inner streaming dispatch on
- *                                   `assistantMessageEvent.type`:
- *        · `text_delta`     → one `text`     { delta }
- *        · `thinking_delta` → one `thinking` { delta }
- *        · `error`          → one `fault`    { model fault }
- *        · everything else  → `[]`
- *
- * Faults: a streaming `error` sub-event becomes a typed `model` fault. The
- * conductor layers its own `aborted` / `tool` / `persistence` / `overflow`
- * faults elsewhere; the translator only mints the one fault the framework
- * stream actually carries.
- */
-import type { AgentEvent, AgentEventType, ExtractAgentEvent } from "indusagi/agent";
-import { type SessionSignal } from "../contract";
-/** A rule mapping one narrowed framework event member to product signals. */
-type TranslatorRule<TType extends AgentEventType> = (event: ExtractAgentEvent<TType>) => SessionSignal[];
-/**
- * The dispatch table: exactly one rule per framework {@link AgentEventType}.
- *
- * Declaring it as a full mapped type means the compiler rejects the module until
- * every framework event variant has a rule — the exhaustiveness guarantee.
- */
-type TranslatorTable = {
-    [K in AgentEventType]: TranslatorRule<K>;
-};
-/**
- * The frozen mapping from each framework event variant to product signals.
- *
- * Exported for testing/inspection; production code calls
- * {@link translateAgentEvent}, which is the table applied.
- */
-export declare const TRANSLATOR_TABLE: TranslatorTable;
-/**
- * Translate a single framework {@link AgentEvent} into the product-level
- * {@link SessionSignal}s it produces (zero, one, or — for future fan-out — many).
- *
- * Pure and total: every framework event variant has a rule (enforced by
- * {@link TranslatorTable}), so this never throws on a known event and returns
- * `[]` for events that carry no product meaning.
- *
- * @param event a framework agent loop event
- * @returns the ordered product signals derived from it
- */
-export declare function translateAgentEvent(event: AgentEvent): SessionSignal[];
-export {};

package/dist/types/conductor/skill-parse/index.d.ts

@@ -1,10 +0,0 @@
-/**
- * Skill-parse subsystem — public barrel.
- *
- * Re-exports the re-derived skill-invocation block parser: the attribute-scanning
- * {@link parseSkillInvocation} hand parser and its structured {@link SkillInvocation}
- * result. Consumers (the conductor's submit path) import from
- * `src/conductor/skill-parse` rather than reaching into `parse`.
- */
-export { parseSkillInvocation } from "./parse";
-export type { SkillInvocation } from "./parse";

package/dist/types/conductor/skill-parse/parse.d.ts

@@ -1,67 +0,0 @@
-/**
- * Skill-invocation block parser — an attribute-scanning hand parser.
- *
- * The coding agent lets a turn carry a *skill invocation*: an XML-ish opener tag
- * that names a capability card to run, optionally locates its on-disk file, and
- * wraps a trailing user message (the body) the skill should act on. The shape is
- * the framework Agent-Skills convention:
- *
- *   ```
- *   <skill name="commit-helper" location="/abs/path/SKILL.md">
- *   please tidy the staged diff and write a message
- *   </skill>
- *   ```
- *
- * This module re-derives that parse from the *format spec*, deliberately NOT as
- * one monolithic capture regex. It is a small hand-written scanner: it walks the
- * input, finds the opener, scans `key=value` attributes one at a time (handling
- * single- or double-quoted and bare values, with `&amp;`/`&lt;`/`&gt;`/`&quot;`/
- * `&#39;` entity decoding), then captures the body up to the matching close tag.
- * Reading attributes incrementally — rather than matching the whole block in a
- * single pattern — is what makes this an independent implementation and lets the
- * parser keep *every* attribute the author wrote, not just a fixed `name`/
- * `location` pair.
- *
- * Block grammar (informal):
- *   block   := WS? '<' TAG WS attrs? WS? '>' body '</' TAG WS? '>'
- *   TAG     := 'skill'            (case-insensitive)
- *   attrs   := (attr WS?)*
- *   attr    := key ('=' value)?
- *   key     := [A-Za-z_][A-Za-z0-9_:.-]*
- *   value   := '"' ... '"' | '\'' ... '\'' | bare           (bare stops at WS / '>')
- *   body    := any text, captured verbatim up to the close tag
- *
- * A valid block must (a) be the leading content of the text (only leading
- * whitespace may precede the opener), (b) name the `skill` tag, (c) carry a
- * non-empty `name` attribute, and (d) be closed by `</skill>`. Anything else
- * yields `null`, signalling "this turn is ordinary text, not a skill call".
- */
-/**
- * The structured result of a successful parse.
- *
- *   - `name` — the value of the required `name` attribute (the skill to run).
- *   - `args` — every attribute the opener carried, keyed by (lower-cased) name,
- *     including `name` itself and any `location`/custom keys. A bare attribute
- *     with no `=value` maps to the empty string.
- *   - `body` — the verbatim text between the opener and the `</skill>` close,
- *     with a single leading and trailing newline trimmed (the common case where
- *     the opener/closer sit on their own lines) but inner whitespace preserved.
- */
-export interface SkillInvocation {
-    readonly name: string;
-    readonly args: Record<string, string>;
-    readonly body: string;
-}
-/**
- * Parse a skill-invocation block out of `text`.
- *
- * Walks the string by hand: skips leading whitespace, confirms a `<skill …>`
- * opener, scans each attribute into an `args` record, captures the body up to the
- * matching `</skill>`, and decodes entities. Returns the structured invocation,
- * or `null` when the text is not a well-formed leading skill block (ordinary
- * turns simply parse to `null`).
- *
- * @param text the raw turn text that may begin with a skill block
- * @returns the parsed `{ name, args, body }`, or `null` if not a skill block
- */
-export declare function parseSkillInvocation(text: string): SkillInvocation | null;

package/dist/types/conductor/submit.test.d.ts

@@ -1,28 +0,0 @@
-/**
- * Phase 2 conductor — submit()/resume() BEHAVIORAL tests.
- *
- * These exercise the live turn loop of {@link createSessionConductor} end-to-end,
- * but with zero network and zero disk. Everything heavy is injected:
- *
- *   - a scripted fake {@link AgentLike} whose `prompt()` drives a pre-recorded
- *     sequence of framework {@link AgentEvent}s through the conductor's stored
- *     subscriber and mutates its own `state.messages` (so `#persistTail` has a
- *     tail to commit);
- *   - an in-memory {@link TranscriptStore} (default {@link memoryBackend}, no disk);
- *   - a fresh {@link SignalHub};
- *   - a {@link ModelMatcher} over a {@link ModelCatalog} built from a stub
- *     {@link CatalogSource} so `options.modelId` resolves;
- *   - `deps.sleep` stubbed to a no-op so retry backoff never actually waits.
- *
- * The four behaviors covered (per the Phase 2 plan):
- *   1. multi-turn tool loop  — ordered text/tool_start/tool_end/turn_end signals,
- *      settled `idle` state with accumulated usage, persisted transcript nodes.
- *   2. fault + retry         — transient streaming error auto-retries then settles;
- *      a hard model fault lands `faulted` with a typed {@link ConductorFault} and a
- *      `{ kind: "fault" }` signal.
- *   3. branch / resume       — a second conductor over the same store resumes the
- *      session and reconstructs the persisted branch (head/leaf).
- *   4. compaction            — autoCompact + a tiny compactAt + a scripted condense
- *      fn fire a `{ kind: "compacted" }` signal and invoke condense.
- */
-export {};

package/dist/types/conductor/transcript-store/index.d.ts

@@ -1,16 +0,0 @@
-/**
- * transcript-store — the conductor's persistent, branchable transcript.
- *
- * Two cooperating pieces:
- *   - {@link TranscriptStore} — the append-only node tree bound to one session:
- *     `append`, `branchAt`, `pathTo`, `load`, with a pluggable storage backend.
- *   - the serialization bridge (re-exported below) — encode/decode the
- *     `indus/transcript@1` NDJSON line shape and project a branch down to the
- *     framework `AgentMessage[]` / LLM `Message[]`.
- *
- * Consumers (the conductor's submit/resume path) import the store and the
- * serialization helpers from `src/conductor/transcript-store` rather than reaching
- * into the individual modules.
- */
-export { TranscriptStore, memoryBackend, fsBackend, replay, type TranscriptBackend, type TranscriptState, type TranscriptClock, type TranscriptStoreOptions, } from "./store";
-export { roleForMessage, encodeEntry, encodeHead, parseSessionText, branchToMessages, branchToLlmMessages, importLegacyFile, importLegacyText, resolveLegacyMessages, type ParsedSessionFile, } from "./serialize";

package/dist/types/conductor/transcript-store/serialize.d.ts

@@ -1,106 +0,0 @@
-/**
- * Transcript serialization — the bridge between the conductor's on-disk
- * {@link TranscriptEntry} vocabulary and the framework's {@link AgentMessage}
- * shapes.
- *
- * Two distinct directions live here, and the split is deliberate:
- *
- *   1. **Conductor ⇄ conductor** — encoding a {@link TranscriptEntry} to/from a
- *      single NDJSON line in the `indus/transcript@1` format. This is the
- *      conductor's *own* envelope (`schema`/`id`/`prev`/`role`/`message`/`at`/
- *      `meta`). The store owns these field names; they are our own, not any
- *      framework-internal session schema.
- *
- *   2. **Conductor ⇄ framework** — projecting a transcript branch down to the
- *      `AgentMessage[]` the agent loop consumes, and (for migration) lifting a
- *      legacy framework session file *up* into transcript entries. Here we
- *      **delegate the actual message serialization to the framework**: the
- *      framework's published loader/context helpers know how to parse and resolve
- *      the legacy on-disk schema, and we keep those internal schema literals
- *      inside the framework package rather than re-declaring them in the app.
- *
- * The role discriminant on a {@link TranscriptEntry} is the conductor's own —
- * `role` here labels the *node*, not the LLM message. We derive it from the
- * carried {@link AgentMessage}'s `role` field so a round-trip is faithful, but
- * the transcript can also hold conductor-only nodes (`condense`, `note`) that the
- * framework message union has no direct counterpart for.
- */
-import type { AgentMessage } from "indusagi/agent";
-import type { Message } from "indusagi/ai";
-import type { SessionHead, TranscriptEntry, TranscriptRole } from "../contract";
-/**
- * Derive the conductor's node {@link TranscriptRole} from a framework
- * {@link AgentMessage}.
- *
- * The framework message union uses `role` values (`user`/`assistant`/`toolResult`
- * plus the custom app messages). We fold those onto the transcript's own role
- * vocabulary. Anything we don't recognize (custom/notification-style messages)
- * is filed as a `note` node so it persists without claiming an LLM turn role.
- */
-export declare function roleForMessage(message: AgentMessage): TranscriptRole;
-/** Encode one {@link TranscriptEntry} to its NDJSON entry line (no newline). */
-export declare function encodeEntry(entry: TranscriptEntry): string;
-/** Encode the {@link SessionHead} to its NDJSON head line (no newline). */
-export declare function encodeHead(head: SessionHead): string;
-/** The result of parsing a whole session file: its head plus its entries. */
-export interface ParsedSessionFile {
-    readonly head: SessionHead | null;
-    readonly entries: TranscriptEntry[];
-}
-/**
- * Parse the raw text of a conductor session file into a head + entries.
- *
- * Tolerant by design: blank lines are skipped, malformed lines are dropped, and
- * lines whose `schema` does not match `indus/transcript@1` are ignored. The last
- * head line wins (a file should carry exactly one, written first and rewritten on
- * branch). Entries keep file order.
- */
-export declare function parseSessionText(sessionId: string, text: string): ParsedSessionFile;
-/**
- * Project a resolved transcript branch down to the framework `AgentMessage[]`
- * the agent loop consumes.
- *
- * The branch is the root→leaf node list (the store's reducer produces it). We
- * pull the carried `content` payloads and hand them straight to the agent; they
- * are already framework messages. Conductor-only nodes whose payload is not a
- * real message would be filtered by the framework's own `convertToLlm` at call
- * time, so we keep them here and let the loop's converter decide.
- */
-export declare function branchToMessages(branch: readonly TranscriptEntry[]): AgentMessage[];
-/**
- * Convert a transcript branch to *LLM-ready* `Message[]`, delegating entirely to
- * the framework's {@link convertToLlm}.
- *
- * This is the one place that must understand how each `AgentMessage` variant
- * (including the framework's custom `bashExecution`/`branchSummary`/… messages)
- * collapses into a plain LLM message — and that knowledge stays in the framework.
- * The conductor never re-implements it.
- */
-export declare function branchToLlmMessages(branch: readonly TranscriptEntry[]): Message[];
-/**
- * Lift a *legacy framework session file* into conductor {@link TranscriptEntry}
- * nodes, for one-way migration/import.
- *
- * The legacy file is the framework's own internal JSONL format. We do **not**
- * parse its schema ourselves — we call the framework's published loader (or its
- * in-memory text parser), then map only the message-bearing entries onto our
- * envelope. Every framework-internal schema literal stays behind that call.
- *
- * Non-message bookkeeping entries (model/thinking changes, labels, raw
- * compaction markers) are dropped from the imported transcript: their effect is
- * already folded into the resolved messages we keep, and the conductor tracks
- * model/thinking in its own state rather than as transcript nodes.
- */
-export declare function importLegacyFile(filePath: string): TranscriptEntry[];
-/** As {@link importLegacyFile}, but from already-loaded text (testing/import). */
-export declare function importLegacyText(text: string): TranscriptEntry[];
-/**
- * Resolve a legacy framework file straight to the `AgentMessage[]` of its active
- * branch, delegating to the framework's {@link buildSessionContext}.
- *
- * Useful when the goal is to *seed* a fresh conductor session from a legacy one
- * without reproducing its tree: the framework walks its own parent links and
- * applies its own compaction/branch-summary resolution, and we receive a flat
- * message list to re-append as new transcript nodes.
- */
-export declare function resolveLegacyMessages(filePath: string): AgentMessage[];

package/dist/types/conductor/transcript-store/serialize.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * Transcript serialization — head usage round-trip.
- *
- * Focused coverage for the cost-cmd durability seam: the head line now carries
- * the session's cumulative {@link Usage}, and {@link encodeHead} →
- * {@link parseSessionText} must round-trip it faithfully so resume can restore the
- * running token/cost total instead of seeding zero. Heads without usage (legacy
- * files, fresh sessions) must still parse cleanly with `usage` absent.
- */
-export {};

package/dist/types/conductor/transcript-store/store.d.ts

@@ -1,188 +0,0 @@
-/**
- * TranscriptStore — the conductor's persistent, branchable transcript.
- *
- * Replaces pi's `SessionManager`, but with the conductor's own vocabulary and a
- * deliberately different internal model. The transcript is an append-only **tree**
- * of {@link TranscriptEntry} nodes: every node names its `parent`, a single
- * {@link SessionHead} tracks the active `leaf`, and the active conversation is the
- * `parent`-chain walked from that leaf back to a root.
- *
- * Design stance (an independent persistence model):
- *   - **Reducer-friendly.** The on-disk form is a flat NDJSON log; the in-memory
- *     view is rebuilt by a pure {@link replay} reducer over that log. State is a
- *     value derived from the log, never mutated in place behind the scenes.
- *   - **Fresh envelope.** Lines carry the `indus/transcript@1` schema with our own
- *     field names (`prev`, `at`, `kind`), delegated to {@link module:serialize} —
- *     not any framework-internal session-manager schema.
- *   - **Branch = move the head.** {@link branchAt} repoints the leaf at an earlier
- *     node; the next {@link append} becomes that node's child, forking a new path
- *     without rewriting history.
- *   - **`pathTo` is the read primitive.** {@link pathTo} resolves the root→leaf
- *     branch (the message list the agent replays); the conductor's `resume` calls
- *     it to rehydrate.
- *
- * The store is storage-pluggable: a {@link TranscriptBackend} abstracts where bytes
- * live, so tests inject an in-memory backend and the conductor binds a filesystem
- * one. Construction is synchronous and empty; {@link load} hydrates from a backend.
- */
-import type { AgentMessage, SessionHead, TranscriptEntry, TranscriptRole } from "../contract";
-import { TRANSCRIPT_SCHEMA } from "../contract";
-import type { Usage } from "indusagi/ai";
-/**
- * Where a transcript's NDJSON log lives. The store appends lines and, on branch,
- * rewrites the whole file; a backend supplies those three primitives plus a way
- * to resolve a session id to its location. All methods may be async.
- *
- * The default {@link fsBackend} maps a session id to `<dir>/<sessionId>.ndjson`;
- * tests pass an in-memory backend so no disk is touched.
- */
-export interface TranscriptBackend {
-    /** Absolute location (path/key) a session id persists to. */
-    locate(sessionId: string): string;
-    /** Read the full NDJSON text for a session, or `null` if absent. */
-    read(sessionId: string): Promise<string | null>;
-    /** Append one already-encoded NDJSON line (no trailing newline) to a session. */
-    append(sessionId: string, line: string): Promise<void>;
-    /** Replace the whole NDJSON text for a session (used after a branch). */
-    rewrite(sessionId: string, text: string): Promise<void>;
-}
-/** An in-memory backend — the default when no persistence is wired. */
-export declare function memoryBackend(): TranscriptBackend;
-/**
- * A filesystem backend rooted at `dir`. Lazily imports `node:fs`/`node:path` so
- * the module stays usable in non-Node test contexts that pass {@link memoryBackend}.
- */
-export declare function fsBackend(dir: string): TranscriptBackend;
-/**
- * The immutable derived state of a transcript: the node table keyed by id, plus
- * the current head. A pure value produced by {@link replay}; the store holds one
- * and swaps it wholesale on each mutation rather than mutating fields.
- */
-export interface TranscriptState {
-    /** Every node, keyed by id, in insertion order. */
-    readonly nodes: ReadonlyMap<string, TranscriptEntry>;
-    /** The active head (session id + current leaf). */
-    readonly head: SessionHead;
-}
-/** A clock + id seam so tests get deterministic ids/timestamps. */
-export interface TranscriptClock {
-    /** Mint a fresh, sortable node id. */
-    readonly id: () => string;
-    /** The current instant as an ISO-8601 string. */
-    readonly now: () => string;
-}
-/**
- * Rebuild a {@link TranscriptState} from an ordered entry list and a leaf.
- *
- * Pure and total: the same inputs always yield the same state. The reducer just
- * indexes the entries by id (later ids overwrite earlier — append-only logs never
- * collide, but a rewrite stays idempotent) and pins the head. Replacing pi's
- * mutate-in-place index with an explicit reducer is the divergence.
- */
-export declare function replay(sessionId: string, entries: readonly TranscriptEntry[], leaf: string | null): TranscriptState;
-/** Tuning seams for a {@link TranscriptStore}. All optional. */
-export interface TranscriptStoreOptions {
-    /** Where bytes live; defaults to {@link memoryBackend}. */
-    readonly backend?: TranscriptBackend;
-    /** Id/timestamp source; defaults to ULID + wall clock. */
-    readonly clock?: TranscriptClock;
-}
-/**
- * An append-only, branchable transcript bound to one session id.
- *
- * Construct (empty), then either {@link append} fresh nodes or {@link load} a
- * persisted session. Every mutation appends to the backend and swaps the derived
- * {@link TranscriptState}. Reads (`pathTo`, `messages`, `head`) are O(branch
- * depth) walks over the in-memory node table.
- */
-export declare class TranscriptStore {
-    #private;
-    constructor(sessionId: string, options?: TranscriptStoreOptions);
-    /** The session id this store is bound to. */
-    get sessionId(): string;
-    /** The current head (session id + active leaf). */
-    get head(): SessionHead;
-    /**
-     * The cumulative session usage last persisted onto the head, or `undefined`
-     * when none has been written (a fresh session, or a legacy file without a
-     * usage-bearing head). `resume` reads this to restore the running token/cost
-     * total instead of seeding zero.
-     */
-    get usage(): Usage | undefined;
-    /** Number of nodes currently in the transcript. */
-    get size(): number;
-    /** Backend location this session persists to (for diagnostics/UI). */
-    locate(sessionId?: string): string;
-    /** Look up a single node by id. */
-    get(id: string): TranscriptEntry | undefined;
-    /**
-     * Append a framework {@link AgentMessage} as a child of the current leaf and
-     * advance the head onto it. The node role is derived from the message (or
-     * overridden via `role`). Persists the new line, then returns the new node.
-     *
-     * This is the conductor's per-message write: one call per produced message in
-     * a settled turn.
-     */
-    append(content: AgentMessage, role?: TranscriptRole, meta?: Readonly<Record<string, unknown>>): Promise<TranscriptEntry>;
-    /**
-     * Persist the session's cumulative usage onto the head and rewrite the backing
-     * file so the running token/cost total survives a reload. Distinct from
-     * {@link append}, which only appends an entry line and never rewrites the head:
-     * usage durability MUST flow through here so the re-emitted head line carries
-     * the latest tally. Leaves the node tree and active leaf untouched.
-     *
-     * @param usage the cumulative usage to pin on the head
-     */
-    persistUsage(usage: Usage): Promise<void>;
-    /**
-     * Repoint the head at an earlier node, forking a branch. The next {@link append}
-     * becomes a child of `id`; existing nodes are untouched. Rewrites the head line.
-     *
-     * @throws if `id` is not a known node.
-     */
-    branchAt(id: string): Promise<void>;
-    /**
-     * Reset the head to before any node; the next {@link append} starts a new root.
-     * Used when re-editing the very first turn.
-     */
-    reset(): Promise<void>;
-    /**
-     * Abandon the current conversation and begin a fresh, empty session under a new
-     * id. All nodes are dropped and the leaf is reset to null, so {@link messages}
-     * is empty and the next {@link append} starts a new root; subsequent writes
-     * persist to the new session's backing file (the old one is left intact on
-     * disk). This is the `/clear` (new-session) primitive — distinct from
-     * {@link reset}, which keeps the nodes and id and only rewinds the head.
-     */
-    startNewSession(sessionId: string): void;
-    /**
-     * Resolve the active branch: the root→leaf node list reached by walking
-     * `parent` links up from `leaf` (or from `from` when given), reversed to
-     * chronological order.
-     *
-     * This is the conductor's read primitive — `resume` rehydrates the agent from
-     * `pathTo()`, and the turn loop projects it to messages via {@link messages}.
-     * Returns `[]` for an empty transcript or a dangling leaf.
-     */
-    pathTo(from?: string): TranscriptEntry[];
-    /** The active branch projected to the framework {@link AgentMessage} list. */
-    messages(from?: string): AgentMessage[];
-    /**
-     * Hydrate this store from a persisted session, replacing its current state.
-     *
-     * Reads the backend, parses it with {@link parseSessionText}, and rebuilds state
-     * via the {@link replay} reducer. If the file carried no head line, the head is
-     * pinned to the deepest leaf reachable from the entries. Returns `true` when a
-     * session was found and loaded, `false` when the backend had nothing.
-     */
-    load(sessionId?: string): Promise<boolean>;
-    /**
-     * Open a persisted session by id, returning a hydrated store (or `null` if the
-     * backend has no such session). The static counterpart to {@link load}.
-     */
-    static open(sessionId: string, options?: TranscriptStoreOptions): Promise<TranscriptStore | null>;
-    /** A point-in-time copy of the derived state (for inspection/testing). */
-    state(): TranscriptState;
-}
-/** Re-export the schema literal for callers building stores directly. */
-export { TRANSCRIPT_SCHEMA };

package/dist/types/console/auth-status.d.ts

@@ -1,28 +0,0 @@
-/**
- * Shared "does the user have a usable credential for this provider" probe.
- *
- * Used anywhere the console needs to know which providers are actually
- * callable — the `/model` picker (only list authenticated providers) and the
- * banner's Session panel (don't display an unauthenticated model as if it were
- * ready to use) both need the exact same answer, so it lives here once.
- */
-import type { OverlayServices } from "./contract";
-/**
- * Load the set of provider ids the user has USABLE credentials for, live, so a
- * mid-session `/login` (either a local vault sign-in or the "Indus Server"
- * server-tier device flow) is reflected without a restart.
- *
- * Two independent sources count: (1) any saved account in the local vault for a
- * provider `listLoginProviders()` names, and (2) a valid server session token,
- * which makes every gateway-eligible provider (`serverTierProviders()` —
- * minimax, sarvam) usable even though the server tier never writes into the
- * vault. Returns `null` until the asynchronous probe settles.
- *
- * `refreshKey` re-runs the probe whenever it changes by reference/value — a
- * short-lived overlay (the `/model` picker) can leave it at its default since
- * it remounts fresh on every open anyway, but a component mounted once for the
- * whole session (the banner, the status bar) MUST pass something that changes
- * right when a sign-in completes (e.g. the console's current status toast),
- * otherwise this only ever reflects whatever was true at session start.
- */
-export declare function useAuthenticatedProviders(services: OverlayServices | undefined, refreshKey?: unknown): Set<string> | null;