@wrongstack/core 0.284.0 → 0.285.0

package/dist/utils/instruction-file.d.ts

@@ -0,0 +1,3 @@
+export declare function readBundledInstructionText(relativePath: string): string;
+export declare function renderInstructionTemplate(template: string, values: Record<string, string>): string;
+//# sourceMappingURL=instruction-file.d.ts.map

package/dist/utils/instruction-file.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"instruction-file.d.ts","sourceRoot":"","sources":["../../src/utils/instruction-file.ts"],"names":[],"mappings":"AAcA,wBAAgB,0BAA0B,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAevE;AAED,wBAAgB,yBAAyB,CACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,MAAM,CAIR"}

package/dist/utils/ip-guard.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Shared IP-address guards for SSRF protection.
+ *
+ * Exported so `fetch.ts` (tools), `web-search/index.ts` (plugins), and any
+ * other package that needs to validate IPs can all consume the same logic.
+ * Any future additions (e.g. extra CIDR blocks) need only be made here.
+ */
+/**
+ * True if `addr` is in a private / loopback / link-local / reserved / CGNAT /
+ * multicast range.  `net.isIP` is called by the caller first so `addr` is
+ * guaranteed to be a canonical dotted-quad at this point.
+ */
+export declare function isPrivateIPv4(addr: string): boolean;
+/**
+ * True if `raw` (an IPv6 literal, already lowercased) is loopback / unique-local /
+ * link-local / unspecified / IPv4-mapped-private.
+ */
+export declare function isPrivateIPv6(raw: string): boolean;
+/**
+ * Expand an IPv6 string into exactly 8 16-bit numbers.  Handles `::` compression.
+ * Returns null on malformed input — caller should treat that as "block".
+ */
+export declare function expandIPv6(addr: string): number[] | null;
+/**
+ * Convenience: throw if `hostname` resolves to a private / loopback IP.
+ * Use as a pre-flight check before opening a socket.
+ *
+ * ⚠️  This is not sufficient alone — connections must also use a pinned
+ * dispatcher (so the OS re-uses the already-resolved address) or the same
+ * check must be applied after every redirect hop.  See `guardedLookup` in
+ * `fetch.ts` for the connection-level enforcement.
+ */
+export declare function assertNotPrivateHost(hostname: string): Promise<void>;
+//# sourceMappingURL=ip-guard.d.ts.map

package/dist/utils/ip-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ip-guard.d.ts","sourceRoot":"","sources":["../../src/utils/ip-guard.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAgBnD;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAiClD;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,IAAI,CA4BxD;AAED;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAiC1E"}

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

@@ -0,0 +1,23 @@
+/**
+ * Attempt to close an incomplete JSON object string by auto-closing braces
+ * and completing any unclosed double-quoted string values.
+ *
+ * Strategy:
+ * 1. Compute origOpen from the ORIGINAL input (how many braces are unclosed).
+ * 2. Add that many closing braces. If result is now valid JSON → return it.
+ * 3. If still invalid: trim trailing whitespace, strip trailing backslash.
+ * 4. Walk backwards to detect an unclosed string value.
+ *    - Quote followed by `:` → key-name, skip
+ *    - Quote followed by `,` `}` or end-of-string → toggle in/out of string
+ * 5. If we end INSIDE a string (unclosed opening `"`), append `"` + origOpen `}`.
+ *
+ * Known limitations:
+ * - Strings whose content ends with a `"` character cannot be repaired
+ *   (algorithm can't distinguish content-`"` from string-terminator `"`).
+ * - Input ending in bare `:` (incomplete value expression) can't be meaningfully repaired.
+ * - Bare `{` returns unchanged.
+ * - If origOpen=0 (braces balanced) but string is unclosed, repair is skipped
+ *   (the input would be valid JSON per JSON.parse, so it's returned as-is).
+ */
+export declare function completePartialObject(s: string): string;
+//# sourceMappingURL=json-repair.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"json-repair.d.ts","sourceRoot":"","sources":["../../src/utils/json-repair.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAIvD"}

