@wrongstack/core 0.284.1 → 0.286.0

package/dist/storage/session-resume-validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-resume-validation.d.ts","sourceRoot":"","sources":["../../src/storage/session-resume-validation.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAEV,gBAAgB,EAChB,YAAY,EACb,MAAM,qBAAqB,CAAC;AA0G7B,6EAA6E;AAC7E,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,SAAS,YAAY,EAAE,EAC/B,WAAW,EAAE,MAAM,GAClB,OAAO,CAAC,gBAAgB,CAAC,CAc3B;AAED,+EAA+E;AAC/E,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,gBAAgB,EAC5B,WAAW,EAAE,MAAM,GAClB,MAAM,GAAG,IAAI,CAiBf"}

package/dist/storage/session-rewinder.d.ts

@@ -0,0 +1,21 @@
+import type { CheckpointInfo, RewindResultExtended, SessionRewinder } from '../types/session-rewinder.js';
+export interface SessionRewinderOptions {
+    sessionsDir: string;
+    /** The project root directory; used to validate rewind targets stay inside it. */
+    projectRoot: string;
+}
+/**
+ * Rewind engine that reads session JSONL files and reverts file system
+ * changes to any previous checkpoint.
+ */
+export declare class DefaultSessionRewinder implements SessionRewinder {
+    private readonly sessionsDir;
+    private readonly projectRoot;
+    constructor(sessionsDir: string, projectRoot: string);
+    private sessionFile;
+    listCheckpoints(sessionId: string): Promise<CheckpointInfo[]>;
+    rewindToCheckpoint(sessionId: string, checkpointIndex: number): Promise<RewindResultExtended>;
+    rewindLastN(sessionId: string, n: number): Promise<RewindResultExtended>;
+    rewindToStart(sessionId: string): Promise<RewindResultExtended>;
+}
+//# sourceMappingURL=session-rewinder.d.ts.map

package/dist/storage/session-rewinder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-rewinder.d.ts","sourceRoot":"","sources":["../../src/storage/session-rewinder.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,cAAc,EAAgB,oBAAoB,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMxH,MAAM,WAAW,sBAAsB;IACrC,WAAW,EAAE,MAAM,CAAC;IACpB,kFAAkF;IAClF,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,qBAAa,sBAAuB,YAAW,eAAe;IAChD,OAAO,CAAC,QAAQ,CAAC,WAAW;IAAU,OAAO,CAAC,QAAQ,CAAC,WAAW;IAA9E,YAA6B,WAAW,EAAE,MAAM,EAAmB,WAAW,EAAE,MAAM,EAAI;IAE1F,OAAO,CAAC,WAAW;IAIb,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CA4BlE;IAEK,kBAAkB,CACtB,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,oBAAoB,CAAC,CA0C/B;IAEK,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkC7E;IAEK,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAkBpE;CACF"}

package/dist/storage/session-store.d.ts

