@cruxy/cli 1.0.2 → 1.0.4

package/dist/tools/types.d.ts

@@ -1,257 +0,0 @@
-import type { z, ZodTypeAny } from "zod";
-import type { CruxyConfig } from "../config/index.js";
-import type { ApprovalDecision } from "../approval/types.js";
-import type { SandboxService } from "../sandbox/index.js";
-import type { Workspace } from "../workspace/index.js";
-import type { logger } from "../utils/logger.js";
-/** The leveled logger instance shared across the CLI. */
-type Logger = typeof logger;
-/**
- * The outcome of a tool run. Tools never throw across this boundary — failures
- * are reported as `{ ok: false }` so the agent loop can feed the error back to
- * the model instead of crashing.
- */
-export type ToolResult = {
-    ok: true;
-    output: string;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * One file's worth of change inside an `apply_patch` preview. Paths are
- * project-relative (the tool relativizes them for display).
- */
-export type PatchFilePreview = {
-    op: "update";
-    path: string;
-    hunks: {
-        oldStr: string;
-        newStr: string;
-    }[];
-} | {
-    op: "create";
-    path: string;
-    lines: string[];
-    omittedLines: number;
-} | {
-    op: "delete";
-    path: string;
-};
-/**
- * An optional preview of exactly what a mutating action will change, threaded
- * from the tool into `ctx.approve` so the prompt can show it before the user
- * decides. The tool fills this in from data it has already computed.
- */
-export type ActionPreview = 
-/** The exact strings `edit_file` is about to swap. */
-{
-    type: "edit";
-    oldStr: string;
-    newStr: string;
-}
-/**
- * What `write_file` will write: whether the path already exists (overwrite vs
- * create) and the first lines of the new content, pre-capped by the tool.
- */
- | {
-    type: "write";
-    exists: boolean;
-    lines: string[];
-    omittedLines: number;
-}
-/** The full set of file changes `apply_patch` will make, for a combined diff. */
- | {
-    type: "patch";
-    files: PatchFilePreview[];
-}
-/**
- * The whole publish plan for a `vcs` action (C.15): the feature branch, the
- * conventional commit, and the PR title/body — shown as one block so the user
- * approves the entire branch → commit → push → open-PR sequence at once. C.26
- * Step 4 adds `target` (the resolved `host/owner/repo` the PR will open against)
- * so the human sees the real API destination — not just the root name — before
- * approving (⚖︎JC-4); it is re-resolved and re-checked immediately before the API
- * call, so what is shown here is what the guard holds them to.
- */
- | {
-    type: "pr";
-    branch: string;
-    base: string;
-    commitSubject: string;
-    commitBody: string;
-    prTitle: string;
-    prBody: string;
-    /** The resolved forge target parsed from `origin` at approval time. */
-    target: {
-        host: string;
-        owner: string;
-        repo: string;
-    };
-}
-/**
- * The full blast radius of a checkpoint restore (C.32): every file rollback
- * will recreate/revert/delete (as patch-style entries), plus the paths that
- * changed since the checkpoint by something *other* than the tracked run —
- * shown before the diff so the collapse cap can never hide them. Rollback
- * covers working-tree files only; commits/pushes/PRs made during the run are
- * out of scope (stated in the rendered note).
- */
- | {
-    type: "rollback";
-    checkpointId: string;
-    createdAt: string;
-    runSummary: string;
-    files: PatchFilePreview[];
-    externalPaths: string[];
-    /** The run executed shell commands, so per-file attribution is impossible. */
-    attributionUnknown: boolean;
-}
-/**
- * A multi-root rollback set (C.26 step 3): one combined preview grouped by root,
- * each root carrying its own file diffs and external-change warnings, so a single
- * U.3 approval covers restoring every touched root of a run at once (⚖︎JC-ι). One
- * `roots` entry per member of the run's `CheckpointSet`.
- */
- | {
-    type: "rollback-set";
-    runId: string;
-    createdAt: string;
-    runSummary: string;
-    roots: {
-        rootName: string;
-        checkpointId: string;
-        files: PatchFilePreview[];
-        externalPaths: string[];
-        attributionUnknown: boolean;
-    }[];
-};
-/**
- * A side-effecting action a tool wants to take, passed to `ctx.approve`. The
- * `kind` set grows as more mutating tools land; it drives the permission prompt.
- */
-export interface ApproveAction {
-    /** The category of side effect being requested. */
-    kind: "write" | "edit" | "shell" | "patch" | "vcs" | "rollback" | "test" | "mcp";
-    /** Absolute resolved path the action targets (write/edit). */
-    path?: string;
-    /** The command to run (shell / test). */
-    command?: string;
-    /** MCP tool call (C.27): the server id and the tool name being invoked. The
-     * gate keys a session grant on this exact pair, so approving one MCP tool never
-     * covers another — and a server can never mark its own tool low-risk. */
-    server?: string;
-    tool?: string;
-    /**
-     * The declared workspace root this action acts in (C.26). `vcs` sets it to the
-     * root a pull request was selected for (C.26 Step 4): it may be non-primary, and
-     * the checkpoint gate attributes the vcs checkpoint to exactly this root. `shell`/
-     * `test` still set it to the primary as an attribution seam — their non-primary
-     * support is Step 5 (JC-β residual), so the gate hard-attributes them to the
-     * primary regardless of this value. File actions carry their root in the resolved
-     * absolute `path`/preview instead, so they leave this unset.
-     */
-    root?: string;
-    /** Exact-change preview rendered above the prompt (write/edit/patch/vcs/rollback). */
-    preview?: ActionPreview;
-}
-/**
- * Ambient capabilities handed to every tool at execution time. Tools run on the
- * user's machine, so this is the only sanctioned door to the filesystem root
- * (`cwd`), configuration, logging, and the permission gate.
- */
-export interface ToolContext {
-    /** Absolute path the tool should treat as its working root. */
-    cwd: string;
-    /**
-     * The declared workspace root set for this session (C.26). Path-taking tools
-     * resolve *through* this rather than through `cwd`, so a multi-root session
-     * confines each call to the one root it selects. **Required** (C.26 Step 6): a
-     * construction site that fails to thread it is a *compile error*, not a runtime
-     * primary-default — closing the omission hole the old optional field left. The
-     * runtime always sets it; a single-root caller builds one with `sessionWorkspace`.
-     * (The type catches *omission*; it cannot catch a *fabricated* workspace threaded
-     * through — the `no-split-brain` grep guard covers that. See its header.) `cwd`
-     * remains equal to `workspace.primary().absPath`.
-     */
-    workspace: Workspace;
-    /** Fully-resolved CLI configuration. */
-    config: CruxyConfig;
-    /** Shared leveled logger (diagnostics to stderr, `print` to stdout). */
-    logger: Logger;
-    /**
-     * The approval gate every side-effecting tool funnels through, **before** any
-     * mutation. Returns a decision: `{allow:true}` to proceed, or `{allow:false,
-     * feedback?}` (a clean rejection whose feedback is surfaced to the agent).
-     * Backed by the risk-tiered `ApprovalService` (see src/approval); it may
-     * *throw* `CRUXY_E_APPROVAL_REQUIRED` when it can't ask (non-interactive),
-     * which propagates to the boundary rather than being swallowed. Read-only
-     * tools never call this.
-     */
-    requestApproval(action: ApproveAction): Promise<ApprovalDecision>;
-    /**
-     * Whether per-root checkpointing is active for this session (C.26 step 3). It is
-     * the single fact that lifts the JC-1 non-primary-write refusal: a write to a
-     * non-primary root is permitted **iff** this is true, because a true value means
-     * a per-root checkpoint gate is wired that captures the write (get-or-creates the
-     * root's service and snapshots it) before it reaches disk. False/absent → a
-     * non-primary write is still refused with `CRUXY_E_MULTIROOT_WRITE_DEFERRED`, so
-     * a checkpoints-disabled session never widens un-restorable writes to siblings.
-     * Set together with `requestApproval` (the gate), so permit and capture are one
-     * decision — never lift-then-verify.
-     */
-    checkpointsActive?: boolean;
-    /**
-     * Isolation substrate for the shell + test tools (C.16). Present ONLY when
-     * the sandbox is enabled; when set, `run_command`/`run_tests` execute the
-     * approved command inside the container and NEVER on the host. Its mere
-     * presence is the switch — there is no host fallback once it is set (an
-     * unavailable runtime fails loud at construction, before this is ever
-     * populated). Absent → host execution, unchanged.
-     */
-    sandbox?: SandboxService;
-    /**
-     * Cooperative cancellation for in-flight tool work (C.33). Set on a subagent's
-     * ctx when it runs inside a parallel fan-out: when a fatal sibling failure or
-     * Ctrl-C aborts the batch, this signal fires, and a long-running `run_command`
-     * kills its whole process tree instead of leaving it orphaned — the C.12/C.16
-     * kill-tree discipline extended to N concurrent children. Absent → no external
-     * cancellation (the tool's own timeout still applies), unchanged behaviour.
-     */
-    signal?: AbortSignal;
-}
-/**
- * The one interface every tool implements. `parameters` is a zod schema; it both
- * validates the model's arguments and (via the registry) becomes the wire-format
- * JSON Schema advertised to the provider.
- */
-export interface Tool<Schema extends ZodTypeAny = ZodTypeAny> {
-    /** Unique, snake_case identifier the model uses to call the tool. */
-    name: string;
-    /** One-line description shown to the model. */
-    description: string;
-    /** Zod schema for the tool's input arguments. */
-    parameters: Schema;
-    /**
-     * An optional pre-rendered JSON Schema to advertise to the provider *verbatim*
-     * instead of deriving one from {@link parameters}. Used only by proxied tools
-     * whose schema originates elsewhere and cannot be reconstructed from zod — the
-     * MCP adapter (C.27) sets this to a server's own (bounds-capped) input schema
-     * while keeping a permissive `parameters` for local validation. Built-in tools
-     * leave it unset and are advertised from their zod schema as before.
-     */
-    rawInputSchema?: Record<string, unknown>;
-    /**
-     * Optional per-turn lifecycle hook (C.13). {@link Session.send} calls it on
-     * every tool in the session registry at the start of each user turn, before the
-     * model runs. A tool that carries per-episode state — e.g. `run_tests`' consecutive-
-     * failure breaker — resets it here so a fresh instruction starts clean, while that
-     * state still latches across the many model iterations *within* one turn. Tools
-     * with no per-turn state omit it (a subagent/one-shot run is a single episode, so
-     * a missing hook simply means the state lives for that whole run).
-     */
-    onTurnStart?(): void;
-    /** Run the tool against validated `input` and the ambient `ctx`. */
-    execute(input: z.infer<Schema>, ctx: ToolContext): Promise<ToolResult>;
-}
-export {};

package/dist/usage/collect.d.ts

@@ -1,40 +0,0 @@
-import type { Usage } from "@cruxy/sdk";
-import type { UsageRecord } from "./types.js";
-/**
- * Usage collection (C.22). Accumulates per-request usage exactly as the agent
- * loop reports it — one {@link UsageEntry} per completed model request — and
- * emits a {@link UsageRecord} for the run.
- *
- * The one honesty invariant: `usage: undefined` (the loop's signal that the
- * provider returned NO usage event for a request) is recorded as `undefined`
- * token counts — the honest "unknown". A provider-reported `0` arrives as a real
- * `Usage` and is stored as `0`. Nothing is estimated, re-tokenized, or
- * zero-filled, and this module makes ZERO network calls.
- */
-/** What the loop hands over for one completed request. */
-export interface RequestUsage {
-    /** The routing tier (C.30) the request ran on, if routing was active. */
-    tier?: string;
-    /**
-     * The provider's usage for THIS request, or `undefined` when the provider
-     * emitted no usage event (⇒ tokens are unknown, not zero).
-     */
-    usage?: Usage;
-}
-/** Wall clock as an injectable seam so tests are deterministic. */
-export type Clock = () => string;
-export declare class UsageCollector {
-    private readonly now;
-    private readonly entries;
-    constructor(now?: Clock);
-    /**
-     * Record one completed request. When `req.usage` is absent the entry's token
-     * counts stay `undefined` — the provider reported nothing, so we assert
-     * nothing. A real reported `0` is preserved as `0`.
-     */
-    record(req: RequestUsage): void;
-    /** How many requests have been recorded so far. */
-    get count(): number;
-    /** Snapshot the collected entries into a persistable {@link UsageRecord}. */
-    toRecord(runId: string, sessionId: string | undefined, startedAt: string): UsageRecord;
-}

package/dist/usage/cost.d.ts

@@ -1,19 +0,0 @@
-import type { PriceTable, TierPrice } from "./types.js";
-/**
- * Token → cost mapping (C.22). The whole discipline lives in one rule: a cost is
- * produced ONLY when the tier has a configured price AND at least one token side
- * is known. Otherwise the result is `undefined` — cost is omitted, tokens are
- * still shown, and NO dollar figure is ever fabricated. Prices are per MILLION
- * tokens (see {@link TierPrice}). Keyed by tier only (U.8 gag). No network.
- */
-/** The configured price for a tier, or `undefined` when the tier is unpriced. */
-export declare function priceForTier(tier: string, prices: PriceTable): TierPrice | undefined;
-/**
- * Compute the cost of a tier's usage, or `undefined` when it cannot be stated
- * honestly:
- *  - no configured price for the tier → `undefined` (cost omitted).
- *  - both token counts unknown → `undefined` (nothing real to price).
- * A known side is priced; an unknown side contributes nothing (never a
- * fabricated 0-token charge). tokens/1e6 × price, summed.
- */
-export declare function costFor(tier: string, inputTokens: number | undefined, outputTokens: number | undefined, prices: PriceTable): number | undefined;

package/dist/usage/index.d.ts

@@ -1,15 +0,0 @@
-/**
- * Usage telemetry + cost tracking (C.22) — LOCAL usage accounting only.
- *
- * NO-PHONE-HOME GUARANTEE: nothing here transmits anything. This module reads
- * and writes ONE local file under `~/.cruxy/usage` and renders to the terminal;
- * it imports no provider, no transport, and makes no `fetch`/HTTP call. The
- * `@cruxy/sdk` import below is a TYPE-only import (`Usage`), erased at build. A
- * future opt-in remote report would be a new, clearly-named seam — this build
- * ships nothing that sends. Asserted by the runtime + static no-phone-home tests.
- */
-export * from "./types.js";
-export { UsageCollector, type RequestUsage, type Clock } from "./collect.js";
-export { costFor, priceForTier } from "./cost.js";
-export { loadUsage, appendRun, usageStorePath } from "./store.js";
-export { summarizeRuns, renderSummary, formatCost, type SummarizeOptions, } from "./summary.js";

package/dist/usage/store.d.ts

@@ -1,37 +0,0 @@
-import { CruxyError } from "../errors/index.js";
-import { type UsageFile, type UsageRecord } from "./types.js";
-/**
- * The usage store (C.22): a single JSON file under `~/.cruxy/usage`, holding a
- * bounded, newest-last list of run records. Pure DATA — parsed with the strict
- * schema, NEVER eval'd — and written `0600` (personal accounting). This module
- * touches only the local filesystem; it makes ZERO network calls.
- *
- * Reads are non-fatal by contract: a missing file is empty (not an error); a
- * corrupt/unreadable one yields an empty result plus a coded
- * {@link usageRead} error the caller can surface and SKIP — a broken usage file
- * never crashes a run.
- */
-/** `~/.cruxy/usage/runs.json` — the single usage store file. */
-export declare function usageStorePath(): string;
-/**
- * Load and validate the store. Never throws. A missing file → empty, no error.
- * Invalid JSON or a schema mismatch → empty + a `CRUXY_E_USAGE_READ` error
- * (skip, don't crash). The raw text is parsed with `JSON.parse` only — a store
- * file is never executed, so a hand-edited file cannot run code.
- */
-export declare function loadUsage(file?: string): {
-    data: UsageFile;
-    error?: CruxyError;
-};
-/**
- * Append one run's usage, pruning oldest-first to the last `retention` runs.
- * Never throws — any failure (a corrupt existing file that cannot be safely
- * appended to, or a write error) is returned as a coded error for the caller to
- * downgrade to a warning, so persistence never takes a run down with it.
- */
-export declare function appendRun(record: UsageRecord, opts?: {
-    retention: number;
-    file?: string;
-}): {
-    error?: CruxyError;
-};

package/dist/usage/summary.d.ts

@@ -1,32 +0,0 @@
-import type { Theme } from "../theme/index.js";
-import type { PriceTable, UsageRecord, UsageSummary } from "./types.js";
-/**
- * Usage aggregation + rendering (C.22). Aggregation sums only KNOWN token
- * counts and counts the requests that reported none separately, so a total is
- * never inflated by a fabricated zero — and the renderer ALWAYS surfaces that
- * count, so a total can never be misread as complete while requests are silently
- * excluded. Costs appear only for priced tiers. Only tier names ever reach the
- * output (U.8 gag). Pure — no I/O, no network.
- */
-export interface SummarizeOptions {
-    prices: PriceTable;
-    /** Currency label to prefix costs; "" when the user configured none. */
-    currency: string;
-}
-/** Aggregate one or more run records into a {@link UsageSummary}. */
-export declare function summarizeRuns(runs: readonly UsageRecord[], opts: SummarizeOptions): UsageSummary;
-/**
- * Format a cost figure honestly: enough precision for small per-run costs,
- * trailing zeros trimmed. Prefixed by the currency label only when one is set
- * (never an assumed symbol). Callers pass a cost only when it was actually
- * computed (priced + known tokens).
- */
-export declare function formatCost(n: number, currency: string): string;
-/**
- * Render a {@link UsageSummary} to a single themed line. Honors the theme
- * end-to-end: NO_COLOR yields zero ANSI (identity stylers), and screen-reader
- * mode swaps the arrow glyphs for words. The count of requests that reported no
- * usage is ALWAYS shown when non-zero, so the total is never mistaken for a
- * complete accounting.
- */
-export declare function renderSummary(summary: UsageSummary, t: Theme): string;

package/dist/usage/types.d.ts

@@ -1,220 +0,0 @@
-import { z } from "zod";
-import { MODEL_TIERS } from "../brand/voice.js";
-/**
- * Usage telemetry + cost tracking (C.22): types for LOCAL, honest usage
- * accounting. Every number here is a real figure the provider reported — a token
- * count is present only when the provider returned usage for that request, and
- * `undefined` (never `0`) when it did not. Nothing in this module is ever
- * transmitted anywhere (see the module barrel's no-phone-home note).
- */
-/** Bump when the on-disk usage file shape changes (enables future migration). */
-export declare const USAGE_FILE_VERSION: 1;
-/**
- * One model request's usage. A request that reported no usage keeps
- * `inputTokens`/`outputTokens` as `undefined` — the honest "unknown", never
- * zero-filled or re-tokenized. A provider-reported `0` is stored as `0` (a real
- * count), so the two cases stay distinguishable downstream.
- */
-export declare const UsageEntrySchema: z.ZodObject<{
-    /** The routing tier (C.30) this request ran on; absent when routing is inert. */
-    tier: z.ZodOptional<z.ZodString>;
-    /** Provider-reported prompt tokens; `undefined` ⇔ no usage was reported. */
-    inputTokens: z.ZodOptional<z.ZodNumber>;
-    /** Provider-reported completion tokens; `undefined` ⇔ no usage was reported. */
-    outputTokens: z.ZodOptional<z.ZodNumber>;
-    /** ISO-8601 timestamp the request completed. */
-    at: z.ZodString;
-}, "strict", z.ZodTypeAny, {
-    at: string;
-    tier?: string | undefined;
-    inputTokens?: number | undefined;
-    outputTokens?: number | undefined;
-}, {
-    at: string;
-    tier?: string | undefined;
-    inputTokens?: number | undefined;
-    outputTokens?: number | undefined;
-}>;
-export type UsageEntry = z.infer<typeof UsageEntrySchema>;
-/** One run's usage: an ordered list of per-request entries. */
-export declare const UsageRecordSchema: z.ZodObject<{
-    /** Unique id for this run (one `session.send`). */
-    runId: z.ZodString;
-    /** Groups runs of one interactive session, so `--session` aggregates them. */
-    sessionId: z.ZodOptional<z.ZodString>;
-    /** ISO-8601 timestamp the run started. */
-    startedAt: z.ZodString;
-    entries: z.ZodArray<z.ZodObject<{
-        /** The routing tier (C.30) this request ran on; absent when routing is inert. */
-        tier: z.ZodOptional<z.ZodString>;
-        /** Provider-reported prompt tokens; `undefined` ⇔ no usage was reported. */
-        inputTokens: z.ZodOptional<z.ZodNumber>;
-        /** Provider-reported completion tokens; `undefined` ⇔ no usage was reported. */
-        outputTokens: z.ZodOptional<z.ZodNumber>;
-        /** ISO-8601 timestamp the request completed. */
-        at: z.ZodString;
-    }, "strict", z.ZodTypeAny, {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-    }, {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    entries: {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-    }[];
-    runId: string;
-    startedAt: string;
-    sessionId?: string | undefined;
-}, {
-    entries: {
-        at: string;
-        tier?: string | undefined;
-        inputTokens?: number | undefined;
-        outputTokens?: number | undefined;
-    }[];
-    runId: string;
-    startedAt: string;
-    sessionId?: string | undefined;
-}>;
-export type UsageRecord = z.infer<typeof UsageRecordSchema>;
-/** The persisted store: a bounded, newest-last list of run records. */
-export declare const UsageFileSchema: z.ZodObject<{
-    version: z.ZodLiteral<1>;
-    runs: z.ZodArray<z.ZodObject<{
-        /** Unique id for this run (one `session.send`). */
-        runId: z.ZodString;
-        /** Groups runs of one interactive session, so `--session` aggregates them. */
-        sessionId: z.ZodOptional<z.ZodString>;
-        /** ISO-8601 timestamp the run started. */
-        startedAt: z.ZodString;
-        entries: z.ZodArray<z.ZodObject<{
-            /** The routing tier (C.30) this request ran on; absent when routing is inert. */
-            tier: z.ZodOptional<z.ZodString>;
-            /** Provider-reported prompt tokens; `undefined` ⇔ no usage was reported. */
-            inputTokens: z.ZodOptional<z.ZodNumber>;
-            /** Provider-reported completion tokens; `undefined` ⇔ no usage was reported. */
-            outputTokens: z.ZodOptional<z.ZodNumber>;
-            /** ISO-8601 timestamp the request completed. */
-            at: z.ZodString;
-        }, "strict", z.ZodTypeAny, {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-        }, {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-        }>, "many">;
-    }, "strict", z.ZodTypeAny, {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }, {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }>, "many">;
-}, "strict", z.ZodTypeAny, {
-    version: 1;
-    runs: {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }[];
-}, {
-    version: 1;
-    runs: {
-        entries: {
-            at: string;
-            tier?: string | undefined;
-            inputTokens?: number | undefined;
-            outputTokens?: number | undefined;
-        }[];
-        runId: string;
-        startedAt: string;
-        sessionId?: string | undefined;
-    }[];
-}>;
-export type UsageFile = z.infer<typeof UsageFileSchema>;
-/**
- * A per-tier price, in the user's own currency, PER MILLION TOKENS. Chosen over
- * per-token so prices read the way LLM pricing is quoted and don't lose
- * precision to tiny floats. Configured by the user under `usage.prices.<tier>`;
- * cruxy ships NO prices (a bundled table would imply upstream identities and go
- * stale) — with none configured, cost is omitted entirely.
- */
-export interface TierPrice {
-    /** Price per 1,000,000 input tokens. */
-    input: number;
-    /** Price per 1,000,000 output tokens. */
-    output: number;
-}
-/**
- * Prices keyed by TIER ONLY (kavi/vaani/mira) — the type literally cannot name
- * an upstream model, so the U.8 gag holds by construction. Partial: any tier may
- * be unpriced (its cost is then omitted, tokens still shown).
- */
-export type PriceTable = Partial<Record<(typeof MODEL_TIERS)[number], TierPrice>>;
-/** Aggregated usage for one tier across the summarized runs. */
-export interface TierUsage {
-    tier: string;
-    /** Sum of KNOWN input tokens; `undefined` if no request on this tier reported usage. */
-    inputTokens?: number;
-    /** Sum of KNOWN output tokens; `undefined` if none reported. */
-    outputTokens?: number;
-    /** Requests attributed to this tier. */
-    requests: number;
-    /** How many of those reported no usage (surfaced, never silently dropped). */
-    requestsWithoutUsage: number;
-    /** Cost, ONLY when this tier is priced AND has known tokens; else omitted. */
-    cost?: number;
-}
-/** The aggregate over one or more runs — what the summary renderer consumes. */
-export interface UsageSummary {
-    perTier: TierUsage[];
-    /** Sum of KNOWN input tokens across all runs; `undefined` if none known. */
-    totalInputTokens?: number;
-    /** Sum of KNOWN output tokens across all runs; `undefined` if none known. */
-    totalOutputTokens?: number;
-    /** Sum of per-tier costs; `undefined` unless ≥1 tier was priced. */
-    totalCost?: number;
-    /** True iff at least one tier had a configured price (cost is shown). */
-    priced: boolean;
-    /** Currency label to prefix costs with; "" when the user configured none. */
-    currency: string;
-    /** Total requests across all runs that reported no usage (rendered visibly). */
-    requestsWithoutUsage: number;
-    /** Total requests across all runs. */
-    requests: number;
-    /** How many runs were aggregated. */
-    runCount: number;
-}

package/dist/utils/child-tree.d.ts

@@ -1,33 +0,0 @@
-/**
- * The process-EXIT backstop for long-lived child trees (C.12 LSP servers, C.27
- * MCP servers). The platform-aware spawn/kill primitives themselves now live in
- * {@link ./process-tree.js} — {@link killTree} is re-exported here unchanged so
- * existing LSP/MCP importers keep their import path, and so this backstop and
- * those transports reap trees the SAME way on every platform (negative-PID
- * `SIGKILL` on POSIX, `taskkill /T /F` on win32 — no more orphaned grandchildren
- * on Windows).
- *
- * A per-session graceful shutdown covers the normal path, but a hard exit
- * (Ctrl-C, an uncaught throw) would otherwise orphan these trees. So every live
- * child's pid is tracked in one process-wide set and force-killed on teardown.
- * Handlers are installed ONCE, lazily, on the first registration — so unit tests
- * that never spawn a real process never install them.
- *
- * This module is deliberately transport-agnostic: LSP (Content-Length framing)
- * and MCP (newline-delimited JSON) share the SAME backstop, so `killTrackedTrees`
- * on exit reaps both and there is a single source of truth for "no orphans".
- */
-import { killTree } from "./process-tree.js";
-export { killTree };
-/**
- * Force-kill the process group of every tracked-but-not-yet-shut-down child,
- * then forget them. This is exactly what the `exit`/`SIGINT`/`SIGTERM`/`SIGHUP`
- * handlers run — the last line against orphaned server trees on a hard exit.
- * Exported so it is directly testable without raising real process signals.
- * Idempotent: a second call is a no-op.
- */
-export declare function killTrackedTrees(): void;
-/** Number of child trees currently tracked by the exit backstop (for tests). */
-export declare function trackedTreeCount(): number;
-/** Track a live child for the exit backstop; returns a deregister callback. */
-export declare function registerForCleanup(pid: number | undefined): () => void;

package/dist/utils/git.d.ts

@@ -1,17 +0,0 @@
-/**
- * Branch name plus the raw `git status --porcelain` text for `cwd`, or `null`
- * when it isn't a git repository (or git is unavailable). Backs the `git_status`
- * tool, which surfaces the porcelain output to the model.
- */
-export declare function getGitStatus(cwd: string): {
-    branch: string;
-    status: string;
-} | null;
-/**
- * Compact git context for the system prompt: current branch and whether the
- * working tree has uncommitted changes. `null` when not a repo / git missing.
- */
-export declare function getGitInfo(cwd: string): {
-    branch: string;
-    dirty: boolean;
-} | null;