@astudioplus/compressor 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { compress, policyFor, OMISSION_MARKER } from './engine/index.ts';
+export type { AppliedTransform, CompressMeta, CompressResult, CompressStats, ContentKind, Estimator, Mode, Policy, ToolKind, } from './engine/index.ts';
+export { cheapEstimator, estimateTokens, tiktokenEstimator } from './tokens/estimate.ts';
+export { countTokensExact } from './tokens/exact.ts';
+export { addUsage, aggregateUsage, encodeProjectDir, findTranscripts, readSessionUsage, } from './claude/transcripts.ts';
+export type { SessionUsage, UsageTotals } from './claude/transcripts.ts';
+export { ATOMS, getAtom } from './packs/atoms.ts';
+export { atomsForMode, MODE_DESCRIPTIONS } from './packs/modes.ts';
+export { atomManifest, markerBegin, MARKER_BEGIN_PREFIX, MARKER_END, parseAtomManifest, renderCursorRules, renderMarkedSection, renderOutputStyle, } from './packs/render.ts';
+export type { AgentName, Atom, AtomCategory, PackMode, RenderedArtifact, } from './packs/types.ts';
+export { adapters, getAdapter, applyChanges, renderChanges, claudeCodeAdapter, copilotAdapter, cursorAdapter, agentsMdAdapter, } from './adapters/index.ts';
+export type { Adapter, AdapterContext, AdapterStatus, FileChange, ModeArg, } from './adapters/index.ts';
+export { handlePostToolUse } from './hook/post-tool-use.ts';
+export type { HookResult } from './hook/post-tool-use.ts';
+export { resolveHookCommand } from './paths.ts';

package/dist/index.js

@@ -0,0 +1,16 @@
+// engine
+export { compress, policyFor, OMISSION_MARKER } from "./engine/index.js";
+// tokens
+export { cheapEstimator, estimateTokens, tiktokenEstimator } from "./tokens/estimate.js";
+export { countTokensExact } from "./tokens/exact.js";
+// transcripts
+export { addUsage, aggregateUsage, encodeProjectDir, findTranscripts, readSessionUsage, } from "./claude/transcripts.js";
+// packs
+export { ATOMS, getAtom } from "./packs/atoms.js";
+export { atomsForMode, MODE_DESCRIPTIONS } from "./packs/modes.js";
+export { atomManifest, markerBegin, MARKER_BEGIN_PREFIX, MARKER_END, parseAtomManifest, renderCursorRules, renderMarkedSection, renderOutputStyle, } from "./packs/render.js";
+// adapters
+export { adapters, getAdapter, applyChanges, renderChanges, claudeCodeAdapter, copilotAdapter, cursorAdapter, agentsMdAdapter, } from "./adapters/index.js";
+// hook
+export { handlePostToolUse } from "./hook/post-tool-use.js";
+export { resolveHookCommand } from "./paths.js";

package/dist/ledger/read.d.ts

@@ -0,0 +1,9 @@
+import type { LedgerEvent } from './write.ts';
+export interface ReadLedgerOptions {
+    /** ledger directory (default: COMPRESSOR_LEDGER_DIR or ~/.compressor/ledger) */
+    dir?: string;
+    /** only events at or after this instant */
+    since?: Date;
+}
+/** Read every monthly file, tolerant of garbage lines; sorted by timestamp. */
+export declare function readLedger(opts?: ReadLedgerOptions): Promise<LedgerEvent[]>;

package/dist/ledger/read.js