@@ -0,0 +1,219 @@
+import type { EventBus } from '../kernel/events.js';
+import type { Logger } from '../types/logger.js';
+import type { SecretScrubber } from '../types/secret-scrubber.js';
+import type { ForkedSession, ResumedSession, SessionData, SessionEvent, SessionForkOptions, SessionMetadata, SessionStore, SessionSummary, SessionWriter, WorkspaceCheckpointRef, WorkspaceMaterializationResult } from '../types/session.js';
+export interface SessionStoreOptions {
+    dir: string;
+    /**
+     * Active project root used to revalidate persisted file-observation hashes
+     * during resume. Omit for stores that only inspect/archive transcripts.
+     */
+    projectRoot?: string | undefined;
+    /** Optional EventBus for emitting session diagnostics. */
+    events?: EventBus | undefined;
+    /**
+     * Optional secret scrubber. When set, `user_input` and `llm_response` event
+     * content is scrubbed before being persisted to the JSONL log and the
+     * summary sidecar — so a secret a user pastes or the model echoes does not
+     * sit in cleartext on disk (and does not ride along in history cloud-sync).
+     * Tool output is already scrubbed upstream by the executor; this closes the
+     * conversation-turn gap (finding F-06).
+     */
+    secretScrubber?: SecretScrubber | undefined;
+    /**
+     * Optional guard consulted by {@link DefaultSessionStore.delete} before
+     * removing a session. Returns `true` if the session is currently in use by
+     * any live process (e.g. it is the active session of another terminal, TUI,
+     * or WebUI in this project). The store ALWAYS also checks `active.json`
+     * directly; this callback widens the check to cross-process live sessions
+     * via the SessionRegistry. When omitted, only the `active.json` check runs.
+     * Resolves to a human-readable reason when in use, or `null` when safe.
+     */
+    isSessionInUse?: ((sessionId: string) => Promise<string | null>) | undefined;
+    /** Logger for structured warnings. Falls back to console.warn when omitted. */
+    logger?: Logger | undefined;
+}
+export declare class DefaultSessionStore implements SessionStore {
+    private readonly dir;
+    private readonly events?;
+    private readonly secretScrubber?;
+    private readonly projectRoot?;
+    private readonly checkpointCas?;
+    private readonly isSessionInUse?;
+    private readonly logger;
+    /**
+     * In-memory cache for load() results, keyed by session ID. The cache is
+     * invalidated when the file's mtimeMs or size changes (indicating the
+     * file was written to). This eliminates redundant full-file reads and
+     * JSON parses when the same session is loaded multiple times within the
+     * store's lifetime (e.g., webui session detail views, list() fallbacks).
+     *
+     * Max size is capped to prevent unbounded memory growth in long-running
+     * processes. When the limit is reached, the oldest entry is evicted.
+     */
+    private readonly _loadCache;
+    private _indexCache;
+    private readonly shardManifestCache;
+    private static readonly LOAD_CACHE_MAX_ENTRIES;
+    private static readonly LIST_SCAN_CONCURRENCY;
+    constructor(opts: SessionStoreOptions);
+    /**
+     * Emit a structured warning. Uses the configured Logger when available;
+     * falls back to console.warn(JSON) so warnings are never silently dropped.
+     */
+    private logWarn;
+    /**
+     * Clear the load() cache. Useful for testing or when the caller knows
+     * the file has changed externally (e.g., another process wrote to it).
+     */
+    clearLoadCache(sessionId?: string): void;
+    private emitRead;
+    private emitWrite;
+    private emitError;
+    /** Absolute path to the session index file. */
+    private get indexFile();
+    /** Join session ID to its absolute path within the store directory. */
+    private sessionPath;
+    private shardManifestPath;
+    private shardKeyForSessionId;
+    private invalidateShardManifestBySessionId;
+    /**
+     * Ensure the directory implied by the session ID exists. When the ID
+     * contains a date prefix like `2026-06-06/...`, this creates the date
+     * subdirectory so sessions group naturally by day.
+     */
+    private ensureShardDir;
+    create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
+    fork(id: string, opts?: SessionForkOptions): Promise<ForkedSession>;
+    materializeWorkspaceCheckpoint(checkpoint: WorkspaceCheckpointRef, targetRoot: string): Promise<WorkspaceMaterializationResult>;
+    resume(id: string): Promise<ResumedSession>;
+    load(id: string): Promise<SessionData>;
+    /**
+     * Fast-path loader that skips message reconstruction and adjacency repair.
+     *
+     * Use this for callers that only need the raw event stream + session
+     * metadata — e.g. session listers, analytics, audit, and the TUI's
+     * "events only" views. It avoids the message array build and
+     * repairToolUseAdjacency cost on large session files (a long agent
+     * run can have 50k+ events; rebuilding messages is O(events) and
+     * allocates per-block, so skipping it is a meaningful win).
+     *
+     * The returned data.messages is an empty array; data.toolCallEnds
+     * is computed from the raw events. usage is the sum across all
+     * llm_response events — same as full load().
+     */
+    loadEventsOnly(id: string): Promise<SessionData>;
+    private loadInternal;
+    /**
+     * Streaming search over a session's JSONL. Walks the file once, parses
+     * each event lazily, and yields only the events that match `predicate`.
+     * Stops as soon as `opts.limit` matches are collected.
+     *
+     * Why this exists: `load()` parses the entire file into memory and
+     * rebuilds `messages`/`toolCallEnds` for every caller. `search()` only
+     * needs to know which events contain matching text — a per-line
+     * predicate is enough. The full parse work (and the `_loadCache` poll)
+     * is wasted in that case.
+     *
+     * Memory: O(hits) regardless of file size. Disk: one linear scan,
+     * terminated at `limit` if the caller asked for one.
+     *
+     * Errors: missing file yields []. Corrupt lines are skipped (same
+     * policy as `load()`). Aborting via `signal` rejects with `AbortError`.
+     */
+    searchEvents(id: string, predicate: (event: SessionEvent, eventIndex: number, ts: string) => boolean, opts?: {
+        limit?: number | undefined;
+        signal?: AbortSignal | undefined;
+    }): Promise<Array<{
+        event: SessionEvent;
+        eventIndex: number;
+        ts: string;
+    }>>;
+    list(limit?: number): Promise<SessionSummary[]>;
+    /**
+     * List sessions matching filter criteria, using the cached index.
+     * Filters are applied BEFORE sorting and slicing, so the caller gets
+     * exactly `limit` matching sessions — not a slice of a larger fetch.
+     *
+     * This avoids the DefaultSessionReader pattern of fetching 1000 sessions
+     * then linear-filtering: the index is already in memory (readIndex
+     * caches it), and the filter runs over the cached array without any
+     * additional disk I/O.
+     */
+    listFiltered(criteria: {
+        since?: string | undefined;
+        until?: string | undefined;
+        provider?: string | undefined;
+        model?: string | undefined;
+        minTokens?: number | undefined;
+        titleContains?: string | undefined;
+        limit?: number | undefined;
+    }): Promise<SessionSummary[]>;
+    private indexAppendCount;
+    private static readonly COMPACT_EVERY;
+    /** Append a session summary to the index. */
+    private appendToIndex;
+    /** Append a tombstone entry for a deleted session. */
+    private writeTombstone;
+    /**
+     * Compact the index: read all entries, drop tombstones, deduplicate
+     * (keep latest per session), and rewrite atomically. Acquires the index
+     * file lock so a concurrent append (this process or another wstack in the
+     * same project) can't be overwritten by the rewrite.
+     */
+    private compactIndex;
+    /**
+     * Lock-free compaction body. The caller MUST already hold the index file
+     * lock (via withFileLock(this.indexFile, ...)). Uses atomicWrite for the
+     * rewrite so the temp file gets a random suffix (no collision between two
+     * compactions) and the Windows transient-EPERM rename retry.
+     */
+    private compactIndexInner;
+    /**
+     * Read the index file and return deduplicated session summaries.
+     * Entries with a matching tombstone are filtered out.
+     * Returns empty array when the index doesn't exist or is corrupt.
+     */
+    private readIndex;
+    /**
+     * Rebuild the index from disk by scanning all sessions and writing a
+     * fresh _index.jsonl. Useful after manual cleanup or index corruption.
+     */
+    rebuildIndex(): Promise<number>;
+    private listFromDirectoryScan;
+    private collectShardKeys;
+    private readOrBuildShardManifest;
+    private collectSessionFilesInShard;
+    private collectSessionFiles;
+    /** Recursively collect session IDs from date-shard subdirectories.
+     *  IDs include the date-prefix path (e.g. "2026-06-06/17-46-57Z_…").
+     *  Skips `.jsonl`/`.summary.json` root files, dot-files, and
+     *  sub-directories that belong to fleet/subagent sessions. */
+    private collectSessionIds;
+    private summaryFor;
+    private readSummaryManifest;
+    private summaryHeaderFor;
+    /**
+     * Delete a session and all associated files: JSONL, summary, plan/todos
+     * sidecars, and the session directory (fleet.json, shared/, subagents/).
+     *
+     * Individual file deletions are best-effort (logged as structured warnings),
+     * but a tombstone is always written so readIndex() filters this session out.
+     * If the session directory itself can't be removed, the error is surfaced
+     * to the caller so prune() can report it.
+     */
+    private deleteSession;
+    /**
+     * Read the session id currently marked active in `active.json`, or `null`
+     * when the lock is absent/unreadable. Shared by {@link delete} and
+     * {@link prune} to avoid clobbering a session a live process is writing to.
+     */
+    private readActiveSessionId;
+    delete(id: string): Promise<void>;
+    rename(id: string, name: string): Promise<SessionSummary>;
+    prune(maxAgeDays?: number): Promise<number>;
+    clearHistory(id: string): Promise<void>;
+    private summarize;
+    private iterSessionEvents;
+}
+//# sourceMappingURL=session-store.d.ts.map

