@pugi/cli 0.1.0-beta.99 → 1.0.0-alpha.10

package/dist/core/repl/engine-bridge.js

@@ -1,303 +0,0 @@
-import { AnvilEngineLoopClient } from '../engine/anvil-client.js';
-import { NativePugiEngineAdapter } from '../engine/native-pugi.js';
-import { loadMcpRegistry as defaultLoadMcpRegistry } from '../mcp/registry.js';
-import { openSession } from '../session.js';
-import { loadHookRegistryOrExit as defaultLoadHookRegistry } from '../../runtime/load-hooks-or-exit.js';
-/**
- * Translate `pugi-tool-route command="..."` into the SDK's
- * `EngineTaskKind`. `code` and `fix` pass through verbatim; `build`
- * maps to `build_task` per `apps/pugi-cli/src/core/engine/native-pugi.ts:1444`
- * (`toCommandKind`).
- */
-function commandToTaskKind(command) {
-    if (command === 'build')
-        return 'build_task';
-    return command;
-}
-/**
- * Translate one `EngineStreamEvent` (rich, adapter-internal vocabulary)
- * into the REPL bridge's narrow `BridgedEngineEvent` shape (four
- * variants -- step / tool.start / tool.result / tokens).
- *
- * Returns `null` for events the bridge surface deliberately ignores
- * (`tool.delta` payloads are surfaced via `tool.result` summary;
- * `thinking.*` and `text.delta` deltas are not part of the bridge
- * UX contract -- the synthetic agent-tree node renders a single
- * `detail` line, not a streaming thinking block).
- *
- * Mutates `names` so a follow-up `tool.end` can resolve its callId
- * back to the recorded tool name (`tool.end` carries only `callId`).
- */
-function translateStreamEvent(event, names) {
-    if (event.type === 'status') {
-        return { type: 'step', detail: event.message };
-    }
-    if (event.type === 'tool.start') {
-        names.set(event.callId, event.name);
-        return {
-            type: 'tool.start',
-            tool: event.name,
-            args: event.arguments,
-        };
-    }
-    if (event.type === 'tool.end') {
-        const name = names.get(event.callId) ?? '';
-        names.delete(event.callId);
-        return {
-            type: 'tool.result',
-            tool: name,
-            ok: event.ok,
-            preview: event.summary,
-        };
-    }
-    // tool.delta / thinking.* / text.delta intentionally dropped.
-    return null;
-}
-/**
- * Production factory. Returns an `EngineBridge` the REPL bootstrap
- * passes straight to `new ReplSession({ engineBridge })`.
- *
- * Per invocation lifecycle:
- *   1. `openSession(cwd)` mints a fresh session id and ensures the
- *      `.pugi/events.jsonl` ledger captures audit lines for the
- *      bridged turn alongside direct `pugi code` invocations.
- *   2. `NativePugiEngineAdapter` is constructed eagerly with the
- *      injected (or default) `EngineLoopClient`. The adapter prewarms
- *      the real-dispatch import on construction; this happens here for
- *      free.
- *   3. `attachStreamListener` subscribes to the adapter's
- *      `streamEmitter`, fans every translatable `EngineStreamEvent`
- *      to `input.onEvent`, and detaches on bridge exit.
- *   4. `adapter.run(task, ctx)` drives the engine loop; the terminal
- *      `result` event maps to the bridge outcome the REPL renders.
- *   5. The bridge's `signal` is threaded straight through `ctx.signal`
- *      so a REPL `/stop` aborts the engine loop mid-turn.
- *
- * Failure modes (each must be observable, never silent):
- *   - Adapter constructor throws (e.g. invalid config) -- the bridge
- *     promise rejects with the underlying error. The REPL's
- *     `runEngineBridge` catch surfaces the message on a system line.
- *   - Network error mid-loop -- adapter yields `result.status='failed'`,
- *     bridge returns `{ outcome: 'failed', detail: result.summary }`.
- *   - Operator abort -- adapter honours `ctx.signal`, surfaces an
- *     `AbortError`; we propagate the rejection so the REPL flips the
- *     synthetic node to `failed` with a clear detail line.
- */
-export function createEngineBridge(deps) {
-    const buildClient = deps.clientFactory ?? ((config) => new AnvilEngineLoopClient(config));
-    const loadMcp = deps.loadMcpRegistry ?? defaultLoadMcpRegistry;
-    const loadHooks = deps.loadHookRegistry ??
-        ((opts) => defaultLoadHookRegistry(opts));
-    // PR A — per-bridge-instance caches. Spawning MCP child processes
-    // (multi-second startup for some servers) and parsing hook configuration
-    // are too expensive to repeat per turn AND have no per-turn state. We
-    // load once on the first call, reuse across turns. The MCP registry
-    // shutdown happens at process exit; a future PR will wire it to the
-    // REPL's exit hook so trusted child processes are reaped before the
-    // parent terminates.
-    //
-    // /triple-review P1 round 2: cache stored as in-flight Promise<T>
-    // instead of value + boolean flag. Two concurrent first-turn calls
-    // would otherwise both observe `mcpLoaded === false`, both spawn the
-    // expensive loader, and the second result would overwrite the first —
-    // leaking the first registry's child processes. Storing the promise
-    // means the second caller awaits the same in-flight load, gets the
-    // same instance, and there is no double-spawn. On loader failure the
-    // promise resolves to `undefined` (mirrors the value-cache fallback);
-    // a future retry on transient ENOENT would mint a NEW promise after
-    // explicit invalidation (out of scope for this PR — tracked as P2 fu).
-    let mcpRegistryPromise = null;
-    let hooksPromise = null;
-    const securityHooksParseFailed = { value: false };
-    async function resolveMcpRegistry(root) {
-        if (mcpRegistryPromise === null) {
-            mcpRegistryPromise = (async () => {
-                try {
-                    return await loadMcp(root);
-                }
-                catch (error) {
-                    // PR A — mirror cli.ts:6394 failure mode. A bad `.pugi/mcp.json`
-                    // must not crash the REPL; the operator sees a stderr warning
-                    // and continues without MCP tools. They can fix the file and
-                    // the next REPL launch picks up the new registry.
-                    const msg = error.message;
-                    process.stderr.write(`pugi REPL engine bridge: MCP registry load failed — ${msg}. ` +
-                        `Continuing without MCP tools. Fix .pugi/mcp.json to enable.\n`);
-                    return undefined;
-                }
-            })();
-        }
-        return mcpRegistryPromise;
-    }
-    async function resolveHooks(root, session) {
-        if (hooksPromise === null) {
-            hooksPromise = (async () => {
-                try {
-                    const outcome = await loadHooks({
-                        workspaceRoot: root,
-                        session,
-                        label: 'repl',
-                    });
-                    if (outcome.kind === 'parse-failure-refused') {
-                        // /triple-review P1 round 2: hooks fail-open is a security
-                        // regression vs cli.ts:6440 (hard-exit on parse failure).
-                        // SECURITY: a workspace operator who configured a `PreToolUse
-                        // onFailure: 'block'` rule that refuses bash containing `rm`
-                        // loses that protection the moment the JSON file gets a
-                        // typo. Stderr-only warning scrolls off the TUI.
-                        //
-                        // Mitigation: do NOT load hooks for this REPL session (so
-                        // the operator's mental model — "I have hooks configured" —
-                        // does not silently break), AND mark the bridge as "hooks
-                        // parse failed" so every turn surfaces the warning until
-                        // the file is fixed. The PUGI_HOOKS_BYPASS=1 env var
-                        // (loadHookRegistryOrExit:97-107) is still the explicit
-                        // escape hatch when the operator is mid-edit and acknowledges
-                        // the risk.
-                        securityHooksParseFailed.value = true;
-                        process.stderr.write('pugi REPL engine bridge: SECURITY — hooks parse failed. ' +
-                            'PreToolUse/PostToolUse rules are NOT active for this REPL ' +
-                            'session. Fix .pugi/hooks.json and restart REPL, OR set ' +
-                            'PUGI_HOOKS_BYPASS=1 to acknowledge and continue.\n');
-                        return undefined;
-                    }
-                    return outcome.hooks;
-                }
-                catch (error) {
-                    const msg = error.message;
-                    process.stderr.write(`pugi REPL engine bridge: hooks loader threw — ${msg}. ` +
-                        `Continuing without hooks.\n`);
-                    return undefined;
-                }
-            })();
-        }
-        return hooksPromise;
-    }
-    return async (input) => {
-        const root = deps.cwd();
-        const session = openSession(root);
-        const client = buildClient(deps.config);
-        const [cachedMcpRegistry, cachedHooks] = await Promise.all([
-            resolveMcpRegistry(root),
-            resolveHooks(root, session),
-        ]);
-        if (securityHooksParseFailed.value) {
-            // /triple-review P1 round 2: re-emit the security warning on every
-            // bridged turn so the operator does not miss it after scrollback.
-            // Cheap one-liner, hard to miss in TUI status pane.
-            process.stderr.write('pugi REPL engine bridge: SECURITY reminder — hooks still NOT ' +
-                'loaded for this session (.pugi/hooks.json parse failure).\n');
-        }
-        const adapter = new NativePugiEngineAdapter({
-            client,
-            session,
-            ...(cachedMcpRegistry ? { mcpRegistry: cachedMcpRegistry } : {}),
-            ...(cachedHooks ? { hooks: cachedHooks } : {}),
-            ...(deps.intensityProfile ? { intensityProfile: deps.intensityProfile } : {}),
-        });
-        // Per-call name map for matching `tool.end` -> `tool.start`. New
-        // every invocation so concurrent bridges never cross-pollute.
-        const callNames = new Map();
-        // Subscribe BEFORE `adapter.run()` so the first `tool.start` is
-        // captured. Detach in `finally` regardless of outcome so the
-        // listener does not accumulate across REPL turns (long sessions
-        // would otherwise leak one listener per bridged turn).
-        const onStreamEvent = (streamEvent) => {
-            const translated = translateStreamEvent(streamEvent, callNames);
-            if (translated === null)
-                return;
-            try {
-                input.onEvent(translated);
-            }
-            catch {
-                // Fire-and-forget contract -- a broken consumer must never
-                // tear down the engine loop.
-            }
-        };
-        adapter.streamEmitter.on('event', onStreamEvent);
-        const taskKind = commandToTaskKind(input.command);
-        const task = {
-            id: input.bridgeId,
-            kind: taskKind,
-            prompt: input.brief,
-            workspaceRoot: root,
-            allowedPaths: [root],
-            deniedPaths: [],
-            artifacts: [],
-            permissionMode: 'auto',
-        };
-        let terminalSummary = '';
-        let terminalStatus = 'failed';
-        let filesChangedCount = 0;
-        let detail;
-        try {
-            const events = adapter.run(task, {
-                sessionId: session.id,
-                signal: input.signal,
-            });
-            for await (const event of events) {
-                if (event.type === 'status') {
-                    // Already fanned out via streamEmitter above. The toplevel
-                    // `EngineEvent` `status` event predates the rich emitter and
-                    // is kept for backwards-compat with older adapters; we
-                    // intentionally do not double-fire `onEvent` here.
-                    continue;
-                }
-                // event.type === 'result' -- terminal.
-                terminalStatus = event.result.status;
-                terminalSummary = event.result.summary;
-                filesChangedCount = event.result.filesChanged.length;
-                if (event.result.status !== 'done') {
-                    detail = event.result.summary;
-                }
-            }
-        }
-        finally {
-            adapter.streamEmitter.off('event', onStreamEvent);
-        }
-        // Map engine `EngineResult.status` -> bridge `EngineBridgeOutcome`.
-        //
-        // `needs_verification` ( PUGI-VERIFY-GATE) downgrades a
-        // `completed` engine loop with no verification command to a status
-        // distinct from `done`. PUGI-538c-FU-OUTCOME (2026-06-05) split
-        // the bridge's failure surface: `needs_verification` now maps to
-        // the dedicated `unverified` outcome so the REPL agent-tree pane
-        // surfaces a yellow advisory instead of a red false-fail. Real
-        // verification regressions (`verification_command_failed` -> still
-        // `failed` here via the engine's `failed` status) are unchanged.
-        //
-        // Why the split matters: a fresh customer repo with no Makefile /
-        // no `package.json` test script trips `needs_verification` on
-        // every routed brief. Collapsing that to `failed` (the pre-538c
-        // mapping) produced the trust regression the CEO escalation 2026
-        // -06-04 demanded we fix: customer dogfood saw files land on
-        // disk yet read "failed" on the agent-tree, lost trust, walked
-        // away. The verify-gate contract is preserved: real test failures
-        // ALSO reach this branch via engine status `failed` (gated by
-        // `computeVerificationOutcome` when a verification command ran
-        // and exited non-zero) and still map to `failed`. Only the
-        // "no command available" path softens.
-        //
-        // `blocked` carries through (operator chose the abort / budget
-        // exhausted). `done` -> `shipped` -- the only path that produces
-        // a clean shipped status is a verified engine loop.
-        const outcome = terminalStatus === 'done'
-            ? 'shipped'
-            : terminalStatus === 'needs_verification'
-                ? 'unverified'
-                : terminalStatus === 'blocked'
-                    ? 'blocked'
-                    : 'failed';
-        return {
-            outcome,
-            filesChanged: filesChangedCount,
-            // PUGI-538c scope guard: stream emitter has no typed `tokens`
-            // event today; reporting `0` keeps the bridge contract honest
-            // until the emitter gains a tokens variant (separate follow-up).
-            tokensUsed: 0,
-            finalText: terminalSummary.length > 0 ? terminalSummary : undefined,
-            ...(detail !== undefined ? { detail } : {}),
-        };
-    };
-}
-//# sourceMappingURL=engine-bridge.js.map

