@wrongstack/core 0.284.1 → 0.286.0

package/dist/types/tool.d.ts

@@ -0,0 +1,252 @@
+import type { Context } from '../core/context.js';
+export type Permission = 'auto' | 'confirm' | 'deny';
+/**
+ * Risk tier for tools in UI/audit surfaces. YOLO auto-approves non-denied
+ * calls regardless of risk tier; when YOLO is off, risk can inform prompts.
+ *
+ * - `safe`       — read-only, no side effects (read, glob, grep, etc.)
+ * - `standard`   — non-destructive writes and mutations (write, edit, safe shell commands)
+ * - `destructive` — irreversible or broadside effects (recursive deletes, db drops, etc.)
+ */
+export type RiskTier = 'safe' | 'standard' | 'destructive';
+/**
+ * Icon identifiers for tools — each UI (WebUI/TUI/REPL) maps these to its own icon library.
+ * Add the icon directly on each Tool so all UIs consume the same canonical value.
+ */
+export type ToolIconId = 'file' | 'edit' | 'search' | 'folder' | 'terminal' | 'web' | 'git' | 'tree' | 'code' | 'test' | 'package' | 'document' | 'scaffold' | 'todo' | 'plan' | 'task' | 'meta' | 'index' | 'json' | 'diff' | 'logs' | 'settings' | 'fallback';
+export interface JSONSchema {
+    type?: string | undefined;
+    properties?: Record<string, JSONSchema>;
+    required?: string[] | undefined;
+    items?: JSONSchema | undefined;
+    enum?: unknown[] | undefined;
+    description?: string | undefined;
+    [k: string]: unknown;
+}
+/**
+ * Tool progress event — yielded by `Tool.executeStream` to give the UI
+ * something to render while a long-running tool works. The executor
+ * publishes each event via EventBus as `tool.progress` so the TUI, logger,
+ * and observability layer can consume them uniformly.
+ *
+ * Keep events small. They are buffered through the EventBus synchronously
+ * and rendered on the main thread.
+ */
+export interface ToolProgressEvent {
+    /**
+     * - `log`           — verbose informational message (e.g. "scanning…")
+     * - `warning`       — non-fatal issue (e.g. "skipped X due to ENOENT")
+     * - `metric`        — numeric data (e.g. files scanned so far)
+     * - `file_changed`  — a tool that mutates the workspace announces a write
+     * - `partial_output` — stream of textual output (bash stdout, fetch body)
+     */
+    type: 'log' | 'warning' | 'metric' | 'file_changed' | 'partial_output';
+    text?: string | undefined;
+    data?: Record<string, unknown>;
+}
+/**
+ * Terminal event for `executeStream`. The output must match the tool's
+ * declared output type — the executor unwraps `output` and treats it like
+ * a normal `execute` return value.
+ */
+export interface ToolFinalEvent<O> {
+    type: 'final';
+    output: O;
+}
+export type ToolStreamEvent<O = unknown> = ToolProgressEvent | ToolFinalEvent<O>;
+export interface Tool<I = unknown, O = unknown> {
+    name: string;
+    description: string;
+    /**
+     * Pre-computed token estimate for this tool's definition (name +
+     * description + JSON-serialized inputSchema). Set by ToolRegistry on
+     * registration; consumed by estimateToolDefTokens / estimateRequestTokens
+     * to skip redundant JSON.stringify on every context-pressure check.
+     */
+    _estDefTokens?: number | undefined;
+    usageHint?: string | undefined;
+    /** Structured guidance for choosing between similar tools. */
+    selection?: {
+        /** A concise boundary where this tool should not be selected. */
+        doNotUseWhen: string;
+        /** Tool names the model should prefer for that boundary. */
+        useInstead?: readonly string[] | undefined;
+    } | undefined;
+    /** Optional category for grouping in help lists and system prompts. */
+    category?: string | undefined;
+    inputSchema: JSONSchema;
+    permission: Permission;
+    mutating: boolean;
+    /**
+     * Risk tier for selective YOLO gating. When YOLO is active, clearly
+     * destructive calls still emit `confirm`. Defaults to `standard` when
+     * omitted — callers should always check `riskTier` after the basic
+     * permission decision.
+     */
+    riskTier?: RiskTier | undefined;
+    /**
+     * Input-field name that the permission policy should match trust rules
+     * against. Without this, the policy falls back to a heuristic
+     * (`command` / `path` / `url` / `name`) that can collide across tools —
+     * e.g. an HTTP tool whose `path` means "request path" would be checked
+     * against filesystem-path trust rules. Set explicitly to avoid the
+     * cross-tool subject collision.
+     *
+     * The named field's value must be a string at runtime; non-string values
+     * fall back to the heuristic.
+     */
+    subjectKey?: string | undefined;
+    maxOutputBytes?: number | undefined;
+    timeoutMs?: number | undefined;
+    /**
+     * The tool owns its timeout/idle policy and only needs the executor to
+     * propagate the parent abort signal. Use this sparingly for orchestration
+     * tools such as `delegate` that already enforce a heartbeat-aware timeout;
+     * otherwise the executor's fixed max-tool timeout can kill healthy work.
+     */
+    managesOwnTimeout?: boolean | undefined;
+    /**
+     * Hint for the TUI spinner — does NOT affect actual timeout enforcement.
+     * Use `timeoutMs` for hard limits. Leave undefined when duration varies
+     * unpredictably.
+     */
+    estimatedDurationMs?: number | undefined;
+    /**
+     * Declarative security capabilities granted by this tool.
+     *
+     * Examples: "shell.arbitrary", "fs.write", "fs.write.outside-project",
+     * "net.outbound", "mcp.proxy", "subagent.spawn", "config.mutate".
+     *
+     * These are used by permission policies (especially subagent guards) and
+     * future capability-based allowlists. Prefer well-known values over ad-hoc strings.
+     *
+     * This field is optional for backward compatibility. Tools without it are
+     * treated conservatively by guards.
+     */
+    capabilities?: readonly string[] | undefined;
+    /**
+     * Icon identifier for this tool — consumed by all UIs (WebUI/TUI/REPL) to
+     * render a tool-specific icon instead of a generic fallback.
+     * Each UI maps this id to its own icon library.
+     */
+    icon?: ToolIconId | undefined;
+    execute(input: I, ctx: Context, opts: {
+        signal: AbortSignal;
+    }): Promise<O>;
+    /**
+     * Optional cross-field validation hook. Called by the executor AFTER
+     * JSON Schema validation passes and AFTER PreToolUse hooks may have
+     * rewritten the input, but BEFORE permission checks and execution.
+     *
+     * Use this for invariants the JSON Schema cannot express — e.g.
+     * `old_string !== new_string` in edit, or `end > start` in a range tool.
+     * Return an array of validation errors (empty = valid). The executor
+     * surfaces them to the model just like schema validation errors, so the
+     * model can self-correct without the tool's `execute()` running.
+     *
+     * P3 #16 (before-release.md): tools that implement cross-field checks
+     * inside `execute()` can migrate them here for earlier rejection and
+     * consistent error formatting.
+     */
+    validate?(input: I): string[];
+    /**
+     * Optional streaming variant. When defined, the executor prefers this
+     * over `execute` — yielded events become `tool.progress` EventBus events
+     * and the terminal `final` event provides the output. Tools that don't
+     * have intermediate state shouldn't implement this; the default `execute`
+     * path is more efficient.
+     */
+    executeStream?(input: I, ctx: Context, opts: {
+        signal: AbortSignal;
+    }): AsyncIterable<ToolStreamEvent<O>>;
+    /**
+     * Optional teardown hook fired by the executor when the tool's run is
+     * aborted (signal triggered). Errors thrown here are swallowed so they
+     * never mask the originating failure.
+     *
+     * **When to use `cleanup` vs `ctx.registerAbortHook`:**
+     *
+     * - Use `cleanup` for resources **owned by the tool author** that are
+     *   established at execute-time: child processes spawned by the tool,
+     *   file handles opened by the tool, network connections initiated by
+     *   the tool. The lifecycle is co-located with the tool definition, so
+     *   readers see the resource and its teardown in one place.
+     *
+     *   ```ts
+     *   async execute(input, ctx, opts) {
+     *     const child = spawn(...);
+     *     // … tool work …
+     *   },
+     *   async cleanup(_input, _ctx) {
+     *     // best-effort kill of any child still running
+     *   }
+     *   ```
+     *
+     * - Use `ctx.registerAbortHook` for **context-scoped teardown** registered
+     *   dynamically inside `execute`: when the tool delegates to a library
+     *   that needs cancellation, or when the resource is created lazily
+     *   somewhere down the call stack and the natural cleanup point isn't
+     *   at the tool boundary. The hook fires when the **agent run** ends,
+     *   not when this specific tool call aborts.
+     *
+     *   ```ts
+     *   async execute(input, ctx, opts) {
+     *     const handle = openHelper();
+     *     ctx.registerAbortHook(() => handle.dispose());
+     *     // … work …
+     *   }
+     *   ```
+     *
+     * If both are registered for the same resource, `cleanup` fires first
+     * (on tool abort) and the abort-hook fires after on the wider run abort.
+     * Avoid double-free by gating one on the other's effect, or pick a single
+     * teardown channel per resource.
+     */
+    cleanup?(input: I, ctx: Context): Promise<void>;
+    /**
+     * Optional custom output serializer. When present, the executor's output
+     * serializer calls this INSTEAD of the central `renderToolObject()` switch
+     * — the tool owns its own pretty-printing.
+     *
+     * Return a string representation of the output that the model will see in
+     * its tool_result block. The serializer applies the iteration output cap
+     * AFTER this runs, so don't worry about truncation.
+     *
+     * P3 #21 (before-release.md): `renderToolObject()` is a god function with
+     * 30+ per-tool branches, far from each tool's definition. New tools that
+     * want custom output no longer need to add a branch there — they implement
+     * this method instead. Existing branches stay until migrated incrementally.
+     */
+    serialize?(output: O, input: I): string;
+}
+export interface ToolCallContext {
+    tool: Tool;
+    input: unknown;
+    callId: string;
+    ctx: Context;
+    signal: AbortSignal;
+}
+/**
+ * Error categories for tool execution failures.
+ * Used by the executor to classify errors and determine retry strategy.
+ */
+export declare enum ToolErrorCategory {
+    TRANSIENT = "transient",// ETIMEDOUT, ECONNRESET, network timeout, HTTP 429/503
+    NOT_FOUND = "not_found",// ENOENT, ENOTDIR, HTTP 404
+    PERMISSION = "permission",// EACCES, EPERM, HTTP 401/403
+    VALIDATION = "validation",// schema validation error, HTTP 400
+    FATAL = "fatal"
+}
+/**
+ * Structured tool error information for the LLM and retry logic.
+ */
+export interface ToolErrorInfo {
+    readonly category: ToolErrorCategory;
+    /** Whether the operation can be retried automatically. */
+    readonly retryable: boolean;
+    /** User-facing message describing the error. */
+    readonly userMessage: string;
+    /** Optional technical detail for debugging. */
+    readonly detail?: string;
+}
+//# sourceMappingURL=tool.d.ts.map