package/dist/storage/session-store.d.ts.map

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

package/dist/storage/session-summary.d.ts

@@ -0,0 +1,12 @@
+import type { SessionSummary } from '../types/session.js';
+export interface SessionFilterCriteria {
+    since?: string | undefined;
+    until?: string | undefined;
+    provider?: string | undefined;
+    model?: string | undefined;
+    minTokens?: number | undefined;
+    titleContains?: string | undefined;
+}
+export declare function compareSessionSummaries(a: SessionSummary, b: SessionSummary): number;
+export declare function matchesSessionFilter(summary: SessionSummary, criteria: SessionFilterCriteria): boolean;
+//# sourceMappingURL=session-summary.d.ts.map

package/dist/storage/session-summary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-summary.d.ts","sourceRoot":"","sources":["../../src/storage/session-summary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAE1D,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3B,SAAS,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC/B,aAAa,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACpC;AAED,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,cAAc,EAAE,CAAC,EAAE,cAAc,GAAG,MAAM,CAIpF;AAED,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,cAAc,EAAE,QAAQ,EAAE,qBAAqB,GAAG,OAAO,CAWtG"}

package/dist/storage/session-tool-call-ends.d.ts

@@ -0,0 +1,5 @@
+import type { SessionData, SessionEvent } from '../types/session.js';
+type ToolCallEnd = SessionData['toolCallEnds'][number];
+export declare function extractToolCallEnds(events: readonly SessionEvent[]): ToolCallEnd[];
+export {};
+//# sourceMappingURL=session-tool-call-ends.d.ts.map

