howtofixcli 0.7.7 → 0.7.9

package/dist/dcp/dcp-extension.js

@@ -1,288 +0,0 @@
-import { assignMessageRefs, formatMessageIdTag, formatMessageRef, refIndicesOf, stripDcpMarkers } from "./ids.js";
-import { applyPrune, filterCompressedRanges, planPrune } from "./prune.js";
-import { activeCompressedRanges } from "./compress-state.js";
-import { rangePrompt } from "./prompts.js";
-import { enrichBlockSummary } from "./protected-content.js";
-import { getDcpState, saveDcpState } from "./state.js";
-import { readMessageText, writeMessageText } from "../prompt-text.js";
-/**
- * The ordered ref snapshot the compress tool validates against, with each row's
- * size estimate.
- *
- * `tokenCount` is not decoration: `applyCompressionState` sums it over the newly
- * covered refs to report `compressedTokens`, so a snapshot without it makes
- * every block claim to have saved nothing. The estimate is the same
- * length-over-four fallback the rest of this module uses, for the same reason -
- * DCP counts with a bundled tokenizer and this repo does not add a dependency
- * for one.
- */
-export function snapshotOf(refs, messages) {
-    const rows = [];
-    for (let position = 0; position < refs.length; position += 1) {
-        const ref = refs[position];
-        if (ref === null)
-            continue;
-        const message = messages[position];
-        const text = message && "content" in message ? readMessageText(message.content) : "";
-        rows.push({ index: ref, tokenCount: Math.round(text.length / 4) });
-    }
-    return rows;
-}
-/**
- * The selection a compress call covers, in ref space. Exported because the
- * command handlers and the compress tool both build it, and it must be built
- * the same way in both places or a range validated against one shape is applied
- * against another.
- */
-export function selectionFor(refs, startIndex, endIndex) {
-    const indices = [];
-    for (const ref of refs) {
-        if (ref !== null && ref >= startIndex && ref <= endIndex)
-            indices.push(ref);
-    }
-    return {
-        startIdx: startIndex,
-        endIdx: endIndex,
-        indices,
-        requiredBlockIds: [],
-        tokenByIndex: new Map(),
-    };
-}
-/**
- * The ref snapshot from the last prompt pass, keyed by session.
- *
- * The compress tool validates its boundaries against this, and it cannot build
- * it: all it sees is what the model passed in its arguments. The handler is the
- * one that knows the transcript, so it publishes the snapshot here and the tool
- * reads it. Process-wide and keyed by session for the same reason `state.ts` is
- * - one object per session, shared by the handler and every tool call.
- */
-/** Marks the compress instructions so a second pass does not append them twice. */
-const COMPRESS_PROMPT_MARK = "COMPRESSED BLOCK PLACEHOLDERS";
-const lastSnapshot = new Map();
-export function snapshotFor(sessionId) {
-    return lastSnapshot.get(sessionId) ?? [];
-}
-/**
- * Forget a session's snapshot.
- *
- * `lastSnapshot` is process-wide and one entry per session, and the handler
- * only ever adds to it. A session that has been replaced has no reader left for
- * its snapshot, so keeping it holds a copy of that session's whole transcript
- * for the rest of the process.
- */
-export function dropSnapshot(sessionId) {
-    lastSnapshot.delete(sessionId);
-}
-/**
- * The session the handler last ran for.
- *
- * The compress tool is registered once, at session creation, before any request
- * has happened - so it cannot capture a session id in a closure. It reads the
- * live one here instead. One process runs one main session, and `/new` or
- * `/resume` replaces it, so "the last one the handler saw" is the right answer
- * rather than a compromise.
- */
-let activeSessionId;
-export function activeDcpSession() {
-    return activeSessionId;
-}
-export function createDcpExtension(options = {}) {
-    return (hxf) => {
-        hxf.on("context_with_system", async (event, ctx) => {
-            // `ctx` carries a fresh manager per session, so the id is read here
-            // rather than cached at registration: `/new` and `/resume` swap sessions
-            // and each needs its own state file.
-            //
-            // A runner built without a session manager hands back `undefined` here,
-            // and a throw inside this handler is swallowed by the SDK — the extension
-            // then does nothing at all, silently, on every request. That is the one
-            // failure mode worse than not being registered, because nothing reports
-            // it. Falling back to a fixed key keeps the transform working; the state
-            // is per process either way.
-            const sessionId = ctx?.sessionManager?.getSessionId() ?? "dcp-sessionless";
-            const state = getDcpState(sessionId);
-            if (state.enabled === false)
-                return undefined;
-            const messages = event.messages;
-            const head = messages[0];
-            // The provider reads the prompt from index 0; without it there is nothing
-            // to rewrite, and rewriting would reorder the transcript.
-            if (!head || head.role !== "system")
-                return undefined;
-            // Refs first: every later step is expressed in ref space, and the
-            // compress tool validates against these very numbers.
-            assignMessageRefs(state.messageIds, messages);
-            const refs = refIndicesOf(state.messageIds, messages);
-            // Published before anything can fail below: the compress tool reads this
-            // to resolve the boundaries the model quotes, and a stale snapshot is a
-            // wrong boundary rather than a missing one.
-            lastSnapshot.set(sessionId, snapshotOf(refs, messages));
-            activeSessionId = sessionId;
-            // Carrier blocks are dropped and their summaries put in place before any
-            // pruning, so a pruned result can never be folded into a block.
-            //
-            // The model's own text is cleaned of any marker it imitated BEFORE the
-            // summaries go in: a summary legitimately carries its own `<dcp-message-id>b1</dcp-message-id>`
-            // and stripping after this point would delete the tag the block placeholders
-            // resolve through. Cleaning here also stops the pattern being taught back to
-            // the model on the next turn, which is how it spread in the first place.
-            const authored = stripModelMarkers(messages);
-            let working = filterCompressedRanges(authored, activeCompressedRanges(state), state.messageIds);
-            const keep = options.keepSet?.() ?? { files: [], identifiers: [] };
-            const plan = planPrune(working, keep);
-            if (plan.ops.length > 0) {
-                working = applyPrune(working, plan.ops);
-                for (const op of plan.ops) {
-                    state.prune.tools[op.callId] = (state.prune.tools[op.callId] ?? 0) + op.savedChars;
-                }
-                state.stats.totalPruneTokens = Object.values(state.prune.tools).reduce((sum, saved) => sum + saved, 0);
-            }
-            // A block created by the compress tool stored only its summary. The
-            // protected text - the user's own words, the <protect> captures, the
-            // outputs of todo/goal/context/task - is layered on here, because the
-            // handler is the only place that holds both the live transcript and the
-            // ref state the block's coverage is expressed in. The tool cannot do it:
-            // `CompressToolDeps.messages()` is a ref snapshot, not the transcript.
-            //
-            // It runs on every pass and is idempotent, so a block created mid-run is
-            // enriched on the very next request without any hook back into the tool.
-            for (const block of state.prune.messages.blocks) {
-                if (block.active && !block.protectedEnriched) {
-                    enrichBlockSummary(state, block, messages);
-                }
-            }
-            saveDcpState(sessionId);
-            // The compress instructions go into the system prompt, which is where the
-            // provider reads the prompt from. `prompts.ts` had no caller before this,
-            // so the model was offered a compress tool without ever being told the
-            // placeholder form `(bN)`, what to keep, or that user intent must be
-            // quoted rather than summarised - the one rule the whole protected-content
-            // path exists to serve.
-            //
-            // Appended to the carrier block's text, which changes only when a block is
-            // created: the text is otherwise byte-identical between turns, so it does
-            // not invalidate the cacheable prefix the way a counter would.
-            const withPrompt = working.map((message, position) => {
-                if (position !== 0 || !("content" in message))
-                    return message;
-                const body = readMessageText(message.content);
-                if (body.includes(COMPRESS_PROMPT_MARK))
-                    return message;
-                return { ...message, content: writeMessageText(message.content, `${body}\n\n${rangePrompt()}`) };
-            });
-            return { messages: tagged(withPrompt, state.messageIds) };
-        });
-    };
-}
-/**
- * Remove any ref marker from text the model authored, before the prompt is built.
- *
- * The refs are how the model names a message in a `compress` call, and it copies
- * the pattern it sees. An imitated marker is a ref the model guessed, and it
- * survives into the next request and into the stored transcript, where it reads
- * as machinery. Cleaning the model's own text is safe at exactly this point in
- * the pipeline: the summaries that carry a legitimate block tag are inserted
- * afterwards, so their tags are never touched.
- */
-function stripModelMarkers(messages) {
-    return messages.map((message) => {
-        // Only the model's own output can contain an imitation. A user message is
-        // the user's words, and a tool result is produced here.
-        if (message.role !== "assistant" || !("content" in message))
-            return message;
-        const cleaned = withCleanedText(message.content);
-        return cleaned === message.content ? message : { ...message, content: cleaned };
-    });
-}
-/**
- * Strip markers from a message's content, preserving its shape.
- *
- * Returns `unknown` for the same reason `withTaggedText` does: the SDK's content
- * union is wider than the four roles this touches, so the value is built here
- * and asserted once at the call site rather than narrowed by hand.
- */
-function withCleanedText(content) {
-    if (typeof content === "string")
-        return stripDcpMarkers(content);
-    if (!Array.isArray(content))
-        return content;
-    let changed = false;
-    const parts = content.map((part) => {
-        if (!part || typeof part !== "object" || !("type" in part) || part.type !== "text")
-            return part;
-        const text = "text" in part && typeof part.text === "string" ? part.text : "";
-        const cleaned = stripDcpMarkers(text);
-        if (cleaned === text)
-            return part;
-        changed = true;
-        return { ...part, text: cleaned };
-    });
-    return changed ? parts : content;
-}
-/**
- * Append each message's ref tag to its own content.
- *
- * The model has to see the refs to use them — `compress` takes `m0007` in its
- * arguments, and a number the prompt never showed cannot be quoted. The tag
- * rides the message it names rather than the system prompt, so it stays
- * attached through a rewind and does not invalidate the cacheable prompt
- * prefix on every turn.
- *
- * Unref'd positions (the system message, anything the SDK added) pass through
- * untouched. `working` may be shorter than the ref list after a filter, so the
- * tag is placed by walking `refs` against the array positions of the messages
- * that actually survived.
- */
-function tagged(messages, idState) {
-    const refs = refIndicesOf(idState, messages);
-    return messages.map((message, position) => {
-        const ref = refs[position];
-        if (ref === null || ref === undefined)
-            return message;
-        // `AgentMessage` includes an open `CustomAgentMessages` map, so the union
-        // does not narrow to the four SDK roles on its own. Only those four carry
-        // `content`, and they are the only ones `refIndicesOf` gave a ref to.
-        if (!("content" in message))
-            return message;
-        const tag = formatMessageIdTag(formatMessageRef(ref));
-        if (readMessageText(message.content).includes(tag))
-            return message;
-        return { ...message, content: withTaggedText(message.content, tag) };
-    });
-}
-/**
- * Append the ref tag to EVERY text part of a message, so one ref maps to the
- * whole message.
- *
- * The spec states the reason: "the same ID appears in every part of the
- * message, so one ID = one whole message". Tagging only the last text part
- * leaves a `toolCall` part with no id at all, and a model reading the call
- * cannot tell which ref it belongs to. That matters here because `compress`
- * takes refs as its arguments: a ref the model cannot attribute to the call in
- * front of it is a ref it has to guess.
- *
- * A `toolCall` part is never rewritten - its fields are the provider's wire
- * contract. A message holding only a call therefore gains one extra text part
- * to carry the tag, which is the smallest change that keeps the mapping
- * visible.
- */
-function withTaggedText(content, tag) {
-    if (typeof content === "string")
-        return content + tag;
-    if (!Array.isArray(content))
-        return content;
-    let taggedAny = false;
-    const parts = content.map((part) => {
-        if (!part || typeof part !== "object" || !("type" in part))
-            return part;
-        if (part.type !== "text")
-            return part;
-        taggedAny = true;
-        // After the `in` guard TypeScript knows `type` exists; `text` is still
-        // unknown, so it is read through a second guard rather than an assertion.
-        const existing = "text" in part && typeof part.text === "string" ? part.text : "";
-        return { ...part, text: existing + tag };
-    });
-    return taggedAny ? parts : [...parts, { type: "text", text: tag.trimStart() }];
-}