package/dist/types/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/types/tool.ts"],"names":[],"mappings":"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"}

package/dist/types/utility-types.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Shared type-level utilities used across WrongStack packages.
+ *
+ * These are pure type helpers with no runtime footprint. They solve
+ * recurring TypeScript pattern problems that the standard library
+ * types (Pick, Omit, Partial, etc.) don't handle well — particularly
+ * around discriminated unions and distribution.
+ */
+/**
+ * Distributive version of the built-in {@link Omit}.
+ *
+ * **Why this exists:** The standard `Omit<T, K>` is defined as
+ * `Pick<T, Exclude<keyof T, K>>`. When `T` is a discriminated union,
+ * `keyof T` returns the *intersection* of all members' keys — not
+ * what you want. `Omit<{ a: 1 } | { b: 2 }, 'id'>` collapses to `{}`.
+ *
+ * `DistributiveOmit` forces distribution over each union member via
+ * a conditional type (`T extends unknown`), yielding the expected
+ * result: `Omit<{ a: 1 }, 'id'> | Omit<{ b: 2 }, 'id'>`.
+ *
+ * @example
+ * ```ts
+ * type Entry = { id: number; kind: 'user'; text: string }
+ *            | { id: number; kind: 'tool'; name: string };
+ *
+ * type Broken  = Omit<Entry, 'id'>;            // {}
+ * type Working = DistributiveOmit<Entry, 'id'>; // { kind: 'user'; text } | { kind: 'tool'; name }
+ * ```
+ */
+export type DistributiveOmit<T, K extends string | number | symbol> = T extends unknown ? Omit<T, K> : never;
+//# sourceMappingURL=utility-types.d.ts.map