@@ -0,0 +1,91 @@
+import path from 'node:path';
+import { readdir, readFile } from 'node:fs/promises';
+import { resolveLedgerDir } from "./write.js";
+const AGENTS = new Set(['claude-code', 'copilot']);
+const TOOLS = new Set(['read', 'bash', 'search', 'other']);
+const MODES = new Set(['full', 'optimized', 'slim']);
+function isFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value);
+}
+function parseEvent(line) {
+    let raw;
+    try {
+        raw = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+        return null;
+    }
+    const record = raw;
+    const ts = record['ts'];
+    const agent = record['agent'];
+    const tool = record['tool'];
+    const mode = record['mode'];
+    const transforms = record['transforms'];
+    if (typeof ts !== 'string' ||
+        typeof agent !== 'string' ||
+        !AGENTS.has(agent) ||
+        typeof tool !== 'string' ||
+        !TOOLS.has(tool) ||
+        typeof mode !== 'string' ||
+        !MODES.has(mode) ||
+        !isFiniteNumber(record['charsIn']) ||
+        !isFiniteNumber(record['charsOut']) ||
+        !isFiniteNumber(record['estTokensIn']) ||
+        !isFiniteNumber(record['estTokensOut']) ||
+        !Array.isArray(transforms) ||
+        !transforms.every((t) => typeof t === 'string')) {
+        return null;
+    }
+    return {
+        ts,
+        agent: agent,
+        tool: tool,
+        mode: mode,
+        charsIn: record['charsIn'],
+        charsOut: record['charsOut'],
+        estTokensIn: record['estTokensIn'],
+        estTokensOut: record['estTokensOut'],
+        transforms,
+    };
+}
+/** Read every monthly file, tolerant of garbage lines; sorted by timestamp. */
+export async function readLedger(opts = {}) {
+    const dir = opts.dir ?? resolveLedgerDir();
+    let names;
+    try {
+        names = await readdir(dir);
+    }
+    catch {
+        return [];
+    }
+    const events = [];
+    for (const name of names.filter((n) => n.endsWith('.jsonl')).sort()) {
+        let body;
+        try {
+            body = await readFile(path.join(dir, name), 'utf8');
+        }
+        catch {
+            continue;
+        }
+        for (const line of body.split('\n')) {
+            if (line.trim() === '') {
+                continue;
+            }
+            const event = parseEvent(line);
+            if (event === null) {
+                continue;
+            }
+            if (opts.since !== undefined) {
+                const when = Date.parse(event.ts);
+                if (Number.isNaN(when) || when < opts.since.getTime()) {
+                    continue;
+                }
+            }
+            events.push(event);
+        }
+    }
+    return events.sort((a, b) => a.ts.localeCompare(b.ts));
+}

package/dist/ledger/write.d.ts

@@ -0,0 +1,29 @@
+import type { Mode, ToolKind } from '../engine/types.ts';
+export interface LedgerEvent {
+    /** ISO timestamp of the compression event */
+    ts: string;
+    agent: 'claude-code' | 'copilot';
+    tool: ToolKind;
+    mode: Mode;
+    charsIn: number;
+    charsOut: number;
+    estTokensIn: number;
+    estTokensOut: number;
+    /** AppliedTransform ids, e.g. ['dedupe-lines', 'truncate'] */
+    transforms: string[];
+}
+/** Resolved at call time (not module load) so tests can swap the env var. */
+export declare function resolveLedgerDir(): string;
+/**
+ * Append one event to the monthly ledger file. Never rejects; every error is
+ * swallowed (fail-open). When COMPRESSOR_NO_LEDGER=1 this returns before any
+ * filesystem work.
+ */
+export declare function appendLedger(event: LedgerEvent): Promise<void>;
+/**
+ * Resolves when all appends in flight at call time have finished (each one
+ * already swallows its own errors, so this never rejects). Hook entries race
+ * this against a hard 250ms timer before exiting so writes flush without
+ * ever delaying the agent meaningfully.
+ */
+export declare function settleLedger(): Promise<void>;

package/dist/ledger/write.js