package/dist/dcp/dedup.js

@@ -1,93 +0,0 @@
-/**
- * Deduplication strategy: group tool calls by signature (tool name +
- * normalised parameters, keys sorted), keep the most recent occurrence of each
- * group, mark the rest as prunable.
- *
- * Ported from Opencode-DCP `lib/strategies/deduplication.ts`. The port is pure
- * over a message array: DCP mutated `state.prune.tools` in place, here the
- * marked tool call ids come back as a `Set` and the caller decides when to
- * apply them. Protected tools (hard-exception tools by default, plus an
- * optional protected file list such as the plan file) are never grouped, so
- * they can never be marked.
- *
- * Pure module: no I/O, no session state, never mutates `messages`.
- */
-import { HARD_EXCEPTION_TOOLS, isToolProtected } from "./protected.js";
-/**
- * Signature of a tool call: tool name plus parameters with `undefined`/`null`
- * fields dropped and all object keys sorted recursively, so key order never
- * affects the signature and a differing field always does.
- */
-export function createToolSignature(tool, parameters) {
-    if (parameters === undefined || parameters === null)
-        return tool;
-    return `${tool}::${JSON.stringify(sortObjectKeys(normalizeParameters(parameters)))}`;
-}
-/** Drop `undefined`/`null` object fields (volatile noise); arrays pass through. */
-function normalizeParameters(params) {
-    if (typeof params !== "object" || params === null)
-        return params;
-    if (Array.isArray(params))
-        return params;
-    const normalized = {};
-    for (const [key, value] of Object.entries(params)) {
-        if (value !== undefined && value !== null) {
-            normalized[key] = value;
-        }
-    }
-    return normalized;
-}
-/** Recursively sort object keys so JSON.stringify is order-independent. */
-function sortObjectKeys(value) {
-    if (typeof value !== "object" || value === null)
-        return value;
-    if (Array.isArray(value))
-        return value.map(sortObjectKeys);
-    const sorted = {};
-    for (const key of Object.keys(value).sort()) {
-        sorted[key] = sortObjectKeys(value[key]);
-    }
-    return sorted;
-}
-/**
- * The tool call ids of every duplicate occurrence — all but the last of each
- * signature group, in transcript order. Calls without a tool result yet are
- * not considered (they are still in flight; DCP dedupes executed calls only).
- */
-export function markDuplicates(messages, options) {
-    const protectedTools = [...(options?.protectedTools ?? HARD_EXCEPTION_TOOLS)];
-    const protectedFiles = options?.protectedFiles ? [...options.protectedFiles] : [];
-    // Only executed calls participate: a call counts once its tool result exists.
-    const executed = new Set();
-    for (const message of messages) {
-        if (message.role === "toolResult")
-            executed.add(message.toolCallId);
-    }
-    const groups = new Map();
-    for (const message of messages) {
-        if (message.role !== "assistant")
-            continue;
-        for (const part of message.content) {
-            if (part.type !== "toolCall" || !executed.has(part.id))
-                continue;
-            if (isToolProtected(part.name, part.arguments, protectedTools, protectedFiles))
-                continue;
-            const signature = createToolSignature(part.name, part.arguments);
-            const group = groups.get(signature);
-            if (group) {
-                group.push(part.id);
-            }
-            else {
-                groups.set(signature, [part.id]);
-            }
-        }
-    }
-    const marks = new Set();
-    for (const ids of groups.values()) {
-        if (ids.length > 1) {
-            for (const id of ids.slice(0, -1))
-                marks.add(id);
-        }
-    }
-    return marks;
-}

