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

package/dist/core/codegraph/offer-hook.js

@@ -1,220 +0,0 @@
-/**
- * Codegraph offer hook — .
- *
- * Single integration point used by both `pugi init` (standalone CLI
- * entry) AND the REPL's `/init` slash so the decision logic + telemetry
- * fan-out stays single-sourced. The hook is split into two halves:
- *
- *  1. `evaluateOffer({ workspaceRoot, nowIso })` — pure: decides if
- *     we should prompt, returns the detection result + suggested copy
- *     so the UI layer can render it however it likes (Y/n prompt in
- *     a TTY, JSON envelope in --no-tty mode, system pane line in the
- *     REPL).
- *  2. `applyOfferDecision({ workspaceRoot, accepted, … })` — side-
- *     effectful: persists the operator's verdict + runs the install
- *     if accepted + emits the right telemetry event.
- *
- * Telemetry events emitted (when consent allows):
- *  - `codegraph.offer.shown` — every time we surface the prompt
- *  - `codegraph.offer.accepted` — operator said yes
- *  - `codegraph.offer.declined` — operator said no
- *  - `codegraph.install.success` — mcp.json merge succeeded
- *  - `codegraph.install.failed` — mcp.json merge failed (rare)
- *  - `codegraph.reminder.shown` — cold-start nudge surfaced
- *  - `codegraph.stale-index.shown` — index > STALE_INDEX_DAYS
- *
- * All telemetry is best-effort fire-and-forget; emit() never throws.
- *
- * The hook NEVER prompts directly — it has no TTY contract. The
- * caller MUST resolve the operator's verdict OR call `applyOfferDecision`
- * with `accepted: false` to record a decline.
- */
-import { detectRepo, buildOfferCopy } from './detect-repo.js';
-import { shouldOfferOnInit, recordDecision, readDecision, shouldNudgeStaleIndex, indexAgeDays, } from './decision-store.js';
-import { installCodegraphMcpEntry, detectCodegraphInstalled, CODEGRAPH_DOCS_URL, } from './install.js';
-import { emit } from '../telemetry/emitter.js';
-/**
- * Pure evaluation. Reads detection + decision store. NEVER writes.
- * Reads NEVER throw — corrupt JSON returns "first-run". Tests rely on
- * this so they can drive `evaluateOffer` repeatedly without setup.
- */
-export function evaluateOffer(input) {
-    const detection = detectRepo(input.workspaceRoot);
-    if (!detection.isRepo) {
-        return { shouldPrompt: false, reason: detection.reason, detection };
-    }
-    if (!detection.offerCodegraph) {
-        return { shouldPrompt: false, reason: 'size-or-language-gate', detection };
-    }
-    // If codegraph is already declared в mcp.json, skip — the operator
-    // already adopted it (maybe via Phase 1 manual install). Cold-start
-    // hook covers the stale-index nudge separately.
-    const installed = detectCodegraphInstalled(input.workspaceRoot);
-    if (installed.installed) {
-        return { shouldPrompt: false, reason: 'already-installed', detection };
-    }
-    if (!input.ignorePriorDecision) {
-        const cadence = shouldOfferOnInit(input.workspaceRoot, input.nowIso);
-        if (!cadence.shouldOffer) {
-            return { shouldPrompt: false, reason: cadence.reason, detection };
-        }
-    }
-    return {
-        shouldPrompt: true,
-        detection: detection,
-        promptCopy: buildOfferCopy(detection),
-        docsUrl: CODEGRAPH_DOCS_URL,
-        reason: 'first-run',
-    };
-}
-export function applyOfferDecision(input) {
-    const decision = recordDecision(input.workspaceRoot, {
-        accepted: input.accepted,
-        ...(input.nowIso ? { nowIso: input.nowIso } : {}),
-    });
-    emitOfferTelemetry(input.accepted ? 'codegraph.offer.accepted' : 'codegraph.offer.declined', {
-        sizeCategory: input.detection.sizeCategory,
-        primaryLanguage: input.detection.languages[0] ?? 'unknown',
-        primarySymbolCount: input.detection.primarySymbolCount,
-    });
-    if (!input.accepted) {
-        return { kind: 'declined', decision };
-    }
-    const install = installCodegraphMcpEntry(input.workspaceRoot);
-    if (install.status === 'failed') {
-        emitOfferTelemetry('codegraph.install.failed', {
-            reason: install.reason.slice(0, 64),
-        });
-        return { kind: 'accepted-install-failed', decision, install };
-    }
-    emitOfferTelemetry('codegraph.install.success', {
-        sizeCategory: input.detection.sizeCategory,
-        primaryLanguage: input.detection.languages[0] ?? 'unknown',
-        alreadyInstalled: install.status === 'already-installed',
-    });
-    return {
-        kind: 'accepted-installed',
-        decision,
-        install,
-        docsUrl: CODEGRAPH_DOCS_URL,
-        trustCommand: 'pugi mcp trust codegraph',
-    };
-}
-/**
- * Surface the offer telemetry "shown" event. Called by the init flow
- * once it has decided to actually render the prompt (so a `--no-tty`
- * invocation that skipped the prompt does not count as a shown event).
- */
-export function emitOfferShown(detection) {
-    emitOfferTelemetry('codegraph.offer.shown', {
-        sizeCategory: detection.sizeCategory,
-        primaryLanguage: detection.languages[0] ?? 'unknown',
-        primarySymbolCount: detection.primarySymbolCount,
-    });
-}
-/**
- * Compute the cold-start nudge. Pure read — never writes. The session
- * module decides whether to render the message AND whether to call
- * `markReindexChecked(...)` after the operator dismisses it (so the
- * once-per-day throttle on `shouldNudgeStaleIndex` works).
- */
-export function evaluateColdStart(input) {
-    const detection = detectRepo(input.workspaceRoot);
-    if (!detection.isRepo) {
-        return { kind: 'silent', reason: detection.reason };
-    }
-    const decision = readDecision(input.workspaceRoot);
-    // Stale-index path takes priority — an accepted operator should be
-    // nudged about freshness before a never-asked operator is nudged
-    // about installation.
-    if (decision && decision.accepted) {
-        if (shouldNudgeStaleIndex(decision, input.nowIso)) {
-            const age = indexAgeDays(decision, input.nowIso) ?? 0;
-            emitOfferTelemetry('codegraph.stale-index.shown', { ageDays: age });
-            return {
-                kind: 'stale-index',
-                ageDays: age,
-                message: `Codegraph index is ${age} day${age === 1 ? '' : 's'} old. Run /codegraph-status to refresh.`,
-            };
-        }
-        return { kind: 'silent', reason: 'fresh-index' };
-    }
-    if (!detection.offerCodegraph) {
-        return { kind: 'silent', reason: 'size-or-language-gate' };
-    }
-    const cadence = shouldOfferOnInit(input.workspaceRoot, input.nowIso);
-    if (!cadence.shouldOffer) {
-        return { kind: 'silent', reason: cadence.reason };
-    }
-    if (cadence.reason !== 'reminder-due') {
-        // Cold-start path is strictly the "reminder" cadence — first-run
-        // offers land through `pugi init`, not the cold-start hook. The
-        // separation prevents double-prompting in the common "run pugi
-        // init + then pugi code" flow.
-        return { kind: 'silent', reason: 'first-run-handled-by-init' };
-    }
-    emitOfferTelemetry('codegraph.reminder.shown', {
-        sizeCategory: detection.sizeCategory,
-        primaryLanguage: detection.languages[0] ?? 'unknown',
-    });
-    return {
-        kind: 'remind',
-        detection,
-        message: `${buildOfferCopy(detection)} (last declined ${humanAge(decision?.offeredAt, input.nowIso)} ago)`,
-    };
-}
-/**
- * Fire one telemetry event. Telemetry meta is keyed by the canonical
- * allowlist (`flagsHash`, `parentCommand`, etc.); we re-purpose
- * `parentCommand` to carry the offer reason since the codegraph
- * event-kind taxonomy is not (yet) in the server-side allowlist.
- *
- * Best-effort: emit() drops events when consent is off and never
- * throws.
- */
-function emitOfferTelemetry(command, meta) {
-    const stringMeta = {};
-    for (const [k, v] of Object.entries(meta)) {
-        // Promote everything через the canonical `parentCommand` slot OR
-        // safe-numeric counters (retryCount). Unknown keys would be
-        // dropped by the emitter's META_ALLOWLIST guard, but routing
-        // through `parentCommand: "<key>=<value>"` keeps the signal
-        // visible на the dashboard.
-        if (typeof v === 'number') {
-            stringMeta.retryCount = v;
-        }
-        else if (typeof v === 'boolean') {
-            stringMeta.cacheHit = v;
-        }
-        else {
-            stringMeta.parentCommand = `${k}=${String(v).slice(0, 32)}`;
-        }
-    }
-    emit({
-        command,
-        kind: 'tool-call',
-        success: true,
-        meta: stringMeta,
-    });
-}
-/**
- * Format the elapsed time since `priorIso` in human-readable units
- * (days / weeks). Pure — exposed for spec parity. Falls back to
- * "earlier" when prior is missing OR unparseable.
- */
-function humanAge(priorIso, nowIso) {
-    if (!priorIso)
-        return 'earlier';
-    const now = nowIso ? Date.parse(nowIso) : Date.now();
-    const prior = Date.parse(priorIso);
-    if (!Number.isFinite(prior))
-        return 'earlier';
-    const days = Math.max(0, Math.floor((now - prior) / (24 * 60 * 60 * 1000)));
-    if (days < 1)
-        return 'today';
-    if (days < 7)
-        return `${days} day${days === 1 ? '' : 's'}`;
-    const weeks = Math.floor(days / 7);
-    return `${weeks} week${weeks === 1 ? '' : 's'}`;
-}
-//# sourceMappingURL=offer-hook.js.map