package/dist/storage/session-tool-call-ends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-tool-call-ends.d.ts","sourceRoot":"","sources":["../../src/storage/session-tool-call-ends.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAErE,KAAK,WAAW,GAAG,WAAW,CAAC,cAAc,CAAC,CAAC,MAAM,CAAC,CAAC;AAEvD,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,GAAG,WAAW,EAAE,CAelF"}

package/dist/storage/storage-concurrency.d.ts

@@ -0,0 +1,2 @@
+export declare function mapWithConcurrency<T, R>(items: readonly T[], concurrency: number, mapper: (item: T, index: number) => Promise<R>): Promise<R[]>;
+//# sourceMappingURL=storage-concurrency.d.ts.map

package/dist/storage/storage-concurrency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-concurrency.d.ts","sourceRoot":"","sources":["../../src/storage/storage-concurrency.ts"],"names":[],"mappings":"AAAA,wBAAsB,kBAAkB,CAAC,CAAC,EAAE,CAAC,EAC3C,KAAK,EAAE,SAAS,CAAC,EAAE,EACnB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAC7C,OAAO,CAAC,CAAC,EAAE,CAAC,CAkBd"}

package/dist/storage/task-store.d.ts

@@ -0,0 +1,33 @@
+import type { EventBus } from '../kernel/events.js';
+import type { TaskItem } from '../utils/task-format.js';
+export interface TaskFile {
+    version: 1;
+    sessionId: string;
+    updatedAt: string;
+    tasks: TaskItem[];
+}
+export declare function emptyTaskFile(sessionId: string): TaskFile;
+/** Read the task file. Returns null when the file doesn't exist. */
+export declare function loadTasks(filePath: string, events?: EventBus, traceId?: string): Promise<TaskFile | null>;
+/**
+ * Write the task file atomically. Prefer `mutateTasks` for read-modify-write
+ * cycles — this low-level function does NOT acquire a lock.
+ */
+/**
+ * Persist the task file. Returns `true` on success, `false` if the write
+ * failed (still emits `storage.error` + warns — does NOT throw). `mutateTasks`
+ * inspects the result and throws so the task TOOL can report `ok:false`
+ * instead of falsely claiming the tasks were saved.
+ */
+export declare function saveTasks(filePath: string, tasks: TaskFile, events?: EventBus, traceId?: string, warn?: (msg: string) => void): Promise<boolean>;
+/**
+ * Load, modify, and save the task file under a file-level lock.
+ * `fn` receives the current TaskFile (or a fresh empty one) and must
+ * return the mutated TaskFile (mutating in-place is fine — the returned
+ * reference is what gets saved).
+ *
+ * This is the primary API for any code path that reads *and then writes*
+ * the task file — it prevents races from parallel `batch_tool_use` calls.
+ */
+export declare function mutateTasks(filePath: string, sessionId: string, fn: (file: TaskFile) => TaskFile | Promise<TaskFile>, events?: EventBus, traceId?: string): Promise<TaskFile>;
+//# sourceMappingURL=task-store.d.ts.map