@@ -0,0 +1,61 @@
+import os from 'node:os';
+import path from 'node:path';
+import process from 'node:process';
+import { appendFile, mkdir } from 'node:fs/promises';
+/** Resolved at call time (not module load) so tests can swap the env var. */
+export function resolveLedgerDir() {
+    return (process.env['COMPRESSOR_LEDGER_DIR'] ?? path.join(os.homedir(), '.compressor', 'ledger'));
+}
+/** Monthly file name from the event timestamp; falls back to 'unknown'. */
+function monthOf(ts) {
+    const month = ts.slice(0, 7);
+    return /^\d{4}-\d{2}$/.test(month) ? month : 'unknown';
+}
+// mkdir -p once per directory (keyed by dir: tests point COMPRESSOR_LEDGER_DIR
+// at fresh temp dirs within one process). Errors are swallowed here AND
+// surfaced again by appendFile, which is also swallowed.
+const mkdirCache = new Map();
+const pending = new Set();
+/**
+ * Append one event to the monthly ledger file. Never rejects; every error is
+ * swallowed (fail-open). When COMPRESSOR_NO_LEDGER=1 this returns before any
+ * filesystem work.
+ */
+export async function appendLedger(event) {
+    if (process.env['COMPRESSOR_NO_LEDGER'] === '1') {
+        return;
+    }
+    const task = (async () => {
+        try {
+            const dir = resolveLedgerDir();
+            let made = mkdirCache.get(dir);
+            if (made === undefined) {
+                made = mkdir(dir, { recursive: true }).then(() => undefined, () => undefined);
+                mkdirCache.set(dir, made);
+            }
+            await made;
+            const file = path.join(dir, `${monthOf(event.ts)}.jsonl`);
+            await appendFile(file, `${JSON.stringify(event)}\n`, 'utf8');
+        }
+        catch {
+            // FAIL-OPEN: ledger problems are never the agent's problem.
+        }
+    })();
+    pending.add(task);
+    void task.finally(() => pending.delete(task));
+    return task;
+}
+/**
+ * Resolves when all appends in flight at call time have finished (each one
+ * already swallows its own errors, so this never rejects). Hook entries race
+ * this against a hard 250ms timer before exiting so writes flush without
+ * ever delaying the agent meaningfully.
+ */
+export async function settleLedger() {
+    try {
+        await Promise.all([...pending]);
+    }
+    catch {
+        // unreachable (tasks never reject), kept for fail-open symmetry
+    }
+}

package/dist/packs/atoms.d.ts

@@ -0,0 +1,3 @@
+import type { Atom } from './types.ts';
+export declare const ATOMS: readonly Atom[];
+export declare function getAtom(id: string): Atom | undefined;

package/dist/packs/atoms.js

@@ -0,0 +1,108 @@
+export const ATOMS = [
+    {
+        id: 'out.no-preamble',
+        category: 'output',
+        text: `Start every response with the answer or the action. No preamble ("I'll help you...", "Let me...", "Great question"), no plan narration for single-step work.`,
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'out.no-postamble',
+        category: 'output',
+        text: `No filler, hedging, or politeness padding. No "feel free to ask", no recap closings.`,
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'out.answer-first',
+        category: 'output',
+        text: 'Lead with the conclusion. Supporting detail comes after, only if it changes what the reader does next.',
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'out.no-recap',
+        category: 'output',
+        text: `Do not summarize what you just did unless asked. After edits, state the result in one line at most ("Fixed the null check in parser.ts:142").`,
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'out.no-code-echo',
+        category: 'output',
+        text: `Never restate code in prose. The diff or the file is the explanation. Don't quote code you just wrote back to the user.`,
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'out.minimal-formatting',
+        category: 'output',
+        text: 'Use plain sentences for short answers. Reserve headers and bullets for genuinely multi-part responses.',
+        modes: ['optimized'],
+    },
+    {
+        id: 'out.explanation-budget',
+        category: 'output',
+        text: 'Hard budget: at most ~10% of your response may be explanation. For a 40-line diff, that is 2-4 short lines. When in doubt, omit the explanation.',
+        modes: ['slim'],
+    },
+    {
+        id: 'out.code-only-default',
+        category: 'output',
+        text: `Respond with code, diffs, commands, and file paths. Prose is for what code cannot express: a decision between alternatives, a risk, a required manual step. Acceptable response shapes: a bare code block; a path followed by a diff; a one-line answer. "Done." is a complete response to a completed task. Never explain what standard code does — only flag the non-obvious: side effects, breaking changes, things the user must do themselves. If the task is ambiguous enough that proceeding risks wasted work, ask one terse question instead of writing a hedged essay.`,
+        modes: ['slim'],
+    },
+    {
+        id: 'beh.targeted-reads',
+        category: 'behavior',
+        text: 'Read only what you need: prefer Grep/Glob to locate, then Read with offset/limit for the relevant range. Read a whole file only when it is small or you must edit broadly across it.',
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'beh.no-reread',
+        category: 'behavior',
+        text: 'Never re-read a file you already have in context, unless it changed or earlier output was compressed — a [compressor: ...] marker means lines were omitted and tells you the exact offset/limit to Read if you need them.',
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'beh.no-tool-echo',
+        category: 'behavior',
+        text: `Do not quote tool output back in your response; reference it ("tests pass", "3 matches in src/").`,
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'beh.surgical-edits',
+        category: 'behavior',
+        text: 'Prefer surgical edits to full-file rewrites. Batch related edits to the same file into one operation.',
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'beh.bounded-commands',
+        category: 'behavior',
+        text: 'Bound command output: use flags like --quiet, head -50, or targeted test selection rather than dumping full logs.',
+        modes: ['optimized', 'slim'],
+    },
+    {
+        id: 'tokens.drop-articles',
+        category: 'output',
+        text: 'Omit articles (a, an, the) and filler words from responses.',
+        modes: ['optimized', 'slim'],
+        rejected: {
+            reason: '~1 token saved per article, output-only; degrades grammar and pushes the model off its training distribution for single-digit savings. Empirically refuted: bench-20260610-124626 (sonnet, 9 tasks ×2 trials) measured optimized-plus-tokens-drop-articles at −2.2% output vs optimized — noise, no benefit on top of a concise baseline. Kept for --ablate-add reproduction.',
+        },
+    },
+    {
+        id: 'tokens.no-politeness-words',
+        category: 'output',
+        text: 'Never use the words please or thank you.',
+        modes: ['optimized', 'slim'],
+        rejected: {
+            reason: 'Micro-optimization already subsumed by out.no-postamble; word-level bans distract the model more than they save.',
+        },
+    },
+];
+const byId = new Map();
+for (const atom of ATOMS) {
+    if (byId.has(atom.id)) {
+        throw new Error(`duplicate atom id: ${atom.id}`);
+    }
+    byId.set(atom.id, atom);
+}
+export function getAtom(id) {
+    return byId.get(id);
+}