package/dist/types/utility-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utility-types.d.ts","sourceRoot":"","sources":["../../src/types/utility-types.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,MAAM,GAAG,MAAM,GAAG,MAAM,IAAI,CAAC,SAAS,OAAO,GACnF,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,GACV,KAAK,CAAC"}

package/dist/utils/assert-never.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Exhaustiveness check for discriminated union switches.
+ * Place in the `default` branch of a switch over a union type
+ * to get a compile-time error when a new variant is added.
+ *
+ * @example
+ * switch (block.type) {
+ *   case 'text': return renderText(block);
+ *   case 'tool_use': return renderToolUse(block);
+ *   default: return assertNever(block);
+ * }
+ */
+export declare function assertNever(x: never, message?: string): never;
+//# sourceMappingURL=assert-never.d.ts.map

package/dist/utils/assert-never.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assert-never.d.ts","sourceRoot":"","sources":["../../src/utils/assert-never.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,KAAK,CAM7D"}

package/dist/utils/atomic-write.d.ts

@@ -0,0 +1,12 @@
+export interface AtomicWriteOptions {
+    mode?: number | undefined;
+    encoding?: BufferEncoding | undefined;
+}
+export interface FileLockOptions {
+    timeoutMs?: number | undefined;
+    staleMs?: number | undefined;
+}
+export declare function atomicWrite(targetPath: string, content: string | Uint8Array, opts?: AtomicWriteOptions): Promise<void>;
+export declare function ensureDir(dir: string): Promise<void>;
+export declare function withFileLock<T>(targetPath: string, fn: () => Promise<T>, opts?: FileLockOptions): Promise<T>;
+//# sourceMappingURL=atomic-write.d.ts.map