package/dist/storage/task-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-store.d.ts","sourceRoot":"","sources":["../../src/storage/task-store.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAGpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAYxD,MAAM,WAAW,QAAQ;IACvB,OAAO,EAAE,CAAC,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,wBAAgB,aAAa,CAAC,SAAS,EAAE,MAAM,GAAG,QAAQ,CAOzD;AAED,oEAAoE;AACpE,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAuD1B;AAED;;;GAGG;AACH;;;;;GAKG;AACH,wBAAsB,SAAS,CAC7B,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,QAAQ,EACf,MAAM,CAAC,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC3B,OAAO,CAAC,OAAO,CAAC,CAwClB;AAED;;;;;;;;GAQG;AACH,wBAAsB,WAAW,CAC/B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,EAAE,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,EACpD,MAAM,CAAC,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,CAAC,CAenB"}

package/dist/storage/todos-checkpoint.d.ts

@@ -0,0 +1,39 @@
+import type { EventBus } from '../kernel/events.js';
+import type { TodoItem } from '../core/context.js';
+import type { ConversationState } from '../core/conversation-state.js';
+/**
+ * On-disk checkpoint for `ctx.todos`. Written atomically every time the
+ * todo list changes, read once on session resume. This is the missing
+ * piece that lets `wstack resume <id>` rehydrate where the previous run
+ * stopped instead of starting with an empty board.
+ *
+ * Schema is intentionally small — a single JSON object so a future
+ * format bump is easy. The `version` field is the only contract; the
+ * shape under `todos` mirrors `TodoItem` so reading is a straight assign.
+ */
+export interface TodosCheckpointFile {
+    version: 1;
+    sessionId: string;
+    updatedAt: string;
+    todos: TodoItem[];
+}
+export type TodosCheckpointDetach = () => Promise<void>;
+/** Read a checkpoint from disk. Returns null when the file doesn't
+ *  exist or is corrupt — callers treat both cases as "no prior state".
+ */
+export declare function loadTodosCheckpoint(filePath: string, events?: EventBus, traceId?: string): Promise<TodoItem[] | null>;
+/** Write the checkpoint atomically. Best-effort: a write failure is
+ *  logged but does not throw — losing one checkpoint shouldn't bring
+ *  down the agent run.
+ */
+export declare function saveTodosCheckpoint(filePath: string, sessionId: string, todos: readonly TodoItem[], events?: EventBus, traceId?: string, warn?: (msg: string) => void): Promise<void>;
+/**
+ * Subscribe a `ConversationState` so every `todos_replaced` mutation
+ * triggers an atomic write to disk. Returns the unsubscribe function.
+ *
+ * Writes are debounced by 150ms so a flurry of edits (e.g. the LLM
+ * marking three items done in the same tool call) coalesces into one
+ * disk hit.
+ */
+export declare function attachTodosCheckpoint(state: ConversationState, filePath: string, sessionId: string, events?: EventBus, traceId?: string, warn?: (msg: string) => void): TodosCheckpointDetach;
+//# sourceMappingURL=todos-checkpoint.d.ts.map

package/dist/storage/todos-checkpoint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"todos-checkpoint.d.ts","sourceRoot":"","sources":["../../src/storage/todos-checkpoint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAIvE;;;;;;;;;GASG;AACH,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,CAAC,CAAC;IACX,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,QAAQ,EAAE,CAAC;CACnB;AAED,MAAM,MAAM,qBAAqB,GAAG,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;AAExD;;GAEG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,MAAM,CAAC,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,QAAQ,EAAE,GAAG,IAAI,CAAC,CA8D5B;AAED;;;GAGG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,MAAM,CAAC,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC3B,OAAO,CAAC,IAAI,CAAC,CA+Bf;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,iBAAiB,EACxB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,EACjB,MAAM,CAAC,EAAE,QAAQ,EACjB,OAAO,CAAC,EAAE,MAAM,EAChB,IAAI,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,GAC3B,qBAAqB,CAiDvB"}

package/dist/storage/tool-audit-log.d.ts