package/dist/dcp/ids.js

@@ -1,189 +0,0 @@
-/**
- * DCP message and block identity: `mNNNN` raw refs, `bN` block refs, both the
- * `xml` tag format and the `compact` `@7@` format, plus assignment of refs to
- * harness transcript messages.
- *
- * Ported from Opencode-DCP `lib/message-ids.ts`, adapted to one hard fact about
- * this host: harness messages carry no id. The system message and any non
- * (user | assistant | toolResult) role get no ref at all; every other message is
- * keyed by `toolResult` → toolCallId, `user`/`assistant` → `role:timestamp#n`
- * where `n` is how many messages with that same role+timestamp precede it in the
- * array. That key is stable across requests for an append-only transcript, so
- * refs assigned once stay attached to the same message.
- *
- * `refIndicesOf` is the single skip-rule source of truth: ref assignment, the
- * compress snapshot, and `filterCompressedRanges` all go through it, so the
- * three can never disagree about which message a ref number means.
- *
- * Pure module: no I/O, no session state, never mutates `messages`.
- */
-const MESSAGE_REF_REGEX = /^m(\d{4})$/;
-const BLOCK_REF_REGEX = /^b([1-9]\d*)$/;
-const COMPACT_MESSAGE_REGEX = /^@([1-9]\d*)@$/;
-const COMPACT_BLOCK_REGEX = /^@b([1-9]\d*)@$/;
-const MESSAGE_ID_TAG_NAME = "dcp-message-id";
-const MESSAGE_REF_WIDTH = 4;
-const MESSAGE_REF_MIN_INDEX = 1;
-export const MESSAGE_REF_MAX_INDEX = 9999;
-export function createMessageIdState() {
-    return { nextRef: MESSAGE_REF_MIN_INDEX, keyToRef: {}, refToKey: {} };
-}
-export function formatMessageRef(index, format = "xml") {
-    const max = format === "compact" ? Number.MAX_SAFE_INTEGER : MESSAGE_REF_MAX_INDEX;
-    if (!Number.isSafeInteger(index) || index < MESSAGE_REF_MIN_INDEX || index > max) {
-        throw new Error(`Message ID index out of bounds: ${index}. Supported range is 1-${max}.`);
-    }
-    return format === "compact" ? `@${index}@` : `m${index.toString().padStart(MESSAGE_REF_WIDTH, "0")}`;
-}
-export function formatBlockRef(blockId, format = "xml") {
-    if (!Number.isInteger(blockId) || blockId < 1) {
-        throw new Error(`Invalid block ID: ${blockId}`);
-    }
-    return format === "compact" ? `@b${blockId}@` : `b${blockId}`;
-}
-export function parseMessageRef(ref, format = "xml") {
-    const normalized = ref.trim().toLowerCase();
-    const match = normalized.match(format === "compact" ? COMPACT_MESSAGE_REGEX : MESSAGE_REF_REGEX);
-    if (!match)
-        return null;
-    const index = Number.parseInt(match[1], 10);
-    if (!Number.isSafeInteger(index))
-        return null;
-    const max = format === "compact" ? Number.MAX_SAFE_INTEGER : MESSAGE_REF_MAX_INDEX;
-    if (index < MESSAGE_REF_MIN_INDEX || index > max)
-        return null;
-    return index;
-}
-export function parseBlockRef(ref, format = "xml") {
-    const normalized = ref.trim().toLowerCase();
-    const match = normalized.match(format === "compact" ? COMPACT_BLOCK_REGEX : BLOCK_REF_REGEX);
-    if (!match)
-        return null;
-    const id = Number.parseInt(match[1], 10);
-    return Number.isSafeInteger(id) ? id : null;
-}
-/** Parse either a message ref or a block ref in the given format. */
-export function parseBoundaryId(id, format = "xml") {
-    const normalized = id.trim().toLowerCase();
-    const messageIndex = parseMessageRef(normalized, format);
-    if (messageIndex !== null) {
-        return { kind: "message", ref: formatMessageRef(messageIndex, format), index: messageIndex };
-    }
-    const blockId = parseBlockRef(normalized, format);
-    if (blockId !== null) {
-        return { kind: "compressed-block", ref: formatBlockRef(blockId, format), blockId };
-    }
-    return null;
-}
-/** Escape a value for use inside a double-quoted XML attribute. */
-export function escapeXmlAttribute(value) {
-    return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-}
-/**
- * Remove any ref marker a model wrote into its own text.
- *
- * The tags exist so the model can quote a ref in a `compress` call, and they are
- * added to a per-request copy of the transcript. A model that has read that
- * pattern can imitate it, and an imitated marker is wrong twice over: it names a
- * ref the model guessed, and it reaches the screen and the stored transcript,
- * where it reads as machinery the user was never meant to see. Observed in real
- * sessions as an answer ending in `<dcp-message-id>m0036</dcp-message-id>`.
- *
- * Only the xml form is stripped. The compact form is a bare number in `@` signs
- * and occurs in ordinary prose often enough that removing it would eat text.
- */
-export function stripDcpMarkers(text) {
-    if (!text.includes("<dcp-message-id") && !text.includes("</dcp-message-id"))
-        return text;
-    return (text
-        // A complete marker, with any attributes the writer invented.
-        .replace(/<dcp-message-id(?:\s[^>]*)?>[\s\S]*?<\/dcp-message-id>/gi, "")
-        // An opener left unpaired — a marker cut off mid-stream, or one whose closing
-        // tag never arrived. The ref it carries goes with it; a bare `m0012` left on
-        // screen names a message the user cannot act on and reads as a typo.
-        .replace(/<dcp-message-id(?:\s[^>]*)?>[mb]?\d{0,6}/gi, "")
-        // Whatever tag text is still standing, opener or closer, including a tag the
-        // stream cut before its `>` arrived.
-        .replace(/<\/?dcp-message-id(?:\s[^>]*)?>?/gi, ""));
-}
-/**
- * Render the id tag appended to a message's output.
- * xml:  `\n<dcp-message-id k="v">m0007</dcp-message-id>` (attributes sorted)
- * compact: `\n@7@ [priority]`, or `\n@blocked@` for the literal "BLOCKED".
- */
-export function formatMessageIdTag(ref, attributes, format = "xml") {
-    if (format === "compact") {
-        if (ref === "BLOCKED")
-            return "\n@blocked@";
-        const priority = attributes?.priority;
-        return `\n${ref}${priority ? ` [${priority}]` : ""}`;
-    }
-    const serializedAttributes = Object.entries(attributes || {})
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([name, value]) => {
-        if (name.trim().length === 0 || typeof value !== "string" || value.length === 0)
-            return "";
-        return ` ${name}="${escapeXmlAttribute(value)}"`;
-    })
-        .join("");
-    return `\n<${MESSAGE_ID_TAG_NAME}${serializedAttributes}>${ref}</${MESSAGE_ID_TAG_NAME}>`;
-}
-/** Roles whose messages receive a ref. System and custom roles never do. */
-function isRefEligible(message) {
-    return message.role === "user" || message.role === "assistant" || message.role === "toolResult";
-}
-/**
- * Compute the ref key for every position in the array in one pass: tool
- * results keyed by their unique call id, user/assistant messages by
- * `role:timestamp#occurrence` where `occurrence` counts earlier messages with
- * the same role+timestamp (harness messages have no id), `null` for roles that
- * never get a ref. Shared by `assignMessageRefs` and `refIndicesOf` so both
- * apply byte-identical keys.
- */
-function refKeysOf(messages) {
-    const seen = new Map();
-    return messages.map((message) => {
-        if (!isRefEligible(message))
-            return null;
-        const base = message.role === "toolResult" ? `toolResult:${message.toolCallId}` : `${message.role}:${message.timestamp}`;
-        const occurrence = seen.get(base) ?? 0;
-        seen.set(base, occurrence + 1);
-        return message.role === "toolResult" ? base : `${base}#${occurrence}`;
-    });
-}
-/**
- * Assign a ref to every message that does not have one yet. Mutates `state`
- * only — never `messages` (tagging outputs is a separate, later step). Returns
- * how many refs were newly allocated.
- */
-export function assignMessageRefs(state, messages) {
-    let assigned = 0;
-    for (const key of refKeysOf(messages)) {
-        if (key === null || state.keyToRef[key] !== undefined)
-            continue;
-        const ref = allocateNextRef(state);
-        state.keyToRef[key] = ref;
-        state.refToKey[String(ref)] = key;
-        assigned++;
-    }
-    return assigned;
-}
-function allocateNextRef(state) {
-    let candidate = Number.isInteger(state.nextRef) ? Math.max(MESSAGE_REF_MIN_INDEX, state.nextRef) : MESSAGE_REF_MIN_INDEX;
-    while (candidate <= MESSAGE_REF_MAX_INDEX) {
-        if (state.refToKey[String(candidate)] === undefined) {
-            state.nextRef = candidate + 1;
-            return candidate;
-        }
-        candidate++;
-    }
-    throw new Error(`Message ID alias capacity exceeded. Cannot allocate more than ${formatMessageRef(MESSAGE_REF_MAX_INDEX)} aliases in this session.`);
-}
-/**
- * Ref number for every position in the array, `null` for unassigned or
- * ineligible messages. The one mapping used by ref assignment, the compress
- * snapshot, and `filterCompressedRanges`.
- */
-export function refIndicesOf(state, messages) {
-    return refKeysOf(messages).map((key) => (key === null ? null : (state.keyToRef[key] ?? null)));
-}