package/dist/utils/atomic-write.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"atomic-write.d.ts","sourceRoot":"","sources":["../../src/utils/atomic-write.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,kBAAkB;IACjC,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,QAAQ,CAAC,EAAE,cAAc,GAAG,SAAS,CAAC;CACvC;AAED,MAAM,WAAW,eAAe;IAC9B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC9B;AAED,wBAAsB,WAAW,CAC/B,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,MAAM,GAAG,UAAU,EAC5B,IAAI,GAAE,kBAAuB,GAC5B,OAAO,CAAC,IAAI,CAAC,CA4Df;AAED,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE1D;AAED,wBAAsB,YAAY,CAAC,CAAC,EAClC,UAAU,EAAE,MAAM,EAClB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,IAAI,GAAE,eAAoB,GACzB,OAAO,CAAC,CAAC,CAAC,CA0DZ"}

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

@@ -0,0 +1,67 @@
+/**
+ * Build a sanitized child-process environment.
+ *
+ * The bash/exec tools and MCP stdio transports execute LLM-generated or
+ * configured commands. The parent process carries provider API keys
+ * (ANTHROPIC_API_KEY, OPENAI_API_KEY, ...), VCS tokens (GITHUB_TOKEN),
+ * and cloud credentials. Forwarding those to a child is an exfiltration
+ * vector even with `permission: 'confirm'` — a compromised MCP server
+ * or a cleverly composed shell pipeline can leak secrets.
+ *
+ * Strategy: copy a small, explicit allowlist of variables that real builds
+ * need, then copy anything else that does NOT look secret-bearing. This
+ * preserves user-friendly behavior (locale, terminal, npm config) while
+ * blocking the obvious leak channels. Two value-side guards back up the
+ * name-based filter:
+ *   - any value carrying an embedded URI credential (`scheme://user:pass@host`,
+ *     e.g. `DATABASE_URL`/`REDIS_URL`/`*_DSN`) is dropped (WS-01);
+ *   - `NODE_OPTIONS` is forwarded but with module-preload directives
+ *     (`--require`/`--import`/`--loader`) stripped so a parent-set value can't
+ *     inject code into node children (WS-02).
+ *
+ * Override with `WRONGSTACK_CHILD_ENV_PASSTHROUGH=1` to forward the full
+ * parent environment unchanged (opt-in for advanced users who understand
+ * the risk).
+ */
+/**
+ * Strip module-preload directives from a `NODE_OPTIONS` value while preserving
+ * benign flags (`--no-warnings`, `--max-old-space-size=…`, etc.). Handles both
+ * the `--require=./x.js` and space-separated `--require ./x.js` forms. Returns
+ * the sanitized string (possibly empty).
+ */
+export declare function sanitizeNodeOptions(value: string): string;
+export interface BuildChildEnvOptions {
+    /** Session ID to inject as WRONGSTACK_SESSION_ID. */
+    sessionId?: string | undefined;
+    /** Additional env vars to merge (takes priority over filtered parent env). */
+    extra?: NodeJS.ProcessEnv | undefined;
+}
+/**
+ * Commit identity applied to every git-touching child process via the
+ * `GIT_AUTHOR_*` / `GIT_COMMITTER_*` env vars. Env-var identity outranks
+ * every `git config` layer (repo/global/system), so commits made by any
+ * tool (git tool, bash/exec, worktree manager, plugins) carry this
+ * name/email without touching the user's git config — hand-made commits
+ * in a normal terminal are unaffected.
+ */
+export interface GitIdentity {
+    name?: string | undefined;
+    email?: string | undefined;
+}
+/**
+ * Set (or clear with `null`) the git commit identity injected by
+ * `buildChildEnv()`. Wired at boot from the user-level `config.git.identity`
+ * (the config loader strips `git` from repo-committed in-project configs —
+ * identity spoofing must not be repo-controllable) and re-applied at runtime
+ * by the `/gitid` slash command.
+ */
+export declare function configureChildEnvGitIdentity(identity: GitIdentity | null | undefined): void;
+/** Current configured git identity, or null when none is set. */
+export declare function getChildEnvGitIdentity(): Readonly<GitIdentity> | null;
+/**
+ * Build a filtered child-process environment suitable for bash, exec, and
+ * MCP server subprocesses. Strips API keys, tokens, and other credentials
+ * while preserving system/tooling variables.
+ */
+export declare function buildChildEnv(optsOrSessionId?: BuildChildEnvOptions | string): NodeJS.ProcessEnv;
+//# sourceMappingURL=child-env.d.ts.map