@@ -0,0 +1,141 @@
+import type { EventBus } from '../kernel/events.js';
+/**
+ * ToolAuditLog — idea #9 from IDEAS.md.
+ *
+ * Tamper-evident audit trail for tool calls. Every tool_use /
+ * tool_result pair is appended to a sidecar JSONL with a chained
+ * SHA-256 — each entry's `prevHash` is the prior entry's `hash`,
+ * so any post-hoc modification of a single line breaks the chain
+ * from that point forward.
+ *
+ * Why a sidecar (not the session JSONL)?
+ *   Same reason as `AnnotationsStore` and `ReplayLogStore`: the
+ *   session log is an event-sourced journal. Mixing in a hash
+ *   chain would inflate every read and tightly couple the
+ *   integrity check to the event format. Sidecar keeps both
+ *   concerns orthogonal.
+ *
+ * What "tamper-evident" means here:
+ *   - The hash covers the full serialized entry: tool name, id,
+ *     input, output, timestamp, author. Changing any byte
+ *     changes the hash.
+ *   - The chain is sequential — a verifier walks the file in
+ *     order, recomputing each hash, and checks `prevHash`
+ *     matches the previous entry's `hash`.
+ *   - Any insertion, deletion, or modification of a single
+ *     entry surfaces as a "chain broken at entry N" verdict.
+ *
+ * What it does NOT defend against:
+ *   - An attacker who rewrites the whole file consistently.
+ *     For that you'd need an external anchor (signing key,
+ *     transparency log, etc.) — out of scope for Phase 1.
+ *   - The agent itself misbehaving; this is post-hoc audit, not
+ *     real-time enforcement. Use `PermissionPolicy` for that.
+ *
+ * File layout: `sessionScopedPath(dir, sessionId, '.audit.jsonl')`,
+ * one entry per line. The chain starts with a `genesis` entry whose
+ * `prevHash` is all zeros.
+ */
+export interface AuditEntry {
+    /** Monotonic index (0-based). */
+    index: number;
+    /** UUID for cross-referencing with logs. */
+    id: string;
+    /** ISO timestamp. */
+    ts: string;
+    /** Hash of the previous entry (or all-zeros for the genesis entry). */
+    prevHash: string;
+    /** Hash of this entry's content (sha256 over the canonical JSON). */
+    hash: string;
+    toolName: string;
+    toolUseId: string;
+    input: unknown;
+    output: unknown;
+    isError: boolean;
+}
+export type VerifyResult = {
+    ok: true;
+    entries: number;
+} | {
+    ok: false;
+    brokenAt: number;
+    reason: string;
+};
+export interface ToolAuditLogOptions {
+    /** Root sessions directory used with `sessionScopedPath(..., '.audit.jsonl')`. */
+    dir: string;
+    /**
+     * Flush the file system cache to disk every N writes per session.
+     * Default 100. Lower values = better crash durability, more I/O overhead.
+     * Set to `Infinity` to disable periodic fsync (fastest, but highest data-loss risk).
+     */
+    fsyncEvery?: number | undefined;
+    events?: EventBus;
+    traceId?: string;
+}
+export declare class ToolAuditLog {
+    private readonly dir;
+    private readonly events;
+    private readonly traceId;
+    /** In-memory cache of the last entry's hash (per session), to compute chains efficiently. */
+    private readonly tailHash;
+    /** In-memory counter for entry indices — avoids re-reading the file on every write. */
+    private readonly tailIndex;
+    /**
+     * File mtime+size recorded after our last write, per session. Used to
+     * detect cross-process writes (session handoff, recovery) that would
+     * invalidate the in-memory tail cache: if the stat no longer matches
+     * we re-read the file to re-establish the chain tip before appending.
+     */
+    private readonly tailStat;
+    /** Tracks writes since last fsync, per session. */
+    private readonly unSyncedWrites;
+    private readonly writeChains;
+    private readonly fsyncEvery;
+    constructor(opts: ToolAuditLogOptions);
+    /**
+     * Append a tool call/result pair to the chain. Returns the
+     * resulting entry. Idempotency is not guaranteed — if you
+     * record the same tool_use twice you get two entries. That's
+     * intentional: the audit log is a record, not a cache.
+     */
+    record(input: {
+        sessionId: string;
+        toolName: string;
+        toolUseId: string;
+        input: unknown;
+        output: unknown;
+        isError: boolean;
+    }): Promise<AuditEntry>;
+    /**
+     * Resolve the chain tip (previous hash + next index) for an append.
+     * Uses the in-memory `tailHash`/`tailIndex` cache when the file's
+     * stat matches our last known write; falls back to a full read on
+     * cache miss or when an external writer has extended the file.
+     */
+    private _resolveChainTip;
+    /**
+     * Walk the chain and verify every entry's hash and prevHash.
+     * Returns a structured verdict — never throws.
+     */
+    verify(sessionId: string): Promise<VerifyResult>;
+    /** All entries for a session, in insertion order. */
+    load(sessionId: string): Promise<AuditEntry[]>;
+    private filePath;
+    private readAll;
+    /**
+     * Tracks writes since last fsync and triggers periodic fsync.
+     * Called after each O(1) append to maintain the same durability
+     * guarantees as the old writeAll approach.
+     */
+    private _trackUnsynced;
+    /**
+     * Explicitly sync the file to disk. Called automatically every
+     * `fsyncEvery` writes, and available for callers who want to
+     * force a sync before closing or during graceful shutdown.
+     */
+    flush(sessionId: string): Promise<void>;
+    private sync;
+    private enqueue;
+}
+//# sourceMappingURL=tool-audit-log.d.ts.map