package/dist/utils/json-schema-validate.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Minimal JSON Schema validator — covers the subset needed for plugin
+ * configSchema validation and tool inputSchema sanity checks. Intentionally
+ * small (~80 lines, zero deps) and tolerant: unknown keywords are ignored so
+ * authors can mix in non-standard extensions without breaking validation.
+ *
+ * NOT for full JSON Schema 2020-12 conformance. If a plugin needs $ref,
+ * conditional schemas, format validation, or anything else exotic, it should
+ * bring its own ajv-based validator and call this only for the cheap path.
+ */
+import type { JSONSchema } from '../types/tool.js';
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+export interface ValidationResult {
+    ok: boolean;
+    errors: ValidationError[];
+}
+export declare function validateAgainstSchema(value: unknown, schema: JSONSchema): ValidationResult;
+export interface CoercionResult {
+    value: unknown;
+    /** True when at least one leaf was rewritten. */
+    changed: boolean;
+}
+/**
+ * Best-effort, lossless coercion of a value toward a JSON Schema. Models —
+ * especially through OpenAI-compatible proxies — frequently deliver
+ * arguments with the right *content* in the wrong *type*: numbers and
+ * booleans encoded as strings ("5", "true"), scalars where a string is
+ * expected, or a whole nested object serialized into a JSON string.
+ *
+ * Only conversions that cannot lose information are applied:
+ *   - string → number/integer when the whole trimmed string parses cleanly
+ *   - string "true"/"false" → boolean
+ *   - number/boolean → string when a string is expected
+ *   - JSON-serialized string → object/array when the parse yields that shape
+ * Recurses into `properties`/`items`. Returns the (possibly new) value and
+ * whether anything changed — callers should re-validate before trusting it.
+ */
+export declare function coerceAgainstSchema(value: unknown, schema: JSONSchema): CoercionResult;
+//# sourceMappingURL=json-schema-validate.d.ts.map

package/dist/utils/json-schema-validate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"json-schema-validate.d.ts","sourceRoot":"","sources":["../../src/utils/json-schema-validate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAEnD,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,OAAO,CAAC;IACZ,MAAM,EAAE,eAAe,EAAE,CAAC;CAC3B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,gBAAgB,CAI1F;AA+ED,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,iDAAiD;IACjD,OAAO,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,GAAG,cAAc,CAEtF"}