package/dist/utils/child-env.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"child-env.d.ts","sourceRoot":"","sources":["../../src/utils/child-env.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AA8FH;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAazD;AAED,MAAM,WAAW,oBAAoB;IACnC,qDAAqD;IACrD,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,8EAA8E;IAC9E,KAAK,CAAC,EAAE,MAAM,CAAC,UAAU,GAAG,SAAS,CAAC;CACvC;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,WAAW;IAC1B,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAID;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,IAAI,CAI3F;AAED,iEAAiE;AACjE,wBAAgB,sBAAsB,IAAI,QAAQ,CAAC,WAAW,CAAC,GAAG,IAAI,CAErE;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,eAAe,CAAC,EAAE,oBAAoB,GAAG,MAAM,GAAG,MAAM,CAAC,UAAU,CAkHhG"}

package/dist/utils/color.d.ts

@@ -0,0 +1,20 @@
+export declare const color: {
+    reset: (s: string) => string;
+    bold: (s: string) => string;
+    dim: (s: string) => string;
+    italic: (s: string) => string;
+    underline: (s: string) => string;
+    red: (s: string) => string;
+    green: (s: string) => string;
+    yellow: (s: string) => string;
+    blue: (s: string) => string;
+    magenta: (s: string) => string;
+    cyan: (s: string) => string;
+    gray: (s: string) => string;
+    amber: (s: string) => string;
+    pink: (s: string) => string;
+    bgRed: (s: string) => string;
+    bgGreen: (s: string) => string;
+};
+export declare function stripAnsi(s: string): string;
+//# sourceMappingURL=color.d.ts.map

package/dist/utils/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../src/utils/color.ts"],"names":[],"mappings":"AAqBA,eAAO,MAAM,KAAK;IAChB,KAAK,MAJD,MAAM,KAAG,MAAM;IAKnB,IAAI;IACJ,GAAG;IACH,MAAM;IACN,SAAS;IACT,GAAG;IACH,KAAK;IACL,MAAM;IACN,IAAI;IACJ,OAAO;IACP,IAAI;IACJ,IAAI;IACJ,KAAK;IACL,IAAI;IACJ,KAAK;IACL,OAAO;CACR,CAAC;AAEF,wBAAgB,SAAS,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE3C"}

package/dist/utils/config-json.d.ts

@@ -0,0 +1,14 @@
+export type JsonObject = Record<string, unknown>;
+export type JsonPathSegment = string | number;
+export type JsonPath = readonly JsonPathSegment[];
+export declare function readJsonObjectFile(filePath: string): Promise<JsonObject>;
+export declare function jsonObjectFileExists(filePath: string): Promise<boolean>;
+export declare function writeJsonObjectFile(filePath: string, value: JsonObject): Promise<void>;
+export declare function updateJsonObjectFile(filePath: string, mutator: (config: JsonObject) => void | JsonObject | Promise<void | JsonObject>): Promise<JsonObject>;
+export declare function getJsonPath(root: unknown, path: JsonPath): unknown;
+export declare function setJsonPath(root: JsonObject, path: JsonPath, value: unknown): JsonObject;
+export declare function removeJsonPath(root: JsonObject, path: JsonPath): boolean;
+export declare function setJsonPathInFile(filePath: string, path: JsonPath, value: unknown): Promise<JsonObject>;
+export declare function removeJsonPathInFile(filePath: string, path: JsonPath): Promise<JsonObject>;
+export declare function isJsonObject(value: unknown): value is JsonObject;
+//# sourceMappingURL=config-json.d.ts.map