package/dist/storage/tool-audit-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-audit-log.d.ts","sourceRoot":"","sources":["../../src/storage/tool-audit-log.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AACpD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,MAAM,WAAW,UAAU;IACzB,iCAAiC;IACjC,KAAK,EAAE,MAAM,CAAC;IACd,4CAA4C;IAC5C,EAAE,EAAE,MAAM,CAAC;IACX,qBAAqB;IACrB,EAAE,EAAE,MAAM,CAAC;IACX,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAC;IACjB,qEAAqE;IACrE,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,OAAO,EAAE,OAAO,CAAC;CAClB;AAID,MAAM,MAAM,YAAY,GACpB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC7B;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEpD,MAAM,WAAW,mBAAmB;IAClC,kFAAkF;IAClF,GAAG,EAAE,MAAM,CAAC;IACZ;;;;OAIG;IACH,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,MAAM,CAAC,EAAE,QAAQ,CAAC;IAClB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD,qBAAa,YAAY;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAC7B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAqB;IAC7C,6FAA6F;IAC7F,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,uFAAuF;IACvF,OAAO,CAAC,QAAQ,CAAC,SAAS,CAA6B;IACvD;;;;;OAKG;IACH,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAwD;IACjF,mDAAmD;IACnD,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAC5D,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoC;IAChE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAS;IAEpC,YAAY,IAAI,EAAE,mBAAmB,EAKpC;IAED;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE;QAClB,SAAS,EAAE,MAAM,CAAC;QAClB,QAAQ,EAAE,MAAM,CAAC;QACjB,SAAS,EAAE,MAAM,CAAC;QAClB,KAAK,EAAE,OAAO,CAAC;QACf,MAAM,EAAE,OAAO,CAAC;QAChB,OAAO,EAAE,OAAO,CAAC;KAClB,GAAG,OAAO,CAAC,UAAU,CAAC,CA2FtB;IAED;;;;;OAKG;YACW,gBAAgB;IA8C9B;;;OAGG;IACG,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,CAmFrD;IAED,qDAAqD;IAC/C,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CA8BnD;IAID,OAAO,CAAC,QAAQ;YAOF,OAAO;IAuBrB;;;;OAIG;YACW,cAAc;IAQ5B;;;;OAIG;IACG,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5C;YAEa,IAAI;IAelB,OAAO,CAAC,OAAO;CAShB"}

package/dist/tasking/index.d.ts

