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

package/dist/core/context/compaction.js

@@ -1,602 +0,0 @@
-/**
- * Six-tier context compaction engine for the Pugi CLI agent loop.
- *
- * Spec: `docs/research/pugi-cli-corpus/patterns/context-compaction.md`,
- * sprint slot:  §.
- *
- * Tiers and triggers (selectTier rules):
- *
- *  pressure     | tier
- *  --------------+----------------------------------------------------
- *  < 0.5       | microcompact (only if redundant tool outputs)
- *  0.5 .. 0.7  | cached_microcompact
- *  0.7 .. 0.85 | reactive_summary
- *  0.85 .. 0.95 | full_compaction
- *  > 0.95      | reset (with checkpoint)
- *
- * Tier behaviours (per pattern card §3):
- *
- *  1. microcompact        — sync; strip redundant token deltas,
- *                            collapse repeated status lines, dedupe
- *                            identical tool argument echoes; keep
- *                            tool RESULTS verbatim; target 10-20%
- *  2. cached_microcompact — sync; replace inline tool output with
- *                            { artifactRef, size } when an artifact
- *                            with matching sha256 already exists;
- *                            target 30-50% on repetitive sessions
- *  3. reactive_summary    — async-shaped; summarize the last N=10
- *                            turns into a structured turn-summary
- *                            artifact; replace those turns with a
- *                            single turn_summary event
- *  4. session_memory      — async-shaped; distill long-running build
- *                            state into .pugi/session.db (or jsonl
- *                            fallback if SQLite not yet present)
- *  5. full_compaction     — sync, slow; rebuild from event log +
- *                            artifacts + session_memory + PUGI.md;
- *                            keep open decisions, FSM state, active
- *                            tool calls, last 3 turns verbatim
- *  6. reset               — manual or >0.95; save full state to
- *                            .pugi/checkpoints/<name>/ and start
- *                            fresh with only PUGI.md + session_memory
- *
- * The compaction NEVER touches static blocks. Invariants enforce that
- * (static-hash-unchanged) plus secrets-never-summarize and
- * open-decisions-preserved. Caller is expected to run `checkInvariants`
- * before committing the result.
- *
- * All tier functions are pure with respect to the in-memory transcript;
- * disk writes (artifacts, checkpoints, session_memory) go through the
- * caller-supplied `ArtifactWriter` so tests can stub them.
- */
-import { createHash } from 'node:crypto';
-import { mkdirSync, writeFileSync } from 'node:fs';
-import { resolve } from 'node:path';
-const REACTIVE_SUMMARY_TURNS_DEFAULT = 10;
-const FULL_COMPACTION_KEEP_TURNS = 3;
-const PATTERN_BUDGET_NO_OP_THRESHOLD = 0.5;
-const PATTERN_BUDGET_CACHED_THRESHOLD = 0.7;
-const PATTERN_BUDGET_REACTIVE_THRESHOLD = 0.85;
-const PATTERN_BUDGET_FULL_THRESHOLD = 0.95;
-/**
- * Decide which tier should run for the given pressure. Pure function.
- * The engine loop calls this every tool turn and dispatches to
- * `runCompaction` with the returned tier.
- */
-export function selectTier(input) {
-    const pressure = input.contextBudgetMax > 0
-        ? input.contextBudgetUsed / input.contextBudgetMax
-        : 0;
-    if (pressure > PATTERN_BUDGET_FULL_THRESHOLD)
-        return 'reset';
-    if (pressure > PATTERN_BUDGET_REACTIVE_THRESHOLD)
-        return 'full_compaction';
-    if (pressure > PATTERN_BUDGET_CACHED_THRESHOLD)
-        return 'reactive_summary';
-    if (pressure > PATTERN_BUDGET_NO_OP_THRESHOLD)
-        return 'cached_microcompact';
-    // Sub-50% pressure: only microcompact if there's actually duplication
-    // to reclaim. The caller may treat the resulting `skipped: true`
-    // result as a no-op.
-    return 'microcompact';
-}
-/**
- * Run the requested compaction tier. The engine should `checkInvariants`
- * on the returned `CompactionResult` before committing the new
- * transcript; on violation, the engine discards the result and proceeds
- * with the pre-compaction state.
- */
-export async function runCompaction(input, tier) {
-    switch (tier) {
-        case 'microcompact':
-            return tierMicrocompact(input);
-        case 'cached_microcompact':
-            return tierCachedMicrocompact(input);
-        case 'reactive_summary':
-            return tierReactiveSummary(input);
-        case 'session_memory':
-            return tierSessionMemory(input);
-        case 'full_compaction':
-            return tierFullCompaction(input);
-        case 'reset':
-            return tierReset(input);
-        default: {
-            const exhaustive = tier;
-            throw new Error(`unknown compaction tier: ${String(exhaustive)}`);
-        }
-    }
-}
-// ---------------------------------------------------------------------
-// Tier 1: microcompact
-// ---------------------------------------------------------------------
-function tierMicrocompact(input) {
-    const beforeBytes = transcriptBytes(input.transcript);
-    const newTranscript = [];
-    let lastStatusLine = '';
-    const seenToolEchoes = new Set();
-    for (const turn of input.transcript) {
-        // Tool RESULTS are kept verbatim (pattern card §3 tier 1 explicit).
-        if (turn.kind === 'tool_result') {
-            newTranscript.push(turn);
-            continue;
-        }
-        // Tool CALL echoes: dedupe by serialized content. Same args sent
-        // twice is bookkeeping noise (e.g. a retry); keep first.
-        if (turn.kind === 'tool_call') {
-            const key = `${turn.role}::${turn.content}`;
-            if (seenToolEchoes.has(key))
-                continue;
-            seenToolEchoes.add(key);
-            newTranscript.push(turn);
-            continue;
-        }
-        // Status lines: collapse exact repeats (typical of streamed progress
-        // dots / "thinking..." stubs). We only collapse the immediate
-        // previous status; non-adjacent repeats survive.
-        const collapsed = collapseRepeatedStatusLines(turn.content);
-        if (turn.role === 'assistant' && collapsed === lastStatusLine && isStatusLike(collapsed)) {
-            continue;
-        }
-        lastStatusLine = collapsed;
-        newTranscript.push({ ...turn, content: collapsed });
-    }
-    const afterBytes = transcriptBytes(newTranscript);
-    const reclaimed = Math.max(0, beforeBytes - afterBytes);
-    return {
-        tier: 'microcompact',
-        bytesReclaimed: reclaimed,
-        artifactsCreated: [],
-        newContextSize: afterBytes,
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript,
-        summaryText: '',
-        skipped: reclaimed === 0,
-        skipReason: reclaimed === 0 ? 'no redundant lines detected' : '',
-    };
-}
-// ---------------------------------------------------------------------
-// Tier 2: cached_microcompact
-// ---------------------------------------------------------------------
-function tierCachedMicrocompact(input) {
-    const beforeBytes = transcriptBytes(input.transcript);
-    // Build a map from (tool, arguments) -> existing artifact ref. A repeat
-    // call with identical arguments is replaced with the inline ref.
-    const existingByKey = new Map();
-    const outputBytesByKey = new Map();
-    for (const out of input.toolOutputs) {
-        const key = `${out.tool}::${out.arguments}`;
-        if (out.existingArtifactRef) {
-            existingByKey.set(key, out.existingArtifactRef);
-        }
-        outputBytesByKey.set(key, out.bytes);
-    }
-    // Also fold large repeated outputs into artifact refs on the fly. If
-    // the same tool+args combo appears twice in the recent transcript and
-    // the output is >2 KB, hash and inline-replace.
-    const seenLargeOutputs = new Map();
-    const newTranscript = [];
-    const artifactsCreated = [];
-    for (const turn of input.transcript) {
-        if (turn.kind !== 'tool_result') {
-            newTranscript.push(turn);
-            continue;
-        }
-        // Try parse the tool result as { tool, arguments, output } for keying.
-        const parsed = tryParseToolResult(turn.content);
-        if (!parsed) {
-            newTranscript.push(turn);
-            continue;
-        }
-        const key = `${parsed.tool}::${parsed.arguments}`;
-        const sizeBytes = Buffer.byteLength(parsed.output, 'utf8');
-        // Already have an artifact ref for this exact call? Inline it.
-        const existing = existingByKey.get(key);
-        if (existing && sizeBytes > 256) {
-            newTranscript.push({
-                ...turn,
-                content: JSON.stringify({
-                    tool: parsed.tool,
-                    arguments: parsed.arguments,
-                    artifactRef: existing,
-                    size: sizeBytes,
-                }),
-            });
-            continue;
-        }
-        // Otherwise, large + repeated: hash, write, replace. Only act on
-        // the SECOND-and-later occurrence so the first response stays inline
-        // for the operator.
-        if (sizeBytes > 2 * 1024) {
-            const prev = seenLargeOutputs.get(key);
-            if (prev) {
-                // Replace this occurrence with the ref. We do NOT write a new
-                // artifact here unless the workspace root is supplied; tests
-                // that omit it will see size shrinkage without a disk artifact.
-                const ref = input.workspaceRoot
-                    ? maybeWriteArtifact(input, parsed.output, 'cached_microcompact', artifactsCreated)
-                    : { sha: prev.sha };
-                newTranscript.push({
-                    ...turn,
-                    content: JSON.stringify({
-                        tool: parsed.tool,
-                        arguments: parsed.arguments,
-                        artifactRef: ref.sha,
-                        size: sizeBytes,
-                    }),
-                });
-                continue;
-            }
-            // First sighting: keep inline, remember sha for next time.
-            const sha = `sha256:${sha256(parsed.output)}`;
-            seenLargeOutputs.set(key, { sha, bytes: sizeBytes });
-        }
-        newTranscript.push(turn);
-    }
-    const afterBytes = transcriptBytes(newTranscript);
-    const reclaimed = Math.max(0, beforeBytes - afterBytes);
-    return {
-        tier: 'cached_microcompact',
-        bytesReclaimed: reclaimed,
-        artifactsCreated,
-        newContextSize: afterBytes,
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript,
-        summaryText: '',
-        skipped: reclaimed === 0 && artifactsCreated.length === 0,
-        skipReason: reclaimed === 0 && artifactsCreated.length === 0
-            ? 'no repeated tool outputs eligible for ref-replacement'
-            : '',
-    };
-}
-// ---------------------------------------------------------------------
-// Tier 3: reactive_summary
-// ---------------------------------------------------------------------
-function tierReactiveSummary(input) {
-    const N = REACTIVE_SUMMARY_TURNS_DEFAULT;
-    if (input.transcript.length <= N) {
-        return skipResult('reactive_summary', input, `transcript has ${input.transcript.length} turns, threshold is ${N}`);
-    }
-    const beforeBytes = transcriptBytes(input.transcript);
-    const head = input.transcript.slice(0, input.transcript.length - N);
-    const tail = input.transcript.slice(input.transcript.length - N);
-    const summary = summarizeTurns(tail);
-    const summaryText = JSON.stringify(summary, null, 2);
-    // The summary turn carries the structured ref as its content. Engine
-    // consumers MAY hydrate the artifact ref into a full read when needed.
-    const summaryTurn = {
-        role: 'assistant',
-        content: summaryText,
-        kind: 'turn_summary',
-    };
-    const newTranscript = [...head, summaryTurn];
-    const afterBytes = transcriptBytes(newTranscript);
-    const reclaimed = Math.max(0, beforeBytes - afterBytes);
-    const artifactsCreated = [];
-    if (input.workspaceRoot) {
-        const ref = writeArtifact(input.workspaceRoot, summaryText, 'reactive_summary');
-        artifactsCreated.push(ref);
-    }
-    return {
-        tier: 'reactive_summary',
-        bytesReclaimed: reclaimed,
-        artifactsCreated,
-        newContextSize: afterBytes,
-        // The head turns are kept verbatim in newTranscript, so any
-        // DECISION/OPEN/BLOCKED/REJECTED lines in the head are physically
-        // preserved. But `summary.decisions` only scans the tail (and only
-        // captures DECISION/OPEN/REJECTED, never BLOCKED) — so the
-        // invariant cross-check, which walks before.transcript looking for
-        // every marker line, would fire on every head decision and every
-        // BLOCKED line. Use extractFourMarkers across the whole input to
-        // report the union; the lines are actually preserved (head verbatim,
-        // tail in summary), so reporting them is honest.
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript,
-        summaryText,
-        skipped: false,
-        skipReason: '',
-    };
-}
-// ---------------------------------------------------------------------
-// Tier 4: session_memory
-// ---------------------------------------------------------------------
-function tierSessionMemory(input) {
-    const beforeBytes = transcriptBytes(input.transcript);
-    // Distill into a session-memory record. The shape matches the spec:
-    // open task graph state, completed nodes, blocked nodes, key
-    // decisions, rejected approaches.
-    const memory = {
-        sessionId: input.sessionId,
-        timestamp: new Date().toISOString(),
-        openTasks: extractMarked(input.transcript, /^\s*OPEN:\s*(.+)$/),
-        completed: extractMarked(input.transcript, /^\s*DONE:\s*(.+)$/),
-        blocked: extractMarked(input.transcript, /^\s*BLOCKED:\s*(.+)$/),
-        decisions: extractMarked(input.transcript, /^\s*DECISION:\s*(.+)$/),
-        rejected: extractMarked(input.transcript, /^\s*REJECTED:\s*(.+)$/),
-    };
-    const summaryText = JSON.stringify(memory, null, 2);
-    const artifactsCreated = [];
-    if (input.workspaceRoot) {
-        // SQLite migration arrives in (per spec). Until then we append
-        // a JSONL line to .pugi/session-memory.jsonl, which the next session
-        // bootstraps into context.
-        const path = resolve(input.workspaceRoot, '.pugi', 'session-memory.jsonl');
-        try {
-            mkdirSync(resolve(input.workspaceRoot, '.pugi'), { recursive: true });
-            writeFileSync(path, `${JSON.stringify(memory)}\n`, { flag: 'a', mode: 0o600 });
-        }
-        catch {
-            // best effort — fall through with no artifact record
-        }
-        const ref = writeArtifact(input.workspaceRoot, summaryText, 'session_memory');
-        artifactsCreated.push(ref);
-    }
-    // Session memory does not modify the active transcript on its own —
-    // it's a side-channel that survives across reactive_summary cycles.
-    return {
-        tier: 'session_memory',
-        bytesReclaimed: 0,
-        artifactsCreated,
-        newContextSize: beforeBytes,
-        // The structured `memory.decisions` field above strips the marker
-        // prefix for the session-memory.jsonl record. The invariant check
-        // compares full lines (with `DECISION:` prefix) against
-        // `before.transcript`, so we must surface the full-line shape here.
-        // Using `memory.decisions` directly would fail the invariant on
-        // every run.
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript: input.transcript,
-        summaryText,
-        skipped: false,
-        skipReason: '',
-    };
-}
-// ---------------------------------------------------------------------
-// Tier 5: full_compaction
-// ---------------------------------------------------------------------
-function tierFullCompaction(input) {
-    const beforeBytes = transcriptBytes(input.transcript);
-    if (input.transcript.length <= FULL_COMPACTION_KEEP_TURNS) {
-        return skipResult('full_compaction', input, `transcript only ${input.transcript.length} turns, keep window is ${FULL_COMPACTION_KEEP_TURNS}`);
-    }
-    const keep = input.transcript.slice(-FULL_COMPACTION_KEEP_TURNS);
-    const distilled = summarizeTurns(input.transcript.slice(0, -FULL_COMPACTION_KEEP_TURNS));
-    const summaryText = JSON.stringify(distilled, null, 2);
-    const summaryTurn = {
-        role: 'assistant',
-        content: summaryText,
-        kind: 'turn_summary',
-    };
-    const newTranscript = [summaryTurn, ...keep];
-    const afterBytes = transcriptBytes(newTranscript);
-    const reclaimed = Math.max(0, beforeBytes - afterBytes);
-    const artifactsCreated = [];
-    if (input.workspaceRoot) {
-        const ref = writeArtifact(input.workspaceRoot, summaryText, 'full_compaction');
-        artifactsCreated.push(ref);
-    }
-    return {
-        tier: 'full_compaction',
-        bytesReclaimed: reclaimed,
-        artifactsCreated,
-        newContextSize: afterBytes,
-        // `distilled.decisions` only carries DECISION/OPEN/REJECTED. The
-        // invariant compares against all four markers in the pre-compaction
-        // transcript, so we union with extractFourMarkers to include any
-        // BLOCKED lines that lived in the head and would otherwise trip
-        // open-decisions-preserved. The keep window also has decisions; both
-        // are scanned because the invariant walks the FULL before.transcript.
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript,
-        summaryText,
-        skipped: false,
-        skipReason: '',
-    };
-}
-// ---------------------------------------------------------------------
-// Tier 6: reset
-// ---------------------------------------------------------------------
-function tierReset(input) {
-    const beforeBytes = transcriptBytes(input.transcript);
-    const distilled = summarizeTurns(input.transcript);
-    const summaryText = JSON.stringify({ ...distilled, reason: 'context budget >95%, full reset triggered' }, null, 2);
-    const artifactsCreated = [];
-    if (input.workspaceRoot) {
-        // Checkpoint dump for replay; named after the session + timestamp.
-        const checkpointName = `${input.sessionId}-${Date.now()}`;
-        const checkpointDir = resolve(input.workspaceRoot, '.pugi', 'checkpoints', checkpointName);
-        try {
-            mkdirSync(checkpointDir, { recursive: true });
-            writeFileSync(resolve(checkpointDir, 'transcript.json'), JSON.stringify(input.transcript, null, 2), { mode: 0o600 });
-            writeFileSync(resolve(checkpointDir, 'summary.json'), summaryText, { mode: 0o600 });
-        }
-        catch {
-            // best effort — the caller still gets the in-memory result
-        }
-        const ref = writeArtifact(input.workspaceRoot, summaryText, 'reset');
-        artifactsCreated.push(ref);
-    }
-    // Post-reset transcript is a single seed message describing the reset.
-    const seed = {
-        role: 'assistant',
-        content: summaryText,
-        kind: 'turn_summary',
-    };
-    return {
-        tier: 'reset',
-        bytesReclaimed: Math.max(0, beforeBytes - Buffer.byteLength(seed.content, 'utf8')),
-        artifactsCreated,
-        newContextSize: Buffer.byteLength(seed.content, 'utf8'),
-        // Same rationale as full_compaction: use the four-marker helper so
-        // BLOCKED lines are preserved alongside DECISION/OPEN/REJECTED.
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript: [seed],
-        summaryText,
-        skipped: false,
-        skipReason: '',
-    };
-}
-// ---------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------
-function transcriptBytes(transcript) {
-    return transcript.reduce((sum, t) => sum + Buffer.byteLength(t.content, 'utf8'), 0);
-}
-function isStatusLike(line) {
-    // Treat short, lowercase, no-period lines as status. Real prose
-    // usually has punctuation or capital letters.
-    if (line.length === 0 || line.length > 80)
-        return false;
-    if (/[.!?]\s*$/.test(line))
-        return false;
-    return true;
-}
-function collapseRepeatedStatusLines(content) {
-    // Within a single turn, collapse any two adjacent identical lines
-    // into one. Streaming "thinking..." style status emits these.
-    const lines = content.split('\n');
-    if (lines.length < 2)
-        return content;
-    const out = [];
-    let prev = '';
-    for (const line of lines) {
-        if (line === prev && isStatusLike(line))
-            continue;
-        out.push(line);
-        prev = line;
-    }
-    return out.join('\n');
-}
-function tryParseToolResult(content) {
-    try {
-        const parsed = JSON.parse(content);
-        if (parsed &&
-            typeof parsed === 'object' &&
-            typeof parsed.tool === 'string' &&
-            typeof parsed.output === 'string') {
-            const p = parsed;
-            return {
-                tool: String(p.tool),
-                arguments: String(p.arguments ?? ''),
-                output: String(p.output),
-            };
-        }
-    }
-    catch {
-        // not JSON — skip
-    }
-    return null;
-}
-function summarizeTurns(turns) {
-    const decisions = [];
-    const blockers = [];
-    const filesTouched = new Set();
-    let goal = '';
-    let nextStep = '';
-    for (const turn of turns) {
-        if (turn.role === 'user' && !goal) {
-            goal = firstSentence(turn.content);
-        }
-        for (const line of turn.content.split('\n')) {
-            const t = line.trim();
-            if (/^DECISION:/.test(t) || /^OPEN:/.test(t) || /^REJECTED:/.test(t))
-                decisions.push(t);
-            if (/^BLOCKED:/.test(t))
-                blockers.push(t);
-            // Crude file capture: paths look like a/b/c.ts or apps/x/src/y.ts.
-            const pathMatches = line.match(/\b[a-z0-9_-]+(?:\/[A-Za-z0-9._-]+){1,}\.[a-z]{1,5}\b/g);
-            if (pathMatches)
-                for (const p of pathMatches)
-                    filesTouched.add(p);
-            // Last imperative line of the assistant becomes next_step.
-            if (turn.role === 'assistant' && /^(?:next|todo|run|build|test|ship|deploy)\b/i.test(t)) {
-                nextStep = t;
-            }
-        }
-    }
-    return {
-        goal: goal || '(no explicit user goal in window)',
-        decisions,
-        blockers,
-        files_touched: [...filesTouched].sort(),
-        next_step: nextStep || '(no explicit next step recorded)',
-    };
-}
-/**
- * Extract every DECISION/OPEN/BLOCKED/REJECTED line from the transcript,
- * preserving the marker prefix (`DECISION: ...`). This is the shape
- * `checkInvariants` expects in `decisionsPreserved`: it walks the
- * pre-compaction transcript collecting the same shape and compares
- * line-for-line. Any tier that drops the prefix (or omits a marker
- * type) will trip `open-decisions-preserved` on every run.
- *
- * Used by all six tiers when they populate `decisionsPreserved`. The
- * structured-memory variant (`extractMarked`, suffix-only) is for the
- * separate session-memory record format and is not invariant-relevant.
- */
-function extractFourMarkers(turns) {
-    const out = [];
-    for (const turn of turns) {
-        for (const line of turn.content.split('\n')) {
-            const t = line.trim();
-            if (/^(?:DECISION|OPEN|BLOCKED|REJECTED):/.test(t))
-                out.push(t);
-        }
-    }
-    return out;
-}
-function extractMarked(turns, rx) {
-    const out = [];
-    for (const turn of turns) {
-        for (const line of turn.content.split('\n')) {
-            const m = rx.exec(line);
-            if (m && m[1])
-                out.push(m[1].trim());
-        }
-    }
-    return out;
-}
-function firstSentence(content) {
-    const trimmed = content.trim();
-    const m = /^[^.!?\n]{1,200}/.exec(trimmed);
-    return m ? m[0].trim() : trimmed.slice(0, 200);
-}
-function sha256(input) {
-    return createHash('sha256').update(input, 'utf8').digest('hex');
-}
-function writeArtifact(workspaceRoot, content, producedBy) {
-    const sha = sha256(content);
-    const dir = resolve(workspaceRoot, '.pugi', 'artifacts');
-    mkdirSync(dir, { recursive: true });
-    const path = resolve(dir, `${sha}.json`);
-    writeFileSync(path, content, { mode: 0o600 });
-    return {
-        sha256: `sha256:${sha}`,
-        path,
-        size: Buffer.byteLength(content, 'utf8'),
-        producedBy,
-    };
-}
-function maybeWriteArtifact(input, content, producedBy, collector) {
-    if (input.workspaceRoot) {
-        const ref = writeArtifact(input.workspaceRoot, content, producedBy);
-        collector.push(ref);
-        return { sha: ref.sha256 };
-    }
-    // Test/no-disk fallback: return the in-memory sha without persisting.
-    return { sha: `sha256:${sha256(content)}` };
-}
-function skipResult(tier, input, reason) {
-    const bytes = transcriptBytes(input.transcript);
-    return {
-        tier,
-        bytesReclaimed: 0,
-        artifactsCreated: [],
-        newContextSize: bytes,
-        decisionsPreserved: extractFourMarkers(input.transcript),
-        newTranscript: input.transcript,
-        summaryText: '',
-        skipped: true,
-        skipReason: reason,
-    };
-}
-//# sourceMappingURL=compaction.js.map