package/dist/utils/config-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config-json.d.ts","sourceRoot":"","sources":["../../src/utils/config-json.ts"],"names":[],"mappings":"AAGA,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACjD,MAAM,MAAM,eAAe,GAAG,MAAM,GAAG,MAAM,CAAC;AAC9C,MAAM,MAAM,QAAQ,GAAG,SAAS,eAAe,EAAE,CAAC;AAElD,wBAAsB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAO9E;AAED,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAO7E;AAED,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5F;AAED,wBAAsB,oBAAoB,CACxC,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,CAAC,MAAM,EAAE,UAAU,KAAK,IAAI,GAAG,UAAU,GAAG,OAAO,CAAC,IAAI,GAAG,UAAU,CAAC,GAC9E,OAAO,CAAC,UAAU,CAAC,CAMrB;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAYlE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,UAAU,CAexF;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAYxE;AAED,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAAC,UAAU,CAAC,CAE7G;AAED,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,GAAG,OAAO,CAAC,UAAU,CAAC,CAIhG;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAEhE"}

package/dist/utils/context-evidence.d.ts

@@ -0,0 +1,47 @@
+import type { Context } from '../core/context.js';
+import type { TextBlock } from '../types/blocks.js';
+import type { CompletedWorkEvidence, CompletedWorkSource, ContextEvidenceState, ToolOutputMetadata } from '../types/context-evidence.js';
+export declare function createContextEvidenceState(): ContextEvidenceState;
+export interface RecordToolOutputEvidenceInput {
+    toolUseId: string;
+    toolName: string;
+    input: unknown;
+    content: string;
+    ok: boolean;
+    outputBytes?: number | undefined;
+    outputTokens?: number | undefined;
+    outputLines?: number | undefined;
+}
+export declare function recordUserIntentEvidence(ctx: Context, text: string): void;
+export declare function recordToolOutputEvidence(ctx: Context, input: RecordToolOutputEvidenceInput): ToolOutputMetadata;
+export declare function markAssistantReferencedEvidence(ctx: Context, text: string): void;
+export declare function buildContextEvidenceDigest(ctx: Context): string;
+export declare function repeatedReadPressure(ctx: Context): number;
+/** Marker prefixing the ledger's system-prompt block (also used to find/replace it). */
+export declare const COMPLETED_WORK_LEDGER_MARKER = "[completed_work_ledger]";
+export interface RecordCompletedWorkInput {
+    /** Stable dedupe key, e.g. `task:<id>` — re-completion updates in place. */
+    key: string;
+    source: CompletedWorkSource;
+    summary: string;
+    /** Optional pointer to proof (test run, commit hash, file path). */
+    evidence?: string | undefined;
+    /** Epoch ms; defaults to now. */
+    completedAt?: number | undefined;
+}
+/**
+ * Append one finished unit of work to the session ledger. The provider request
+ * composer renders this state as a volatile tail block; the stable system-prompt
+ * prefix is never mutated here.
+ */
+export declare function recordCompletedWorkEvidence(ctx: Context, input: RecordCompletedWorkInput): CompletedWorkEvidence;
+/** Render the ledger's system-prompt block text (marker + newest entries). */
+export declare function formatCompletedWorkLedger(items: readonly CompletedWorkEvidence[]): string;
+/** Build the current volatile completed-work block without mutating the prompt. */
+export declare function buildCompletedWorkLedgerBlock(ctx: Context): TextBlock | undefined;
+/**
+ * @deprecated Volatile state must be composed at request time. Kept as a
+ * compatibility no-op for embedders importing the old helper.
+ */
+export declare function syncCompletedWorkLedgerBlock(_ctx: Context): void;
+//# sourceMappingURL=context-evidence.d.ts.map