@@ -1,124 +1,3 @@
-import { d as TaskGraph, e as TaskNode, k as TaskFilter, l as TaskSort, c as TaskProgress } from '../task-graph-CH3acNQ7.js';
-
-interface TaskStore {
-    saveGraph(graph: TaskGraph): Promise<void>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    listGraphs(): Promise<{
-        id: string;
-        title: string;
-        updatedAt: number;
-    }[]>;
-    deleteGraph(id: string): Promise<void>;
-}
-interface TaskTrackerOptions {
-    store: TaskStore;
-    /**
-     * Called when an in-the-background persistence (`saveGraph`) rejects.
-     * The synchronous TaskTracker methods (addNode/addEdge/updateNodeStatus)
-     * fire-and-forget their writes; without this, a failing store silently
-     * loses graph mutations. Defaults to a console.warn.
-     */
-    onPersistError?: (((err: unknown) => void)) | undefined;
-}
-interface TaskTransition {
-    from: TaskNode['status'];
-    to: TaskNode['status'];
-    timestamp: number;
-    reason?: string | undefined;
-}
-/** A change notification emitted to `TaskTracker.subscribe` listeners. */
-interface TaskTrackerChange {
-    type: 'node_added' | 'node_updated' | 'status_changed' | 'node_removed';
-    nodeId: string;
-    /** For `node_removed` this is the node as it was just before deletion. */
-    node: TaskNode;
-    transition?: TaskTransition | undefined;
-}
-type TaskTrackerListener = (change: TaskTrackerChange) => void;
-declare class TaskTracker {
-    private readonly opts;
-    private graph;
-    private transitions;
-    private listeners;
-    constructor(opts: TaskTrackerOptions);
-    /**
-     * Subscribe to live task mutations (add / update / status change). Returns an
-     * unsubscribe fn. This is the hook the board projector uses to stream a live
-     * snapshot — the tracker was previously fire-and-forget with no observability.
-     */
-    subscribe(listener: TaskTrackerListener): () => void;
-    private notifyChange;
-    /**
-     * Attach an existing graph (used by PhaseOrchestrator to associate a tracker
-     * with a phase's pre-built task graph without re-creating it).
-     */
-    setGraph(graph: TaskGraph): void;
-    createGraph(specId: string, title: string): Promise<TaskGraph>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    addNode(node: Omit<TaskNode, 'id' | 'createdAt' | 'updatedAt'>): TaskNode;
-    addEdge(from: string, to: string, type?: TaskGraph['edges'][0]['type']): void;
-    /**
-     * Declare that `taskId` depends on `depId` (a `depends_on` edge `depId → taskId`),
-     * guarding against self-loops, duplicates, missing nodes, and cycles. Returns
-     * true if the dependency now holds (added or already present), false if it was
-     * rejected (would create a cycle / unknown node). This is the safe entry point
-     * for wiring agent-declared `dependsOn` references into the graph.
-     */
-    addDependency(depId: string, taskId: string): boolean;
-    /** True when `taskId` transitively depends on `targetId` (follows depends_on blockers). */
-    private dependsOnTransitively;
-    /**
-     * Merge `patch` into a node's `metadata` (used for per-task model/provider/
-     * fallback assignment and the cancel marker). Persists + notifies as a node
-     * update. No-op if the node is missing.
-     */
-    patchMetadata(id: string, patch: Record<string, unknown>): void;
-    /**
-     * Remove a node and every edge touching it. Intended for deleting a task that
-     * has not started yet — callers must gate on status (do not remove a running
-     * task). Dependents simply lose this blocker (re-evaluated by `canStart`).
-     * Returns true if a node was removed.
-     */
-    removeNode(id: string): boolean;
-    updateNodeStatus(id: string, status: TaskNode['status'], reason?: string): void;
-    updateNode(id: string, patch: Partial<Pick<TaskNode, 'title' | 'description' | 'priority' | 'estimateHours' | 'tags' | 'assignee'>>): void;
-    getNode(id: string): TaskNode | undefined;
-    getAllNodes(filter?: TaskFilter, sort?: TaskSort): TaskNode[];
-    getChildren(parentId: string): TaskNode[];
-    getDependents(taskId: string): string[];
-    getBlockers(taskId: string): string[];
-    canStart(taskId: string): boolean;
-    getProgress(): TaskProgress;
-    getTransitions(_taskId?: string): TaskTransition[];
-    private unblockDependents;
-    private checkAndBlockIfNeeded;
-    /**
-     * Fire-and-forget persistence with attached error handler.
-     * Synchronous mutators (addNode/addEdge/updateNodeStatus) use this to
-     * avoid forcing an async cascade through every caller; if the store
-     * is missing or throwing, the error is surfaced via onPersistError.
-     */
-    private persist;
-}
-
-/**
- * In-memory task-graph store used by AutoPhase and tests.
- *
- * The store clones the graph container on read/write so callers cannot replace
- * its Maps/arrays behind the store's back. Task nodes themselves intentionally
- * remain shared: TaskTracker owns node mutation and persists after each change.
- */
-declare class DefaultTaskStore implements TaskStore {
-    private readonly graphs;
-    saveGraph(graph: TaskGraph): Promise<void>;
-    loadGraph(id: string): Promise<TaskGraph | null>;
-    listGraphs(): Promise<Array<{
-        id: string;
-        title: string;
-        updatedAt: number;
-    }>>;
-    deleteGraph(id: string): Promise<void>;
-    private cloneGraph;
-}
-
-export { DefaultTaskStore, type TaskStore, TaskTracker, type TaskTrackerChange, type TaskTrackerListener, type TaskTrackerOptions, type TaskTransition };
+export { DefaultTaskStore } from './task-store.js';
+export { TaskTracker, type TaskStore, type TaskTrackerChange, type TaskTrackerListener, type TaskTrackerOptions, type TaskTransition, } from './task-tracker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/tasking/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tasking/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EACL,WAAW,EACX,KAAK,SAAS,EACd,KAAK,iBAAiB,EACtB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EACvB,KAAK,cAAc,GACpB,MAAM,mBAAmB,CAAC"}