package/dist/core/context/index.js

@@ -1,28 +0,0 @@
-/**
- * Three-tier context model - Phase 1 barrel.
- *
- * Bundles the four primitives so the REPL bootstrap can import from a
- * single path:
- *
- *  import {
- *    loadPugiIgnore,
- *    buildRepoSkeleton,
- *    renderSkeleton,
- *    WorkingSet,
- *    PugiWatcher,
- *  } from '../context/index.js';
- *
- * No new logic lives here - just re-exports.
- */
-export { BASELINE_IGNORE_PATTERNS, SECRET_IGNORE_PATTERNS, globalPugiIgnorePath, loadPugiIgnore, parsePatternText, readPatternFile, workspaceGitIgnorePath, workspacePugiIgnorePath, } from './pugiignore.js';
-export { COLLAPSE_DIR_ENTRIES, MAX_README_LINES, MAX_SKELETON_BYTES, MAX_TREE_DEPTH, MAX_WALK_NODES, TOP_LANGUAGES, buildRepoSkeleton, detectPackageManager, languageForExtension, readGitBranch, readPackageJson, readReadme, renderSkeleton, topLanguages, } from './repo-skeleton.js';
-export { DEFAULT_WORKING_SET_CAPACITY, WorkingSet, } from './working-set.js';
-export { MAX_WATCHED_PATHS, PugiWatcher, THROTTLE_WINDOW_MS, } from './watcher.js';
-/**
- * β5a R4+P5 — per-directory PUGI.md / AGENTS.md / CLAUDE.md / GEMINI.md
- * traverse-up. Loads agent-context markdown at every directory between
- * `cwd` and `workspaceRoot` (workspace root file is owned by
- * `loadMarkdownContext` in `markdown-loader.ts` — no double-load).
- */
-export { MAX_TRAVERSE_BYTES, MAX_TRAVERSE_PER_FILE_BYTES, MAX_TRAVERSE_DEPTH, TRAVERSE_SOURCES, loadTraversedMarkdown, } from './markdown-traverse.js';
-//# sourceMappingURL=index.js.map