package/dist/packs/modes.d.ts

@@ -0,0 +1,3 @@
+import type { AgentName, Atom, PackMode } from './types.ts';
+export declare function atomsForMode(mode: PackMode, agent?: AgentName): Atom[];
+export declare const MODE_DESCRIPTIONS: Record<PackMode, string>;

package/dist/packs/modes.js

@@ -0,0 +1,34 @@
+import { getAtom } from "./atoms.js";
+/** Curated render order — explicit so object-key order can never reorder output. */
+const MODE_ORDER = [
+    'out.no-preamble',
+    'out.answer-first',
+    'out.no-recap',
+    'out.no-code-echo',
+    'out.no-postamble',
+    'out.minimal-formatting',
+    'out.explanation-budget',
+    'out.code-only-default',
+    'beh.targeted-reads',
+    'beh.no-reread',
+    'beh.no-tool-echo',
+    'beh.surgical-edits',
+    'beh.bounded-commands',
+];
+const ORDERED_ATOMS = MODE_ORDER.map((id) => {
+    const atom = getAtom(id);
+    if (atom === undefined) {
+        throw new Error(`unknown atom id in mode order: ${id}`);
+    }
+    return atom;
+});
+export function atomsForMode(mode, agent) {
+    return ORDERED_ATOMS.filter((atom) => atom.rejected === undefined &&
+        atom.modes.includes(mode) &&
+        (atom.agents === undefined ||
+            (agent !== undefined && atom.agents.includes(agent))));
+}
+export const MODE_DESCRIPTIONS = {
+    optimized: 'Concise answer-first responses with disciplined context use',
+    slim: 'Code-first responses under a hard explanation budget',
+};

package/dist/packs/render.d.ts

@@ -0,0 +1,24 @@
+import type { AgentName, Atom, PackMode, RenderedArtifact } from './types.ts';
+export declare const MARKER_BEGIN_PREFIX = "<!-- compressor:begin";
+export declare const MARKER_END = "<!-- compressor:end -->";
+/**
+ * Full grammar for a begin-marker LINE (test against the trimmed line).
+ * Prefix-only matching is unsafe: user prose that merely starts with the
+ * prefix must never be mistaken for a section boundary.
+ */
+export declare const MARKER_BEGIN_LINE_RE: RegExp;
+export declare function markerBegin(mode: PackMode): string;
+export declare function atomManifest(atomIds: string[]): string;
+export declare function parseAtomManifest(text: string): {
+    mode: PackMode;
+    atomIds: string[];
+} | null;
+/**
+ * Output style over an explicit atom list (benchmark ablation variants).
+ * styleName is validated only: Claude Code resolves styles by file name
+ * (`<styleName>.md`), and a `name:` frontmatter field is deliberately omitted.
+ */
+export declare function renderOutputStyleFromAtoms(atoms: Atom[], styleName: string, description: string): RenderedArtifact;
+export declare function renderOutputStyle(mode: PackMode): RenderedArtifact;
+export declare function renderMarkedSection(mode: PackMode, agent: AgentName): RenderedArtifact;
+export declare function renderCursorRules(mode: PackMode): RenderedArtifact;