package/dist/dcp/index.js

@@ -1,25 +0,0 @@
-/**
- * DCP's public surface, re-exported from one path.
- *
- * `session.ts` and the command handlers import from here so the module layout
- * stays free to change: the nine files under `src/dcp/` are an implementation
- * detail, this is the contract.
- *
- * DCP is dynamic context pruning. Before each LLM call it rebuilds the copy of
- * the transcript that goes to the provider: it tags every message with a stable
- * ref (`m0007`), replaces stale tool output with fixed placeholders, and folds
- * consumed ranges into compressed blocks. The session's own transcript is never
- * touched — every function here is pure over an array, and the handler returns
- * a new one.
- */
-export { MESSAGE_REF_MAX_INDEX, assignMessageRefs, createMessageIdState, escapeXmlAttribute, formatBlockRef, formatMessageIdTag, formatMessageRef, parseBlockRef, parseBoundaryId, parseMessageRef, refIndicesOf, } from "./ids.js";
-export { HARD_EXCEPTION_TOOLS, getFilePathsFromParameters, isFilePathProtected, isToolNameProtected, isToolProtected, matchesGlob, normalizePath } from "./protected.js";
-export { createToolSignature, markDuplicates } from "./dedup.js";
-export { BIG_OUTPUT_CHARS, PRUNED_QUESTION_INPUT_REPLACEMENT, PRUNED_TOOL_ERROR_INPUT_REPLACEMENT, PRUNED_TOOL_OUTPUT_REPLACEMENT, QUESTION_TOOLS, applyPrune, filterCompressedRanges, planPrune, pruneToolErrors, pruneToolInputs, pruneToolOutputs, } from "./prune.js";
-export { COMPRESSED_BLOCK_HEADER, activeCompressedRanges, allocateBlockId, allocateRunId, applyCompressionState, wrapCompressedSummary, } from "./compress-state.js";
-export { compressRanges, createCompressTool, parseBlockPlaceholders, resolveRanges, validateArgs, validateNonOverlapping, validateSummaryPlaceholders, } from "./compress.js";
-export { rangePrompt } from "./prompts.js";
-export { appendProtectedPromptInfo, appendProtectedTools, appendProtectedUserMessages, extractProtectedPromptInfo } from "./protected-content.js";
-export { createDcpState, dcpStatePath, dropDcpState, getDcpState, readConfigEnabled, resolveDcpEnabled, saveDcpState } from "./state.js";
-export { createDcpExtension, selectionFor, snapshotOf, snapshotFor, dropSnapshot, activeDcpSession } from "./dcp-extension.js";
-export { DCP_USAGE, runDcpCommand } from "./commands.js";