package/dist/utils/lru-cache.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Minimal LRU (Least Recently Used) cache.
+ *
+ * Uses the insertion-order property of `Map` (oldest entry is the first
+ * iterator) to evict the least-recently-used entry when the capacity is
+ * reached. Reads and writes re-insert the entry so it becomes the newest,
+ * matching LRU semantics.
+ *
+ * Designed for the permission-policy eval cache (P3 #17, before-release.md):
+ * a plain `Map` with no eviction could grow without bound on an iteration
+ * that evaluates thousands of unique tool+subject combinations. This wrapper
+ * caps the size at a configurable maximum while preserving the `get`/`set`/
+ * `clear`/`has` API the policy already uses.
+ *
+ * Intentionally dependency-free and small (~30 lines) — not a general-purpose
+ * LRU. If richer semantics are needed (TTL, size tracking, weighted entries),
+ * bring a dedicated library.
+ */
+export declare class LruCache<K, V> {
+    private readonly store;
+    private readonly capacity;
+    constructor(capacity: number);
+    get(key: K): V | undefined;
+    set(key: K, value: V): void;
+    has(key: K): boolean;
+    clear(): void;
+    get size(): number;
+}
+//# sourceMappingURL=lru-cache.d.ts.map

package/dist/utils/lru-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lru-cache.d.ts","sourceRoot":"","sources":["../../src/utils/lru-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,QAAQ,CAAC,CAAC,EAAE,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAmB;IACzC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAElC,YAAY,QAAQ,EAAE,MAAM,EAG3B;IAED,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAOzB;IAED,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAS1B;IAED,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO,CAEnB;IAED,KAAK,IAAI,IAAI,CAEZ;IAED,IAAI,IAAI,IAAI,MAAM,CAEjB;CACF"}

package/dist/utils/merge-custom-models.d.ts

@@ -0,0 +1,12 @@
+import type { CustomModelDefinition } from '../types/config.js';
+/**
+ * Merge per-provider `customModels` into top-level `configModels`.
+ *
+ * Keys present in `configModels` always win over `providerCustomModels`
+ * when the same model id appears in both places. This lets the user
+ * override provider-attached definitions from the top-level config.
+ *
+ * Pure: never mutates its inputs.
+ */
+export declare function mergeCustomModelDefs(providerCustomModels: Record<string, CustomModelDefinition> | undefined, configModels: Record<string, CustomModelDefinition> | undefined): Record<string, CustomModelDefinition> | undefined;
+//# sourceMappingURL=merge-custom-models.d.ts.map

package/dist/utils/merge-custom-models.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-custom-models.d.ts","sourceRoot":"","sources":["../../src/utils/merge-custom-models.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAEhE;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,SAAS,EACvE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,SAAS,GAC9D,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,GAAG,SAAS,CAmBnD"}

package/dist/utils/merge-models-payload.d.ts

@@ -0,0 +1,20 @@
+import type { ModelsDevPayload } from '../types/models-registry.js';
+/**
+ * Deep-merge a curated `overlay` payload on top of a `base` payload (both in
+ * the models.dev `api.json` shape). The overlay always wins: it can add
+ * providers/models the base lacks and override fields the base gets wrong.
+ *
+ * Precedence rules:
+ *  - Provider present in both → scalar fields (`name`, `npm`, `api`, `env`,
+ *    `doc`) come from the overlay when set; `models` maps merge by model id.
+ *  - Provider only in the overlay → added wholesale.
+ *  - Model present in both → overlay model fields override base model fields
+ *    (`{ ...base, ...overlay }`), with the nested `limit` / `cost` /
+ *    `modalities` objects merged one level deeper so an overlay can fix just
+ *    `limit.context` without restating the rest of the model.
+ *  - Model only in the overlay → added.
+ *
+ * Pure: never mutates its inputs.
+ */
+export declare function mergeModelsPayload(base: ModelsDevPayload, overlay: ModelsDevPayload): ModelsDevPayload;
+//# sourceMappingURL=merge-models-payload.d.ts.map

package/dist/utils/merge-models-payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-models-payload.d.ts","sourceRoot":"","sources":["../../src/utils/merge-models-payload.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAGV,gBAAgB,EACjB,MAAM,6BAA6B,CAAC;AAErC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,gBAAgB,EACtB,OAAO,EAAE,gBAAgB,GACxB,gBAAgB,CAUlB"}

package/dist/utils/message-invariants.d.ts

@@ -0,0 +1,22 @@
+import type { Message } from '../types/messages.js';
+export interface MessageRepairReport {
+    changed: boolean;
+    removedToolUses: string[];
+    removedToolResults: string[];
+    removedMessages: number;
+}
+export interface MessageRepairResult {
+    messages: Message[];
+    report: MessageRepairReport;
+}
+/**
+ * Repair provider-level tool-call adjacency invariants.
+ *
+ * Anthropic requires every assistant `tool_use` block to have a matching
+ * `tool_result` block in the immediately following user message. Manual
+ * context surgery (summary/prune) can cut through the middle of such an
+ * exchange. This function removes only the now-orphaned protocol blocks,
+ * preserving surrounding text/images/thinking blocks where possible.
+ */
+export declare function repairToolUseAdjacency(messages: Message[]): MessageRepairResult;
+//# sourceMappingURL=message-invariants.d.ts.map

package/dist/utils/message-invariants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-invariants.d.ts","sourceRoot":"","sources":["../../src/utils/message-invariants.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpD,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,kBAAkB,EAAE,MAAM,EAAE,CAAC;IAC7B,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,MAAM,EAAE,mBAAmB,CAAC;CAC7B;AAED;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,mBAAmB,CAyD/E"}

package/dist/utils/newline-normalize.d.ts

@@ -0,0 +1,5 @@
+export type NewlineStyle = 'lf' | 'crlf' | 'cr';
+export declare function detectNewlineStyle(text: string): NewlineStyle;
+export declare function toStyle(text: string, style: NewlineStyle): string;
+export declare function normalizeToLf(text: string): string;
+//# sourceMappingURL=newline-normalize.d.ts.map

package/dist/utils/newline-normalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"newline-normalize.d.ts","sourceRoot":"","sources":["../../src/utils/newline-normalize.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,YAAY,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAAC;AAEhD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAoB7D;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,YAAY,GAAG,MAAM,CAKjE;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/dist/utils/regex-guard.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Compile a user-supplied regex with conservative bounds against ReDoS.
+ *
+ * Duplicated from @wrongstack/tools/_regex.ts to avoid a circular
+ * dependency (tools depends on core, not vice versa). Keep both copies
+ * in sync if the heuristics change.
+ *
+ * V8's regex engine is backtracking-based and cannot interrupt a
+ * synchronous match — a pattern like `(a+)+$` against a sufficiently
+ * long line will pin a worker for seconds.
+ */
+export interface CompileResult {
+    ok: true;
+    regex: RegExp;
+}
+export interface CompileFail {
+    ok: false;
+    reason: string;
+}
+export declare function compileUserRegex(pattern: string, flags: string): CompileResult | CompileFail;
+//# sourceMappingURL=regex-guard.d.ts.map

package/dist/utils/regex-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex-guard.d.ts","sourceRoot":"","sources":["../../src/utils/regex-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAUH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,IAAI,CAAC;IACT,KAAK,EAAE,MAAM,CAAC;CACf;AAED,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,aAAa,GAAG,WAAW,CA2B5F"}

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

@@ -0,0 +1,31 @@
+export interface SafeParseResult<T> {
+    ok: boolean;
+    value?: T | undefined;
+    error?: string | undefined;
+}
+export declare function safeParse<T = unknown>(input: string, maxBytes?: number): SafeParseResult<T>;
+export declare function safeStringify(value: unknown, pretty?: boolean): string;
+/**
+ * Attempt to parse JSON5-style input and return a valid JSON string.
+ * Handles trailing commas, single-line comments, and unquoted keys
+ * that are common in provider output.
+ *
+ * Returns the sanitized string if it parses successfully as JSON,
+ * or `null` if the input cannot be made valid. Callers use this to
+ * decide whether to proceed with the parsed result or fall back to
+ * raw handling.
+ */
+export declare function sanitizeJsonString(s: string): string | null;
+/**
+ * Strip a Markdown code-fence wrapper from a payload.
+ *
+ * Models occasionally return tool-call arguments wrapped in ```json fences
+ * (or embedded in prose around one) instead of bare JSON. Returns the inner
+ * content when the input starts with a fence (closing fence optional, so a
+ * truncated stream still unwraps) or contains one complete fenced block;
+ * returns null when no fence is present. Callers should only invoke this
+ * after a direct parse failed, so fences inside legitimate string values are
+ * never touched.
+ */
+export declare function stripCodeFences(s: string): string | null;
+//# sourceMappingURL=safe-json.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"safe-json.d.ts","sourceRoot":"","sources":["../../src/utils/safe-json.ts"],"names":[],"mappings":"AAEA,MAAM,WAAW,eAAe,CAAC,CAAC;IAChC,EAAE,EAAE,OAAO,CAAC;IACZ,KAAK,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC;IACtB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CAC5B;AAED,wBAAgB,SAAS,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAY,GAAG,eAAe,CAAC,CAAC,CAAC,CAY9F;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,UAAQ,GAAG,MAAM,CAoBpE;AAED;;;;;;;;;GASG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA0B3D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAYxD"}

package/dist/utils/session-scoped-path.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Resolve `<dir>/<sessionId><suffix>` for per-session sidecar files
+ * (annotations, audit chain, replay log, the session JSONL itself).
+ *
+ * Modern session ids are date-sharded ("2026-06-11/sess_<ULID>"),
+ * so a forward slash is a legitimate shard separator — NOT traversal.
+ * Escape attempts are blocked two ways: an explicit ban on `..` and
+ * backslashes, plus a resolved-path containment check that rejects any
+ * id whose resolved target leaves `dir`. Character bans alone are how
+ * several stores ended up throwing on every modern session id.
+ */
+export declare function sessionScopedPath(dir: string, sessionId: string, suffix: string): string;
+//# sourceMappingURL=session-scoped-path.d.ts.map

package/dist/utils/session-scoped-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-scoped-path.d.ts","sourceRoot":"","sources":["../../src/utils/session-scoped-path.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAUxF"}

package/dist/utils/sleep.d.ts

@@ -0,0 +1,5 @@
+/** Resolve a promise after `ms` milliseconds. Prefer this over raw
+ *  `setTimeout` wrappers so all delay sites use a single implementation
+ *  and an abortable variant can be introduced without a codebase-wide hunt. */
+export declare function sleep(ms: number): Promise<void>;
+//# sourceMappingURL=sleep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"sleep.d.ts","sourceRoot":"","sources":["../../src/utils/sleep.ts"],"names":[],"mappings":"AAAA;;+EAE+E;AAC/E,wBAAgB,KAAK,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE/C"}

package/dist/utils/slug.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Turn an arbitrary string into a filesystem- and URL-safe lowercase slug.
+ *
+ * Collapses every run of non-alphanumeric characters into a single hyphen,
+ * trims leading/trailing hyphens, and caps the length. Returns `fallback`
+ * when the input slugifies to the empty string.
+ *
+ * Used as the stable dedup + registry key for prompts. (Distinct from the
+ * project-folder slug in `wstack-paths.ts`, which has its own `'project'`
+ * fallback and shorter cap.)
+ */
+export declare function slugify(name: string, fallback?: string, maxLen?: number): string;
+//# sourceMappingURL=slug.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slug.d.ts","sourceRoot":"","sources":["../../src/utils/slug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,SAAW,EAAE,MAAM,SAAK,GAAG,MAAM,CAS9E"}

package/dist/utils/string.d.ts

@@ -0,0 +1,9 @@
+/**
+ * String utilities shared across the WrongStack codebase.
+ */
+/**
+ * Truncate a string to at most `max` characters, appending an ellipsis if it
+ * was longer. Returns the original string unchanged when it fits.
+ */
+export declare function truncate(s: string, max: number): string;
+//# sourceMappingURL=string.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"string.d.ts","sourceRoot":"","sources":["../../src/utils/string.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/utils/task-format.d.ts

@@ -0,0 +1,22 @@
+import type { TaskPriority, TaskStatus, TaskType, TaskProgress as TaskGraphProgress } from '../types/task-graph.js';
+export type { TaskStatus, TaskPriority, TaskType };
+export interface TaskItem {
+    id: string;
+    title: string;
+    description?: string | undefined;
+    type: TaskType;
+    priority: TaskPriority;
+    status: TaskStatus;
+    /** IDs of tasks this one depends on. */
+    dependsOn?: string[] | undefined;
+    /** Agent/subagent name assigned to this task. */
+    assignee?: string | undefined;
+    estimateHours?: number | undefined;
+    tags?: string[] | undefined;
+    createdAt: string;
+    updatedAt: string;
+}
+export declare function computeTaskItemProgress(tasks: TaskItem[]): TaskGraphProgress;
+export declare function formatTaskProgress(tasks: TaskItem[]): string;
+export declare function formatTaskList(tasks: TaskItem[]): string;
+//# sourceMappingURL=task-format.d.ts.map

package/dist/utils/task-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-format.d.ts","sourceRoot":"","sources":["../../src/utils/task-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,YAAY,IAAI,iBAAiB,EAClC,MAAM,wBAAwB,CAAC;AAIhC,YAAY,EAAE,UAAU,EAAE,YAAY,EAAE,QAAQ,EAAE,CAAC;AAOnD,MAAM,WAAW,QAAQ;IACvB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACjC,IAAI,EAAE,QAAQ,CAAC;IACf,QAAQ,EAAE,YAAY,CAAC;IACvB,MAAM,EAAE,UAAU,CAAC;IACnB,wCAAwC;IACxC,SAAS,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACjC,iDAAiD;IACjD,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IAC5B,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAMD,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,iBAAiB,CA4C5E;AAmCD,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,CAgB5D;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,CAkCxD"}

package/dist/utils/term.d.ts

@@ -0,0 +1,133 @@
+/**
+ * TTY detection helpers — the single source of truth for "is this process
+ * running against a real terminal?". Replaces ad-hoc `process.stdin.isTTY`
+ * / `process.stdout.isTTY` checks scattered across the codebase so that:
+ *
+ *   1. test code can mock a single module instead of stubbing `isTTY` on
+ *      every ReadStream/WriteStream the test happens to touch;
+ *   2. a future TTY-detection source (an env var override, a Windows
+ *      ConPTY workaround, …) lands in one place;
+ *   3. `isInteractive()` encodes the rule the project already used inline
+ *      ("both streams are TTYs AND we're not running under CI") in one
+ *      testable helper instead of the same 3-condition check in two
+ *      different files.
+ *
+ * Scope: detection only. Raw-mode control (`setRawMode`), resize
+ * subscriptions, and write-injection belong to a future, larger TTY
+ * abstraction; this module is the smallest pull that gives us a
+ * testable seam and dedups 20+ call sites.
+ */
+/** True when `process.stdout` is attached to a terminal (not a pipe/file). */
+export declare function isStdoutTTY(): boolean;
+/** True when `process.stdin` is attached to a terminal (not a pipe/file). */
+export declare function isStdinTTY(): boolean;
+/**
+ * True when the current process is an interactive session: both stdin and
+ * stdout are TTYs. Callers that also need a "not a single-shot invocation"
+ * or "not under CI" check should layer that on top — keeping this helper
+ * minimal preserves the original inline checks it replaces.
+ */
+export declare function isInteractive(): boolean;
+/** Current terminal size in characters, with a 24×80 fallback for non-TTYs. */
+export declare function getTermSize(): {
+    rows: number;
+    cols: number;
+};
+/**
+ * Subscribe to terminal resize events. `cb` is called with the new size each
+ * time the underlying stream emits `resize`. Returns a cleanup function the
+ * caller MUST call on dispose to remove the listener — leaving a stale
+ * `resize` listener on a disposed component leaks the closure (and the
+ * component itself, transitively) until the process exits.
+ *
+ * The stream argument defaults to `process.stdout`. Pass an explicit
+ * `NodeJS.WriteStream` when the caller already owns one (e.g. a status line
+ * that targets an injected `out` for testability). For non-TTY streams no
+ * listener is registered and the returned cleanup is a no-op.
+ */
+export declare function onResize(cb: (size: {
+    rows: number;
+    cols: number;
+}) => void, stream?: NodeJS.WriteStream): () => void;
+/**
+ * Toggle raw mode on a TTY stdin stream. Returns `true` when the toggle was
+ * applied, `false` when the stream is null, not a TTY, or doesn't expose
+ * `setRawMode` (pipes, file descriptors, Windows ConPTY edge cases). Callers
+ * that need to restore the previous mode should snapshot `input.isRaw`
+ * BEFORE the call and pass the value to a second call to flip back.
+ *
+ * Use this helper to drop the now-redundant
+ * `if (input.isTTY) input.setRawMode(...)` ceremony at every call site.
+ */
+export declare function setRawMode(input: NodeJS.ReadStream, mode: boolean): boolean;
+/**
+ * Bracket installed by the interactive input reader while a `readline`
+ * prompt is on screen. Out-of-band terminal writes — logger WARN/INFO
+ * lines, async activity from the Telegram bridge, etc. — go to the same
+ * physical terminal as the half-typed prompt but readline has no idea they
+ * happened, so it never repaints. The result is the classic corruption the
+ * user sees: every async line strands the in-progress draft as a fresh
+ * scrollback row (sometimes with its cursor underline).
+ *
+ * The guard closes that gap. `suspend()` wipes the draft row so the message
+ * prints clean; `resume()` repaints the prompt + draft (cursor preserved).
+ * When no prompt is active the guard is `null` and writes pass straight
+ * through — so agent-turn output (spinner, renderer) is untouched.
+ */
+export interface OutputLineGuard {
+    /** Clear the current input row right before an out-of-band write. */
+    suspend(): void;
+    /** Repaint the prompt + in-progress draft right after the write. */
+    resume(): void;
+}
+/**
+ * Register (or clear, with `null`) the guard that brackets out-of-band
+ * writes. Installed by {@link writeOut}/{@link writeErr} consumers — in
+ * practice the CLI's readline input reader — only while a prompt is live.
+ * Idempotent; the most recent caller wins.
+ */
+export declare function setOutputLineGuard(guard: OutputLineGuard | null): void;
+/**
+ * Write `s` to `stream` (defaults to `process.stdout`). Returns `false`
+ * when the stream is missing or doesn't expose `write` so callers can
+ * degrade silently under hostile host environments (closed pipe, mock
+ * injects `null`, test replaces the stream with a stub).
+ *
+ * Why a helper:
+ *   1. **Single seam for output capture in tests** — stub `writeOut` once
+ *      and assert on what the rest of the codebase intended to print,
+ *      without spying on `process.stdout.write` (which is brittle and
+ *      leaks across parallel test files).
+ *   2. **Stream swap without grep** — routing the CLI's output to a
+ *      logger or `out.log` becomes a one-line change at process boot.
+ *   3. **Defensive default** — closes the "what if `process.stdout` is
+ *      `null`" gap that currently exists at ~50 call sites that just
+ *      call `process.stdout.write(s)` and crash on certain Windows
+ *      redirect invocations.
+ *
+ * Call-site migration is staged: this commit introduces the helper, a
+ * follow-up commit replaces the 50+ `process.stdout.write(...)` sites
+ * with `writeOut(...)`. Until that migration lands, both forms coexist
+ * and `writeOut` is the preferred form for new code.
+ */
+export declare function writeOut(s: string, stream?: NodeJS.WriteStream): boolean;
+/**
+ * Symmetric partner of `writeOut` for the standard error stream. Same shape,
+ * same defensive contract, same single-seam-for-tests story — just defaults to
+ * `process.stderr` instead of `process.stdout`.
+ *
+ * Use this in code paths that emit error/diagnostic/warning text. Keeping
+ * these two helpers split (rather than a single `writeTo(s, stream)`) means
+ * the call site reads as a clear intent signal: "I am writing an error" vs.
+ * "I am writing a result" — which matters for callers that decide between
+ * stdout/stderr routing (e.g. `--quiet` flags, log-level filtering,
+ * structured-log rewriters that fork on stream).
+ *
+ * Stderr writes from the core logger (see `infrastructure/logger.ts`) and from
+ * the TUI guard (see `tui/run-tui.ts`) used to call `process.stderr.write`
+ * directly. Routing them through this helper lets tests stub the stream at
+ * one boundary and lets future logging middleware (e.g. a JSON-line rewriter)
+ * swap the destination for the entire process in one place.
+ */
+export declare function writeErr(s: string, stream?: NodeJS.WriteStream): boolean;
+//# sourceMappingURL=term.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"term.d.ts","sourceRoot":"","sources":["../../src/utils/term.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAKH,8EAA8E;AAC9E,wBAAgB,WAAW,IAAI,OAAO,CAErC;AAED,6EAA6E;AAC7E,wBAAgB,UAAU,IAAI,OAAO,CAEpC;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC;AAED,+EAA+E;AAC/E,wBAAgB,WAAW,IAAI;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAM5D;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,QAAQ,CACtB,EAAE,EAAE,CAAC,IAAI,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,KAAK,IAAI,EAClD,MAAM,GAAE,MAAM,CAAC,WAA4B,GAC1C,MAAM,IAAI,CAYZ;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,CAAC,UAAU,EAAE,IAAI,EAAE,OAAO,GAAG,OAAO,CAK3E;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,eAAe;IAC9B,qEAAqE;IACrE,OAAO,IAAI,IAAI,CAAC;IAChB,oEAAoE;IACpE,MAAM,IAAI,IAAI,CAAC;CAChB;AAID;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI,GAAG,IAAI,CAEtE;AAsCD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,MAAM,GAAE,MAAM,CAAC,WAA4B,GAC1C,OAAO,CAET;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,QAAQ,CACtB,CAAC,EAAE,MAAM,EACT,MAAM,GAAE,MAAM,CAAC,WAA4B,GAC1C,OAAO,CAET"}

package/dist/utils/todos-format.d.ts

@@ -0,0 +1,30 @@
+import type { TodoItem } from '../core/context.js';
+/**
+ * Canonical text rendering of the live todo list, shared by the CLI's
+ * `/todos` slash command and the TUI's auto-echo (which prints the same
+ * snapshot to chat history each time the `todo` tool mutates the list).
+ *
+ * Layout: a header line with the `done/total done` count, then one row
+ * per item — `[ ]` pending, `[~]` in-progress, `[x]` completed. In-
+ * progress rows prefer `activeForm` ("Building the project") over the
+ * imperative `content` ("Build the project") when present.
+ *
+ * Returned as a single newline-joined string so callers can hand it
+ * straight to a history dispatcher or stdout.
+ */
+export declare function formatTodosList(todos: TodoItem[]): string;
+/**
+ * True when the todos list still has at least one unfinished item — either
+ * `pending` (not started) or `in_progress` (underway). The REPL and other
+ * post-turn handlers call this to decide whether to surface `<nextsteps>`
+ * suggestions to the user: as long as the agent has open todos, finishing
+ * them takes priority over offering new prompt options. Surfacing
+ * `<nextsteps>` mid-task is what causes YOLO+auto mode and the autonomy
+ * 'auto' loop to prematurely pivot away from the in-flight todo list.
+ *
+ * Returns false for an empty / undefined list (nothing pending, nothing to
+ * block on) and false for an all-completed list. Treats any non-array input
+ * (legacy contexts, mocks) as "no todos" rather than throwing.
+ */
+export declare function hasOpenTodos(todos: readonly TodoItem[] | undefined | null): boolean;
+//# sourceMappingURL=todos-format.d.ts.map

package/dist/utils/todos-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todos-format.d.ts","sourceRoot":"","sources":["../../src/utils/todos-format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGnD;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,MAAM,CAiBzD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,SAAS,QAAQ,EAAE,GAAG,SAAS,GAAG,IAAI,GAAG,OAAO,CAGnF"}