package/dist/packs/render.js

@@ -0,0 +1,115 @@
+import { atomsForMode, MODE_DESCRIPTIONS } from "./modes.js";
+export const MARKER_BEGIN_PREFIX = '<!-- compressor:begin';
+export const MARKER_END = '<!-- compressor:end -->';
+/**
+ * Full grammar for a begin-marker LINE (test against the trimmed line).
+ * Prefix-only matching is unsafe: user prose that merely starts with the
+ * prefix must never be mistaken for a section boundary.
+ */
+export const MARKER_BEGIN_LINE_RE = /^<!-- compressor:begin mode=\S+ v=\d+ -->$/;
+export function markerBegin(mode) {
+    return `${MARKER_BEGIN_PREFIX} mode=${mode} v=1 -->`;
+}
+export function atomManifest(atomIds) {
+    return `<!-- atoms: ${atomIds.join(',')} -->`;
+}
+const BEGIN_RE = /<!-- compressor:begin mode=(\S+) v=\d+ -->/;
+const MANIFEST_RE = /<!-- atoms: ([^>]*) -->/;
+const DESCRIPTION_RE = /^description: (.+)$/m;
+function isPackMode(value) {
+    return value === 'optimized' || value === 'slim';
+}
+function parseMode(text) {
+    const fromMarker = BEGIN_RE.exec(text)?.[1];
+    if (fromMarker !== undefined && isPackMode(fromMarker)) {
+        return fromMarker;
+    }
+    const description = DESCRIPTION_RE.exec(text)?.[1];
+    if (description !== undefined) {
+        const modes = ['optimized', 'slim'];
+        return modes.find((m) => MODE_DESCRIPTIONS[m] === description) ?? null;
+    }
+    return null;
+}
+export function parseAtomManifest(text) {
+    const idsRaw = MANIFEST_RE.exec(text)?.[1];
+    if (idsRaw === undefined) {
+        return null;
+    }
+    const mode = parseMode(text);
+    if (mode === null) {
+        return null;
+    }
+    const atomIds = idsRaw
+        .split(',')
+        .map((id) => id.trim())
+        .filter((id) => id.length > 0);
+    return { mode, atomIds };
+}
+function bullet(atom) {
+    return `- ${atom.text}`;
+}
+/** Atoms slim pulls out into a leading '## Code-first responses' section. */
+const CODE_FIRST_IDS = new Set([
+    'out.explanation-budget',
+    'out.code-only-default',
+]);
+/**
+ * Output style over an explicit atom list (benchmark ablation variants).
+ * styleName is validated only: Claude Code resolves styles by file name
+ * (`<styleName>.md`), and a `name:` frontmatter field is deliberately omitted.
+ */
+export function renderOutputStyleFromAtoms(atoms, styleName, description) {
+    if (styleName === '' || /[/\\]/.test(styleName)) {
+        throw new Error(`invalid output-style name ${JSON.stringify(styleName)} — becomes the file name <styleName>.md`);
+    }
+    const codeFirst = atoms.filter((a) => CODE_FIRST_IDS.has(a.id));
+    const output = atoms.filter((a) => a.category === 'output' && !CODE_FIRST_IDS.has(a.id));
+    const behavior = atoms.filter((a) => a.category === 'behavior');
+    const atomIds = [...codeFirst, ...output, ...behavior].map((a) => a.id);
+    const lines = [
+        '---',
+        `description: ${description}`,
+        'keep-coding-instructions: true',
+        '---',
+        '',
+        atomManifest(atomIds),
+        '',
+    ];
+    if (codeFirst.length > 0) {
+        lines.push('## Code-first responses', ...codeFirst.map(bullet), '');
+    }
+    lines.push('## Output discipline', ...output.map(bullet), '');
+    lines.push('## Context discipline', ...behavior.map(bullet));
+    return { body: `${lines.join('\n')}\n`, atomIds };
+}
+export function renderOutputStyle(mode) {
+    return renderOutputStyleFromAtoms(atomsForMode(mode, 'claude-code'), `compressor-${mode}`, MODE_DESCRIPTIONS[mode]);
+}
+export function renderMarkedSection(mode, agent) {
+    const atoms = atomsForMode(mode, agent);
+    const atomIds = atoms.map((a) => a.id);
+    const lines = [
+        markerBegin(mode),
+        atomManifest(atomIds),
+        '## Response & context discipline (compressor)',
+        ...atoms.map(bullet),
+        MARKER_END,
+    ];
+    return { body: lines.join('\n'), atomIds };
+}
+export function renderCursorRules(mode) {
+    const atoms = atomsForMode(mode, 'cursor');
+    const atomIds = atoms.map((a) => a.id);
+    const lines = [
+        '---',
+        `description: ${MODE_DESCRIPTIONS[mode]}`,
+        'alwaysApply: true',
+        '---',
+        '',
+        atomManifest(atomIds),
+        '',
+        ...atoms.map(bullet),
+    ];
+    return { body: `${lines.join('\n')}\n`, atomIds };
+}