package/dist/dcp/prompts.js

@@ -1,68 +0,0 @@
-export function rangePrompt(format = "xml") {
-    const compact = format === "compact";
-    const message = compact ? "@4@" : "mNNNN";
-    const block = compact ? "@b1@" : "bN";
-    const placeholder = compact ? "@b1@" : "(bN)";
-    return `COMPRESSING A RANGE OF THIS CONVERSATION
-
-This is what the \`compress\` tool is for, and how a range must be summarised when it is used. Reach for it when the conversation has grown long enough that its older turns cost more than they are worth - never as a way to answer the user, and never on a range they did not ask about. Nothing here is a standing instruction to summarise: it is the contract the tool's output is held to.
-
-THE SUMMARY
-Your summary must be EXHAUSTIVE. Capture file paths, function signatures, decisions made, constraints discovered, key findings... EVERYTHING that maintains context integrity. This is not a brief note - it is an authoritative record so faithful that the original conversation adds no value.
-
-USER INTENT FIDELITY
-When the compressed range includes user messages, preserve the user's intent with extra care. Do not change scope, constraints, priorities, acceptance criteria, or requested outcomes.
-Directly quote user messages when they are short enough to include safely. Direct quotes are preferred when they best preserve exact meaning.
-
-Yet be LEAN. Strip away the noise: failed attempts that led nowhere, verbose tool outputs, back-and-forth exploration. What remains should be pure signal - golden nuggets of detail that preserve full understanding with zero ambiguity.
-
-COMPRESSED BLOCK PLACEHOLDERS
-When the selected range includes previously compressed blocks, use this exact placeholder format when referencing one:
-
-- \`${placeholder}\`
-
-Compressed block sections in context are clearly marked with a header:
-
-- \`[Compressed conversation section]\`
-
-${compact ? "Compressed block IDs look like `@b1@`, distinct from raw message IDs like `@4@`." : "Compressed block IDs always use the `bN` form (never `mNNNN`) and are represented in the same XML metadata tag format."}
-
-Rules:
-
-- Include every required block placeholder exactly once.
-- Do not invent placeholders for blocks outside the selected range.
-- Treat \`${placeholder}\` placeholders as RESERVED TOKENS. Do not emit \`${placeholder}\` text anywhere except intentional placeholders.
-- If you need to mention a block in prose, use plain text like \`compressed ${compact ? "block 1" : "bN"}\` (not as a placeholder).
-- Preflight check before finalizing: the set of \`${placeholder}\` placeholders in your summary must exactly match the required set, with no duplicates.
-
-These placeholders are semantic references. They will be replaced with the full stored compressed block content when the tool processes your output.
-
-FLOW PRESERVATION WITH PLACEHOLDERS
-When you use compressed block placeholders, write the surrounding summary text so it still reads correctly AFTER placeholder expansion.
-
-- Treat each placeholder as a stand-in for a full conversation segment, not a short label.
-- Ensure transitions before and after each placeholder preserve chronology and causality.
-- Do not write text that depends on the placeholder staying literal (for example, "as noted in \`${compact ? "@b2@" : "(b2)"}\`").
-- Your final meaning must be coherent once each placeholder is replaced with its full compressed block content.
-
-BOUNDARY IDS
-You specify boundaries by ID using the injected IDs visible in the conversation:
-
-- \`${message}\` IDs identify raw messages
-- \`${block}\` IDs identify previously compressed blocks
-
-${compact ? "Each message has an ID like `@4@`. Copy the whole marker, including both `@` characters, into `startId` and `endId`." : "Each message has an ID inside XML metadata tags like `<dcp-message-id>...</dcp-message-id>`."}
-The same ID tag appears in every tool output of the message it belongs to — each unique ID identifies one complete message.
-Treat these tags as boundary metadata only, not as tool result content.
-
-Rules:
-
-- Pick \`startId\` and \`endId\` directly from injected IDs in context.
-- IDs must exist in the current visible context.
-- \`startId\` must appear before \`endId\`.
-- Do not invent IDs. Use only IDs that are present in context.
-
-BATCHING
-When multiple independent ranges are ready and their boundaries do not overlap, include all of them as separate entries in the \`content\` array of a single tool call. Each entry should have its own \`startId\`, \`endId\`, and \`summary\`.
-`;
-}