package/dist/core/compact/auto-trigger.js

@@ -1,96 +0,0 @@
-/**
- * Auto-compact threshold gate.
- *
- * Decides whether the conversation buffer has crossed the threshold
- * percent of the active model's context window. The check runs after
- * every operator/persona turn before the NEXT operator input lands so
- * the compaction completes BEFORE the model would have rejected the
- * request with a context-overflow error.
- *
- * Design choices:
- *
- *  - Pure function. The caller passes (tokenCount, windowSize, env).
- *    The gate returns a verdict; the session module owns the side
- *    effect of invoking the summariser. Pure-function shape keeps the
- *    spec exhaustive and the call site readable.
- *
- *  - Hysteresis: once a compaction lands, the marker resets the
- *    baseline token count to "summary + tail" — the gate looks at the
- *    POST-marker tokens only. This is enforced upstream by the caller
- *    passing the post-marker count; the gate itself has no memory.
- *
- *  - Two env knobs:
- *      PUGI_AUTOCOMPACT_DISABLED=1 — kill switch
- *      PUGI_AUTOCOMPACT_THRESHOLD=N — float in (0, 1] (default 0.75)
- *    Anything outside (0, 1] is rejected and the gate falls back to
- *    the default. Bad input never crashes the REPL.
- */
-/** Default trip point as a fraction of the context window. */
-export const DEFAULT_THRESHOLD = 0.75;
-/**
- * Decide whether to fire `/compact` automatically. Pure; safe to call
- * after every turn.
- */
-export function evaluateAutoCompact(input) {
-    const env = input.env ?? process.env;
-    const threshold = resolveThreshold(env);
-    if (input.windowSize <= 0 || !Number.isFinite(input.windowSize)) {
-        return {
-            kind: 'skip',
-            reason: 'invalid-window',
-            tokenCount: input.tokenCount,
-            windowSize: input.windowSize,
-            threshold,
-            pressure: 0,
-        };
-    }
-    if (env['PUGI_AUTOCOMPACT_DISABLED'] === '1') {
-        return {
-            kind: 'skip',
-            reason: 'disabled',
-            tokenCount: input.tokenCount,
-            windowSize: input.windowSize,
-            threshold,
-            pressure: roundPressure(input.tokenCount / input.windowSize),
-        };
-    }
-    const pressure = roundPressure(input.tokenCount / input.windowSize);
-    if (pressure >= threshold) {
-        return {
-            kind: 'fire',
-            tokenCount: input.tokenCount,
-            windowSize: input.windowSize,
-            threshold,
-            pressure,
-        };
-    }
-    return {
-        kind: 'skip',
-        reason: 'below-threshold',
-        tokenCount: input.tokenCount,
-        windowSize: input.windowSize,
-        threshold,
-        pressure,
-    };
-}
-/**
- * Resolve the threshold from env, clamping to the (0, 1] open-closed
- * interval. Bad input silently falls back to DEFAULT_THRESHOLD so the
- * REPL never crashes on a malformed environment variable.
- */
-function resolveThreshold(env) {
-    const raw = env['PUGI_AUTOCOMPACT_THRESHOLD'];
-    if (!raw)
-        return DEFAULT_THRESHOLD;
-    const parsed = Number.parseFloat(raw);
-    if (!Number.isFinite(parsed) || parsed <= 0 || parsed > 1) {
-        return DEFAULT_THRESHOLD;
-    }
-    return parsed;
-}
-function roundPressure(raw) {
-    if (!Number.isFinite(raw) || raw < 0)
-        return 0;
-    return Math.round(raw * 1000) / 1000;
-}
-//# sourceMappingURL=auto-trigger.js.map