package/dist/core/repl/history-search.js

@@ -1,175 +0,0 @@
-/**
- * FZF-style history search - Sprint .
- *
- * Powers the Ctrl+R (reverse) / Ctrl+S (forward) interactive search
- * mode in the REPL input box. Hand-rolled scorer (no dep) tuned for
- * short query strings (operator typing a few chars) over up to
- * MAX_HISTORY_ENTRIES candidates.
- *
- * Scoring model (mirrors fzf v2 mid-priorities, simplified):
- *
- *  - Substring match required. Non-matching candidates score 0.
- *  - Prefix match: +50
- *  - Word-boundary start (' ', '/', '-', '_'): +20
- *  - Camel boundary (`abcD` → 'D'): +10
- *  - Contiguous run bonus: +5 per consecutive char after the first
- *  - Distance penalty: -1 per gap char between query characters
- *  - Recency bonus: +0.5 × (recencyRank / total) so newer entries
- *    break ties in the operator's favour
- *
- * The result is a list of matches ordered by descending score with
- * the matched character positions preserved so the UI can highlight
- * them. `cycle` steps the focused match index forward (Ctrl+R again)
- * or backward (Ctrl+S) modulo the result length.
- *
- * Contract:
- *  - `searchHistory(query, entries, options)` is pure. No I/O.
- *  - Empty query returns ALL entries newest-first so the operator
- *    can browse without typing.
- *  - Matching is case-insensitive on ASCII; non-ASCII characters
- *    compare as-is.
- *  - `cycle(state, direction)` is a no-op when there are no matches.
- */
-const DEFAULT_LIMIT = 50;
-const WORD_BOUNDARIES = new Set([' ', '/', '-', '_', '.', ',', ':', ';', '\t']);
-/**
- * Score one candidate against the query. Returns `null` when the
- * query cannot be matched as an in-order substring (not necessarily
- * contiguous). The matched positions are returned so the UI can
- * underline them.
- */
-export function scoreCandidate(query, candidate) {
-    if (query.length === 0) {
-        return { score: 0, positions: [] };
-    }
-    const lowerQuery = query.toLowerCase();
-    const lowerCandidate = candidate.toLowerCase();
-    // Walk the candidate, greedily matching each query char in order.
-    const positions = [];
-    let qIdx = 0;
-    for (let i = 0; i < lowerCandidate.length && qIdx < lowerQuery.length; i += 1) {
-        if (lowerCandidate[i] === lowerQuery[qIdx]) {
-            positions.push(i);
-            qIdx += 1;
-        }
-    }
-    if (qIdx < lowerQuery.length)
-        return null;
-    // Score the match.
-    let score = 0;
-    // Prefix bonus.
-    if (positions[0] === 0)
-        score += 50;
-    // Substring contiguity + boundary bonuses.
-    let lastPos = -2;
-    for (let p = 0; p < positions.length; p += 1) {
-        const pos = positions[p];
-        // Contiguous run.
-        if (pos === lastPos + 1) {
-            score += 5;
-        }
-        else if (lastPos >= 0) {
-            // Distance penalty for non-contiguous matches.
-            score -= pos - lastPos - 1;
-        }
-        // Word-boundary start.
-        if (pos === 0) {
-            // Already counted as prefix.
-        }
-        else {
-            const prev = candidate[pos - 1] ?? '';
-            if (WORD_BOUNDARIES.has(prev)) {
-                score += 20;
-            }
-            else {
-                // Camel boundary: prev is lowercase, current is uppercase.
-                const cur = candidate[pos] ?? '';
-                if (prev === prev.toLowerCase() && cur !== cur.toLowerCase()) {
-                    score += 10;
-                }
-            }
-        }
-        lastPos = pos;
-    }
-    return { score, positions };
-}
-/**
- * Search a history list for matches. Entries are passed oldest-first
- * (the format `history.read` returns); the recency bonus uses the
- * original index so newer entries win ties.
- */
-export function searchHistory(query, entries, options = {}) {
-    const limit = options.limit ?? DEFAULT_LIMIT;
-    const total = entries.length;
-    if (query.length === 0) {
-        // Empty query - browse mode. Return newest-first up to limit, no
-        // scoring needed.
-        const out = [];
-        for (let i = total - 1; i >= 0 && out.length < limit; i -= 1) {
-            const brief = entries[i];
-            out.push({ brief, positions: [], score: 0, originalIndex: i });
-        }
-        return out;
-    }
-    const candidates = [];
-    for (let i = 0; i < total; i += 1) {
-        const brief = entries[i];
-        const scored = scoreCandidate(query, brief);
-        if (!scored)
-            continue;
-        // Recency bonus: 0..0.5 weight scaled by index/total.
-        const recency = total === 0 ? 0 : (i / total) * 0.5;
-        candidates.push({
-            brief,
-            positions: scored.positions,
-            score: scored.score + recency,
-            originalIndex: i,
-        });
-    }
-    candidates.sort((a, b) => {
-        if (b.score !== a.score)
-            return b.score - a.score;
-        // Tie-breaker: newer first.
-        return b.originalIndex - a.originalIndex;
-    });
-    return candidates.slice(0, limit);
-}
-/**
- * Initial search state for a fresh Ctrl+R press. Empty query +
- * focusedIndex 0 over the browse list.
- */
-export function initialSearchState(entries) {
-    const matches = searchHistory('', entries);
-    return { query: '', matches, focusedIndex: 0 };
-}
-/**
- * Update the search state when the operator types a new query char or
- * removes one. The focused index is clamped to the new match list so
- * the UI never points off-the-end.
- */
-export function applyQuery(state, query, entries) {
-    const matches = searchHistory(query, entries);
-    const focusedIndex = matches.length === 0 ? 0 : Math.min(state.focusedIndex, matches.length - 1);
-    return { query, matches, focusedIndex };
-}
-/**
- * Move the focused match. `+1` = next (Ctrl+R repeat), `-1` = previous
- * (Ctrl+S). Wraps around modulo result length so the operator never
- * has to chase the end.
- */
-export function cycle(state, direction) {
-    if (state.matches.length === 0)
-        return state;
-    const len = state.matches.length;
-    const next = (state.focusedIndex + direction + len) % len;
-    return { ...state, focusedIndex: next };
-}
-/**
- * Pull the brief from the currently focused match, or `null` when
- * the result list is empty (Enter accepts nothing).
- */
-export function currentBrief(state) {
-    const match = state.matches[state.focusedIndex];
-    return match ? match.brief : null;
-}
-//# sourceMappingURL=history-search.js.map