package/dist/utils/context-evidence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context-evidence.d.ts","sourceRoot":"","sources":["../../src/utils/context-evidence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,KAAK,EACV,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,kBAAkB,EACnB,MAAM,8BAA8B,CAAC;AAgBtC,wBAAgB,0BAA0B,IAAI,oBAAoB,CAWjE;AAED,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,EAAE,EAAE,OAAO,CAAC;IACZ,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,YAAY,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAClC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CASzE;AAED,wBAAgB,wBAAwB,CACtC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,6BAA6B,GACnC,kBAAkB,CAqDpB;AAED,wBAAgB,+BAA+B,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAyBhF;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAgE/D;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAEzD;AAoBD,wFAAwF;AACxF,eAAO,MAAM,4BAA4B,4BAA4B,CAAC;AAEtE,MAAM,WAAW,wBAAwB;IACvC,4EAA4E;IAC5E,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,mBAAmB,CAAC;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,oEAAoE;IACpE,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,iCAAiC;IACjC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAClC;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,GAAG,EAAE,OAAO,EACZ,KAAK,EAAE,wBAAwB,GAC9B,qBAAqB,CAiBvB;AAED,8EAA8E;AAC9E,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,SAAS,qBAAqB,EAAE,GAAG,MAAM,CAYzF;AAED,mFAAmF;AACnF,wBAAgB,6BAA6B,CAAC,GAAG,EAAE,OAAO,GAAG,SAAS,GAAG,SAAS,CAQjF;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,CAEhE"}

package/dist/utils/deep-merge.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Deep merge utility — safely merges nested objects with configurable
+ * conflict resolution, array merging, and prototype-pollution guarding.
+ *
+ * Used by:
+ * - config-loader  (config layer merging with primitive-array concatenation)
+ * - secret-vault   (config patching)
+ * - json-path       (json_merge tool with prefer-base / prefer-patch semantics)
+ *
+ * @module utils/deep-merge
+ */
+export declare const FORBIDDEN_PROTO_KEYS: Set<string>;
+/** True when every element is a primitive or null (no nested objects/arrays). */
+export declare function isPrimitiveArray(a: unknown[]): boolean;
+export interface DeepMergeOptions {
+    /**
+     * Which side wins on collision for scalars and arrays.
+     *
+     * - `'prefer-patch'` (default): patch value replaces base value.
+     * - `'prefer-base'`:  base value is kept, patch value is ignored.
+     */
+    conflictResolution?: 'prefer-base' | 'prefer-patch';
+    /**
+     * How to handle array values.
+     *
+     * - `'replace'` (default): patch array replaces base array entirely.
+     * - `'concat-primitives'`: when both values are primitive arrays,
+     *   they are concatenated and deduped (via Set).  Non-primitive
+     *   arrays still replace the base wholesale.
+     */
+    arrayMode?: 'replace' | 'concat-primitives';
+    /**
+     * Skip prototype-pollution keys (`__proto__`, `constructor`, etc.).
+     * Enabled by default.  Only disable when you control both inputs
+     * and the keyset (e.g. when merging trusted JSON schemas).
+     */
+    protectProto?: boolean;
+    /**
+     * Optional callback fired when a non-primitive (object) array is
+     * replaced wholesale (only relevant with `arrayMode: 'concat-primitives'`).
+     * Receives the key name, existing array length, and patch array length.
+     * Used by config-loader for debug logging.
+     */
+    onNonPrimitiveArrayReplace?: (key: string, existingLen: number, patchLen: number) => void;
+}
+/**
+ * Recursively merge `patch` into `base`, returning a new object.
+ *
+ * - Nested plain objects are merged recursively.
+ * - Arrays are handled per `options.arrayMode`.
+ * - Scalar collisions are resolved per `options.conflictResolution`.
+ * - `null` and non-object values in `patch` replace the base value
+ *   (unless `conflictResolution` is `'prefer-base'`).
+ * - Keys in `base` that are absent from `patch` are preserved.
+ * - `FORBIDDEN_PROTO_KEYS` are skipped in the patch (unless
+ *   `options.protectProto` is set to `false`).
+ *
+ * The function is generic over `T extends Record<string, unknown>` for
+ * callers that pass typed config objects, but the runtime signature
+ * also accepts `unknown` inputs (used by the json-path plugin).
+ */
+export declare function deepMerge<T extends Record<string, unknown>>(base: T, patch: Record<string, unknown>, options?: DeepMergeOptions): T;
+export declare function deepMerge(base: unknown, patch: unknown, options?: DeepMergeOptions): unknown;
+//# sourceMappingURL=deep-merge.d.ts.map