package/dist/core/compact/buffer-rewriter.js

@@ -1,115 +0,0 @@
-/**
- * Type guard: discriminate a SessionEvent against the `compaction`
- * kind. Used by replay code so the boundary marker drives a different
- * code path than `user`/`persona`/`system` transcript rows.
- */
-export function isCompactBoundary(event) {
-    if (event.kind !== 'compaction')
-        return false;
-    const p = event.payload;
-    if (p === null || typeof p !== 'object')
-        return false;
-    if (p.version !== 1)
-        return false;
-    if (p.trigger !== 'manual' && p.trigger !== 'auto')
-        return false;
-    if (typeof p.summary !== 'string' || p.summary.length === 0)
-        return false;
-    if (typeof p.summaryTokenCount !== 'number')
-        return false;
-    if (typeof p.summaryTurnsBefore !== 'number')
-        return false;
-    if (typeof p.keptTailTurns !== 'number')
-        return false;
-    if (typeof p.coversUntilOffset !== 'number')
-        return false;
-    return true;
-}
-/**
- * Append one `compaction` boundary marker to the SessionStore. Returns
- * the SessionEvent we wrote so the caller can echo it into the in-
- * memory transcript without a re-read. Throws on store error so the
- * caller surfaces the failure inline.
- */
-export async function appendCompactBoundary(input) {
-    const ts = (input.now ?? (() => Date.now()))();
-    const payload = {
-        version: 1,
-        trigger: input.trigger,
-        summary: input.summary,
-        summaryTokenCount: input.summaryTokenCount,
-        summaryTurnsBefore: input.summaryTurnsBefore,
-        keptTailTurns: input.keptTailTurns,
-        coversUntilOffset: input.coversUntilOffset,
-    };
-    const event = {
-        t: ts,
-        kind: 'compaction',
-        payload,
-    };
-    await input.store.appendEvent(event);
-    return event;
-}
-/**
- * Apply replay masking to a chronological event list. Given the full
- * ordered events.jsonl content, return only the events the caller
- * should render: every event AFTER the latest `compaction` boundary,
- * plus the boundary itself (so the renderer can show the banner +
- * summary), and the K kept-tail events that landed BEFORE the boundary
- * but were preserved per the marker's `keptTailTurns`.
- *
- * Mask logic:
- *  1. Walk events. Find the LATEST boundary by offset.
- *  2. Index 0 .. coversUntilOffset-1 are masked, EXCEPT the last
- *     `keptTailTurns` of that range (which are the verbatim tail).
- *  3. The boundary event itself + everything after it stays.
- *
- * Why we expose this here (and not in session.ts): keeping the mask
- * logic next to the writer means the wire format is owned by one
- * module. session.ts depends on this; this depends on nothing in
- * session.ts. Unidirectional.
- */
-export function applyCompactMask(events) {
-    // Find latest compaction event.
-    let latestIdx = -1;
-    let latestPayload = null;
-    for (let i = events.length - 1; i >= 0; i -= 1) {
-        const ev = events[i];
-        if (isCompactBoundary(ev)) {
-            latestIdx = i;
-            latestPayload = ev.payload;
-            break;
-        }
-    }
-    if (latestIdx === -1 || latestPayload === null) {
-        return events;
-    }
-    // `coversUntilOffset` is the count of events that existed in the
-    // store immediately before the marker append. Events 0 ..
-    // coversUntilOffset-1 are summarised; events keptTailTurns of them
-    // are surfaced anyway as the verbatim tail.
-    const cap = Math.max(0, Math.min(latestPayload.coversUntilOffset, latestIdx));
-    const tailKeepCount = Math.max(0, Math.min(latestPayload.keptTailTurns, cap));
-    // Take the LAST tailKeepCount events from the masked range, but only
-    // those that represent renderable turns (user/persona/system).
-    // Boundary markers and tool stream events are NOT counted as turns
-    // for the tail-keep window — using them would let the keptTailTurns
-    // budget be consumed by infra events and the operator would lose
-    // the last K real turns. The spec is about "last K human-visible
-    // turns", not "last K events".
-    const tailSlice = [];
-    for (let i = cap - 1; i >= 0 && tailSlice.length < tailKeepCount; i -= 1) {
-        const ev = events[i];
-        if (ev.kind === 'user' || ev.kind === 'persona' || ev.kind === 'system') {
-            tailSlice.push(ev);
-        }
-    }
-    tailSlice.reverse();
-    // After the marker: everything that landed AFTER the boundary
-    // append. These are post-compaction events the user has not yet
-    // seen folded into a summary; they pass through verbatim.
-    const afterMarker = events.slice(latestIdx + 1);
-    const markerEvent = events[latestIdx];
-    return [...tailSlice, markerEvent, ...afterMarker];
-}
-//# sourceMappingURL=buffer-rewriter.js.map