package/dist/core/repl/history.js

@@ -1,182 +0,0 @@
-/**
- * Persistent REPL history (per-workspace) - Sprint .
- *
- * Stores submitted briefs in `~/.pugi/history/<workspace-slug>.jsonl`,
- * one JSON object per line. The format is line-delimited JSON so the
- * file can be appended to atomically (single `write(2)` per entry on
- * Linux/macOS for entries < PIPE_BUF) and tailed by humans without a
- * parser. Per-workspace separation lets the operator switch repos and
- * keep brief history contextual: `brief: fix the cabinet sidebar 401`
- * does not bleed into the agents repo.
- *
- * Contract:
- *
- *  - `append({ home, workspaceSlug, brief })` writes one line. Dedups
- *    a brief that is identical to the immediately preceding entry
- *    (most common operator pattern: Up + Enter to re-run).
- *  - `read({ home, workspaceSlug })` returns entries oldest-first so
- *    the caller can navigate with `index = entries.length - 1` for
- *    "most recent" semantics.
- *  - The file is capped at MAX_ENTRIES; on overflow we keep the most
- *    recent slice and rewrite. Cheap because briefs are short text
- *    and the cap is 1000.
- *  - `slugForCwd(cwd)` normalises a working directory into a safe
- *    filename component (alphanumerics + `-`, lowercase, slashes
- *    collapsed). Empty cwd resolves to `default`.
- *  - Failures (missing $HOME, disk full, EACCES) NEVER throw. History
- *    is operator comfort, not a contract surface; degrading to "no
- *    history this session" is correct.
- *
- * Brand voice: file is operator-facing if they `cat` it, so the JSON
- * keys stay readable English (`brief`, `ts`). No forbidden words.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync, appendFileSync, renameSync, unlinkSync, } from 'node:fs';
-import { randomBytes } from 'node:crypto';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-/** Cap on stored entries per workspace. Drops oldest on overflow. */
-export const MAX_HISTORY_ENTRIES = 1000;
-/**
- * Compute the on-disk path for a given workspace slug. Tests rely on
- * this to assert per-workspace isolation without re-implementing the
- * directory math.
- */
-export function historyPath(io) {
-    const home = io.home ?? homedir();
-    const safe = sanitiseSlug(io.workspaceSlug);
-    return join(home, '.pugi', 'history', `${safe}.jsonl`);
-}
-/**
- * Append a brief to history. Dedups consecutive identical entries.
- * Returns the entry that was written, or `null` when the entry was
- * deduped or the brief was empty.
- */
-export function append(input) {
-    const brief = input.brief.trim();
-    if (brief.length === 0)
-        return null;
-    const path = historyPath(input);
-    try {
-        ensureDir(dirname(path));
-    }
-    catch {
-        return null;
-    }
-    const existing = read({ home: input.home, workspaceSlug: input.workspaceSlug });
-    const last = existing[existing.length - 1];
-    if (last && last.brief === brief) {
-        return null;
-    }
-    const ts = (input.now ?? (() => new Date()))().toISOString();
-    const entry = { ts, brief };
-    // Overflow path: combined length > cap means we trim before rewrite.
-    // Write to a sibling tmp file and renameSync over the target so
-    // concurrent CLI instances in the same workspace cannot observe a
-    // half-written file or race a parallel appendFileSync into oblivion.
-    // POSIX renameSync is atomic within a directory; on Windows fs.rename
-    // is atomic too as long as both paths are on the same volume (the tmp
-    // sibling guarantees that). P2 fix from PR triple-review.
-    if (existing.length + 1 > MAX_HISTORY_ENTRIES) {
-        const trimmed = [...existing.slice(existing.length + 1 - MAX_HISTORY_ENTRIES), entry];
-        // β1b #52 : unique-per-call tmp suffix.
-        // Previous form was a fixed `${path}.tmp`, which means two CLI
-        // processes hitting the overflow rewrite at the same moment race
-        // on the same sibling file. Whichever writeFileSync lands second
-        // can corrupt the renameSync target's content (one process's
-        // serialized buffer overwrites the other mid-flight). Append a
-        // pid + monotonic-ish timestamp + 8 hex random bytes so the tmp
-        // names are collision-proof across PIDs, concurrent calls inside
-        // one PID, and rapid re-runs that share the same ms timestamp.
-        const tmpPath = `${path}.${process.pid}.${Date.now()}.${randomBytes(4).toString('hex')}.tmp`;
-        try {
-            writeFileSync(tmpPath, trimmed.map(serialize).join('\n') + '\n', { mode: 0o600 });
-            renameSync(tmpPath, path);
-        }
-        catch {
-            // Best-effort cleanup of the orphan tmp file; never throw out.
-            try {
-                unlinkSync(tmpPath);
-            }
-            catch {
-                /* ignore — tmp file may not exist yet */
-            }
-            return null;
-        }
-        return entry;
-    }
-    try {
-        appendFileSync(path, serialize(entry) + '\n', { mode: 0o600 });
-    }
-    catch {
-        return null;
-    }
-    return entry;
-}
-/**
- * Read history for a workspace, oldest-first. Returns `[]` when the
- * file is missing, unreadable, or empty. Malformed lines are dropped
- * silently - one bad line should not nuke the whole history.
- */
-export function read(io) {
-    const path = historyPath(io);
-    if (!existsSync(path))
-        return [];
-    let raw;
-    try {
-        raw = readFileSync(path, 'utf8');
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const line of raw.split('\n')) {
-        const trimmed = line.trim();
-        if (trimmed.length === 0)
-            continue;
-        try {
-            const parsed = JSON.parse(trimmed);
-            if (typeof parsed === 'object' &&
-                parsed !== null &&
-                typeof parsed.brief === 'string' &&
-                typeof parsed.ts === 'string') {
-                out.push({
-                    ts: parsed.ts,
-                    brief: parsed.brief,
-                });
-            }
-        }
-        catch {
-            // Drop malformed line.
-        }
-    }
-    return out;
-}
-/**
- * Normalise a cwd or workspace name into a safe filename component.
- * Lowercase, alphanumerics + `-` only. Slashes become `-`. Empty input
- * resolves to `default` so we never produce an empty filename.
- */
-export function slugForCwd(cwd) {
-    if (!cwd || cwd.trim().length === 0)
-        return 'default';
-    // Strip leading slash so `/Users/foo` becomes `users-foo`.
-    const normalised = cwd
-        .replace(/^[/\\]+/, '')
-        .replace(/[/\\]+/g, '-')
-        .toLowerCase();
-    return sanitiseSlug(normalised);
-}
-function sanitiseSlug(raw) {
-    const cleaned = raw.replace(/[^a-z0-9-]/gi, '-').toLowerCase().replace(/-+/g, '-');
-    const trimmed = cleaned.replace(/^-+|-+$/g, '');
-    return trimmed.length === 0 ? 'default' : trimmed;
-}
-function serialize(entry) {
-    return JSON.stringify(entry);
-}
-function ensureDir(dir) {
-    if (existsSync(dir))
-        return;
-    mkdirSync(dir, { recursive: true, mode: 0o700 });
-}
-//# sourceMappingURL=history.js.map