package/dist/packs/types.d.ts

@@ -0,0 +1,32 @@
+/** Modes that render instructions. 'full' renders nothing — it is the absence of artifacts. */
+export type PackMode = 'optimized' | 'slim';
+export type AtomCategory = 'output' | 'behavior';
+export type AgentName = 'claude-code' | 'copilot' | 'cursor' | 'agents-md';
+/**
+ * One independently ablatable instruction. Rendered artifacts embed the atom
+ * IDs as a manifest comment so `status` and the benchmark can read what is
+ * installed.
+ */
+export interface Atom {
+    /** namespaced id, e.g. 'out.no-preamble', 'beh.targeted-reads' */
+    id: string;
+    category: AtomCategory;
+    /** markdown bullet line(s), no trailing newline, no timestamps (cache-stable) */
+    text: string;
+    modes: PackMode[];
+    /** undefined = applies to all agents */
+    agents?: AgentName[];
+    /**
+     * Rejected atoms are never rendered; they exist so nobody re-adds them and
+     * so the benchmark can demonstrate the rejection with data (--ablate-add).
+     */
+    rejected?: {
+        reason: string;
+    };
+}
+export interface RenderedArtifact {
+    /** complete file body or marked section, byte-deterministic */
+    body: string;
+    /** atoms included, in render order */
+    atomIds: string[];
+}

package/dist/packs/types.js

@@ -0,0 +1 @@
+export {};

package/dist/paths.d.ts

@@ -0,0 +1,29 @@
+import type { PackMode } from './packs/types.ts';
+export declare function packageRoot(): string;
+/**
+ * Hook command for ownership matching in status/uninstall — must work even
+ * when the bundle is missing (e.g. uninstalling a broken install).
+ */
+export declare function describeHookCommand(mode: PackMode, root?: string): string;
+/**
+ * Command line installed for the PostToolUse hook. Refuses to install a
+ * command that would fail on every tool call (fail-open hook = silent no-op).
+ */
+export declare function resolveHookCommand(mode: PackMode, root?: string): string;
+/** Copilot hook command for display/matching — works without the bundle. */
+export declare function describeCopilotHookCommand(mode: PackMode, root?: string): string;
+/**
+ * Command line installed for the Copilot postToolUse hook. Like
+ * resolveHookCommand, refuses to install a command that would fail on every
+ * tool call (Copilot postToolUse is fail-open: a dead command = silent no-op).
+ */
+export declare function resolveCopilotHookCommand(mode: PackMode, root?: string): string;
+/**
+ * Copilot hook command derived from the Claude Code hook command carried in
+ * AdapterContext (the only resolved-path carrier adapters receive; the
+ * adapters/types.ts contract is frozen). Both commands are generated in this
+ * module from the same root, so swapping the sibling bundle name and --mode
+ * flag reproduces copilotHookCommandFor exactly. Mode omitted → base form
+ * for ownership matching (mode-agnostic, like claude-code's predicate).
+ */
+export declare function copilotHookCommandFrom(hookCommand: string, mode?: PackMode): string;