package/dist/core/compact/summarizer.js

@@ -1,208 +0,0 @@
-import { estimateTokens } from './token-counter.js';
-/**
- * System prompt for the summarizer. Six closed sections + brand
- * voice clamp + "no tool calls" sentinel. The headings are stable
- * markdown so a downstream renderer can split + reformat without
- * re-parsing the model output.
- *
- * Why the explicit `If a section has no content` rule: empty sections
- * cost zero tokens but their absence is meaningful — the second model
- * reading the memo learns "no decisions were made yet" from the empty
- * `## Decisions` header. Without the rule we observed models silently
- * dropping empty sections and the reader could not distinguish "no
- * decisions" from "summarizer forgot the section".
- */
-const SUMMARIZE_SYSTEM_PROMPT = [
-    'You are the Pugi conversation summarizer. Compress the supplied',
-    'transcript into a six-section memo. Operator picks the work back up',
-    'from this memo — accuracy and completeness matter more than brevity.',
-    '',
-    'OUTPUT FORMAT (verbatim section headings, in this order):',
-    '',
-    "## Intent",
-    '(What the operator is trying to accomplish, in one paragraph.)',
-    '',
-    "## Decisions",
-    '(Bullet list of decisions made + the reasoning. Empty section means',
-    'no decisions yet — render the heading anyway.)',
-    '',
-    "## Files",
-    '(Bullet list of file paths touched, with one-line "why".)',
-    '',
-    "## Errors",
-    '(Bullet list of errors encountered + how each was resolved. Empty',
-    'means no errors — still render the heading.)',
-    '',
-    "## Tools",
-    '(Bullet list of notable tool calls and their outcomes. Group similar',
-    'calls; the goal is to surface meaningful state changes, not log',
-    'every Read.)',
-    '',
-    "## Next",
-    '(One paragraph: the immediate next planned action.)',
-    '',
-    'RULES:',
-    '- Do not invent state. Only summarise what is in the transcript.',
-    '- Preserve file paths verbatim.',
-    '- Do not call any tools (you have none).',
-    '- Do not address the operator. Write in third person.',
-    '- No emoji. No em dashes.',
-].join('\n');
-/**
- * Convert a slice of session events into the user message body the
- * summarizer ingests. We keep the format simple: one event per line,
- * prefixed with the kind, so the model can see role boundaries. Tool
- * outputs are length-capped at 4 KB each so a single 200 KB grep result
- * does not blow the summarizer's own context budget.
- */
-const TOOL_PAYLOAD_CAP_BYTES = 4096;
-export function renderEventsForSummary(events) {
-    const lines = [];
-    for (const event of events) {
-        const rendered = renderOneEvent(event);
-        if (rendered !== null)
-            lines.push(rendered);
-    }
-    return lines.join('\n');
-}
-function renderOneEvent(event) {
-    const payload = (event.payload ?? null);
-    switch (event.kind) {
-        case 'user': {
-            const text = stringField(payload, 'brief') ?? stringField(payload, 'text') ?? '';
-            if (text.length === 0)
-                return null;
-            return `[operator] ${text}`;
-        }
-        case 'persona': {
-            const text = stringField(payload, 'text') ?? '';
-            if (text.length === 0)
-                return null;
-            const slug = stringField(payload, 'personaSlug') ?? 'persona';
-            return `[${slug}] ${text}`;
-        }
-        case 'system': {
-            const text = stringField(payload, 'text') ?? '';
-            if (text.length === 0)
-                return null;
-            return `[system] ${text}`;
-        }
-        case 'tool.start': {
-            const toolName = stringField(payload, 'toolName') ?? 'unknown';
-            const args = stringField(payload, 'args') ?? '';
-            return `[tool.start ${toolName}] ${truncate(args, TOOL_PAYLOAD_CAP_BYTES)}`;
-        }
-        case 'tool.result': {
-            const toolName = stringField(payload, 'toolName') ?? 'unknown';
-            const result = stringField(payload, 'result') ?? '';
-            return `[tool.result ${toolName}] ${truncate(result, TOOL_PAYLOAD_CAP_BYTES)}`;
-        }
-        case 'agent.spawned': {
-            const slug = stringField(payload, 'personaSlug') ?? 'unknown';
-            return `[agent.spawned ${slug}]`;
-        }
-        case 'agent.completed': {
-            const slug = stringField(payload, 'personaSlug') ?? 'unknown';
-            return `[agent.completed ${slug}]`;
-        }
-        case 'compaction': {
-            // Pre-existing compact marker — its `summary` payload IS the
-            // condensed form of older history. We pass it through verbatim so
-            // the summarizer treats it as already-summarised state and folds
-            // it into the new memo (rather than re-summarising garbage).
-            const summary = stringField(payload, 'summary') ?? '';
-            if (summary.length === 0)
-                return null;
-            return `[prior compaction]\n${summary}`;
-        }
-        case 'rewind-marker': {
-            // L9 : rewind tombstones are infrastructure rows that
-            // describe a transcript edit, not conversation content. They
-            // never carry user-visible prose; the summariser drops them so
-            // the produced memo focuses on actual operator/persona turns.
-            // The masked range (events the marker covers) is already elided
-            // by `applyRewindMask` before this function is reached, so the
-            // summariser only sees a marker when it sits OUTSIDE every active
-            // rewind range — in which case the marker has already been
-            // cancelled by an undo-rewind and contributes nothing.
-            return null;
-        }
-        default: {
-            // Forward-compat: unknown kinds get a structural fingerprint so
-            // the summarizer can still represent them.
-            const exhaustive = event.kind;
-            void exhaustive;
-            return null;
-        }
-    }
-}
-function stringField(payload, key) {
-    if (!payload)
-        return undefined;
-    const value = payload[key];
-    return typeof value === 'string' ? value : undefined;
-}
-function truncate(s, capBytes) {
-    if (Buffer.byteLength(s, 'utf8') <= capBytes)
-        return s;
-    // Naive cut on UTF-16 chars — good enough for the summarizer; we
-    // append a marker so the model knows content was elided.
-    return `${s.slice(0, Math.floor(capBytes / 2))}\n... [truncated]`;
-}
-/**
- * Run one summarisation round. Throws on transport error (the caller
- * surfaces a one-line message to the operator and aborts the compact).
- * Returns the structured result on success.
- */
-export async function summarizeEvents(input) {
-    if (input.events.length === 0) {
-        throw new SummarizerError('refusing-to-summarize-empty-slice', 'No events to summarize.');
-    }
-    const userBody = renderEventsForSummary(input.events);
-    if (userBody.length === 0) {
-        throw new SummarizerError('refusing-to-summarize-empty-slice', 'All events rendered as empty.');
-    }
-    const messages = [
-        { role: 'system', content: SUMMARIZE_SYSTEM_PROMPT },
-        { role: 'user', content: userBody },
-    ];
-    const response = await input.client.send(messages, [], {
-        personaSlug: input.personaSlug,
-        tag: { tag: 'summarize' },
-        maxTokens: 2048,
-        temperature: 0.1,
-        ...(input.model !== undefined ? { model: input.model } : {}),
-        ...(input.signal !== undefined ? { signal: input.signal } : {}),
-    });
-    if (response.stop === 'error') {
-        throw new SummarizerError(response.code, `Summarizer transport failed: ${response.message}`);
-    }
-    if (response.stop === 'tool_use') {
-        // Sanity guard. We pass tools: [] so the model should not be able
-        // to invoke any; if Anvil's prompt template ever leaks tool defs
-        // we want a hard failure rather than a silent dropped summary.
-        throw new SummarizerError('unexpected-tool-call', 'Summarizer returned tool_use despite tools: []. Treating as failure.');
-    }
-    const summary = response.content.trim();
-    if (summary.length === 0) {
-        throw new SummarizerError('empty-summary', 'Summarizer returned an empty body.');
-    }
-    return {
-        summary,
-        tokensSummarised: estimateTokens(userBody),
-        eventsSummarised: input.events.length,
-    };
-}
-/**
- * Error class so the caller can branch on `error instanceof
- * SummarizerError` and surface `error.code` to the operator.
- */
-export class SummarizerError extends Error {
-    code;
-    constructor(code, message) {
-        super(message);
-        this.name = 'SummarizerError';
-        this.code = code;
-    }
-}
-//# sourceMappingURL=summarizer.js.map