package/dist/utils/deep-merge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deep-merge.d.ts","sourceRoot":"","sources":["../../src/utils/deep-merge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAMH,eAAO,MAAM,oBAAoB,aAQ/B,CAAC;AAMH,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAEtD;AAMD,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,aAAa,GAAG,cAAc,CAAC;IAEpD;;;;;;;OAOG;IACH,SAAS,CAAC,EAAE,SAAS,GAAG,mBAAmB,CAAC;IAE5C;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;;OAKG;IACH,0BAA0B,CAAC,EAAE,CAC3B,GAAG,EAAE,MAAM,EACX,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,KACb,IAAI,CAAC;CACX;AAMD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACzD,IAAI,EAAE,CAAC,EACP,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,OAAO,CAAC,EAAE,gBAAgB,GACzB,CAAC,CAAC;AAEL,wBAAgB,SAAS,CACvB,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,OAAO,EACd,OAAO,CAAC,EAAE,gBAAgB,GACzB,OAAO,CAAC"}

package/dist/utils/diff.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Myers diff with unified-format output. No external dependencies.
+ * Operates on arrays of lines (newline-terminated or stripped).
+ */
+export interface UnifiedDiffOptions {
+    context?: number | undefined;
+    fromFile?: string | undefined;
+    toFile?: string | undefined;
+}
+export declare function unifiedDiff(oldText: string, newText: string, opts?: UnifiedDiffOptions): string;
+//# sourceMappingURL=diff.d.ts.map

package/dist/utils/diff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.ts","sourceRoot":"","sources":["../../src/utils/diff.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA6FH,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC7B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC7B;AAED,wBAAgB,WAAW,CACzB,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,GAAE,kBAAuB,GAC5B,MAAM,CA4ER"}

package/dist/utils/error.d.ts

@@ -2,6 +2,5 @@
  * Converts an unknown error value to a human-readable string.
  * Used in 40+ files across the codebase to normalize error messaging.
  */
-declare function toErrorMessage(err: unknown): string;
-
-export { toErrorMessage };
+export declare function toErrorMessage(err: unknown): string;
+//# sourceMappingURL=error.d.ts.map

package/dist/utils/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../../src/utils/error.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,MAAM,CAEnD"}

package/dist/utils/error.js

@@ -2,7 +2,7 @@
 function toErrorMessage(err) {
   return err instanceof Error ? err.message : String(err);
 }
-
-export { toErrorMessage };
+export {
+  toErrorMessage
+};
 //# sourceMappingURL=error.js.map
-//# sourceMappingURL=error.js.map

package/dist/utils/error.js.map

@@ -1 +1,7 @@
-{"version":3,"sources":["../../src/utils/error.ts"],"names":[],"mappings":";AAIO,SAAS,eAAe,GAAA,EAAsB;AACnD,EAAA,OAAO,GAAA,YAAe,KAAA,GAAQ,GAAA,CAAI,OAAA,GAAU,OAAO,GAAG,CAAA;AACxD","file":"error.js","sourcesContent":["/**\n * Converts an unknown error value to a human-readable string.\n * Used in 40+ files across the codebase to normalize error messaging.\n */\nexport function toErrorMessage(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n"]}
+{
+  "version": 3,
+  "sources": ["../../src/utils/error.ts"],
+  "sourcesContent": ["/**\n * Converts an unknown error value to a human-readable string.\n * Used in 40+ files across the codebase to normalize error messaging.\n */\nexport function toErrorMessage(err: unknown): string {\n  return err instanceof Error ? err.message : String(err);\n}\n"],
+  "mappings": ";AAIO,SAAS,eAAe,KAAsB;AACnD,SAAO,eAAe,QAAQ,IAAI,UAAU,OAAO,GAAG;AACxD;",
+  "names": []
+}

package/dist/utils/expect-defined.d.ts

@@ -2,6 +2,5 @@
  *  Useful after optional chaining and indexed access when the
  *  control flow guarantees the value exists but TypeScript can't
  *  prove it (e.g. after a check on a related field). */
-declare function expectDefined<T>(value: T | null | undefined, label?: string): T;
-
-export { expectDefined };
+export declare function expectDefined<T>(value: T | null | undefined, label?: string): T;
+//# sourceMappingURL=expect-defined.d.ts.map

package/dist/utils/expect-defined.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expect-defined.d.ts","sourceRoot":"","sources":["../../src/utils/expect-defined.ts"],"names":[],"mappings":"AAAA;;;wDAGwD;AACxD,wBAAgB,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,GAAG,SAAS,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,CAAC,CAO/E"}