context-brake 1.0.0 → 1.1.0

package/dist/src/cli/assistant/summary.js

@@ -1,34 +1,25 @@
-function snapshotLine(facts) {
-    if (facts.snapshotCommand === null)
-        return 'Snapshot command: none (only zone headers are injected)';
-    const resume = facts.resumeCommand === null ? '' : `, resume ${facts.resumeCommand}`;
-    return `Snapshot command: ${facts.snapshotCommand} (trigger ${facts.triggerZone}${resume})`;
+import { PLAIN_STYLE } from '../output/style.js';
+import { renderCard } from '../output/card.js';
+import { harnessRows, optionRows, snapshotRows } from './summary-rows.js';
+const SUMMARY_TITLE = 'Summary of your choices:';
+const COMMAND_LABEL = 'Equivalent command:';
+const COMMAND_INDENT = '  ';
+function commandLines(command, style) {
+    const label = style.paint('muted', COMMAND_LABEL);
+    if (command.length === 1)
+        return [`${label} ${style.paint('accent', command[0] ?? '')}`];
+    return [label, ...command.map((line) => `${COMMAND_INDENT}${style.paint('accent', line)}`)];
 }
-function restartLines(facts) {
-    const state = facts.restartOn ? `on, at most ${facts.restartLimit ?? 'the default number of'} consecutive restarts` : 'off';
-    return [`Restart: ${state}`, ...facts.restartModes.map((fact) => `  ${fact.harness}: ${fact.mode}`)];
-}
-function bridgeLine(facts) {
-    if (facts.statuslineBridge === null)
-        return 'Status line bridge: not applicable (Claude Code not selected)';
-    return `Status line bridge: ${facts.statuslineBridge ? 'yes' : 'no'}`;
-}
-function gitIgnoreLine(facts) {
-    if (facts.gitIgnore === null)
-        return 'Git ignore: not applicable (not a Git repository)';
-    return `Git ignore: ${facts.gitIgnore ? 'yes' : 'no'}`;
-}
-export function renderSummary(facts, command) {
-    const excluded = facts.excluded.length === 0 ? '' : ` (turned off: ${facts.excluded.join(', ')})`;
-    const equivalent = command.length === 1 ? [`Equivalent command: ${command[0]}`] : ['Equivalent command:', ...command.map((line) => `  ${line}`)];
+export function renderSummary(facts, command, style = PLAIN_STYLE) {
     return [
-        'Summary of your choices:',
-        `  Harnesses: ${facts.selected.length === 0 ? 'none' : facts.selected.join(', ')}${excluded}`,
-        `  ${snapshotLine(facts)}`,
-        ...restartLines(facts).map((line) => `  ${line}`),
-        `  ${bridgeLine(facts)}`,
-        `  Debug mode: ${facts.debug ? 'on' : 'off'}`,
-        `  ${gitIgnoreLine(facts)}`,
-        ...equivalent,
+        style.paint('title', SUMMARY_TITLE),
+        '',
+        ...renderCard('Harnesses', harnessRows(facts), style),
+        '',
+        ...renderCard('Snapshot', snapshotRows(facts), style),
+        '',
+        ...renderCard('Options', optionRows(facts), style),
+        '',
+        ...commandLines(command, style),
     ];
 }

package/dist/src/cli/assistant/types.d.ts

@@ -1,13 +1,25 @@
 import type { HarnessAdapter } from '../../core/contracts/adapter.js';
 import type { ContextBrakeConfig } from '../../core/contracts/configuration.js';
 import type { HarnessDetection, HarnessId } from '../../core/contracts/harness.js';
+import type { SkillCatalogReader } from '../../core/contracts/skill-catalog.js';
+import type { SkillInvocationResolver } from '../../core/contracts/skill-invocation.js';
+import type { ContextSource } from '../../infrastructure/harnesses/claude-code/context-source.js';
 import type { HarnessRestartMode } from '../../core/services/restart-install-extras.js';
 export type AssistantContext = {
     readonly config: ContextBrakeConfig | null;
     readonly detections: readonly HarnessDetection[];
     readonly adapters: readonly HarnessAdapter[];
     readonly hasStatuslineOptOut: boolean;
+    readonly contextSource: ContextSource;
     readonly insideGit: boolean;
+    readonly invocations: SkillInvocationResolver;
+    readonly projectRoot: string;
+    readonly catalog: SkillCatalogReader;
+};
+export type HarnessInvocationFact = {
+    readonly harness: HarnessId;
+    readonly command: string;
+    readonly resumeCommand: string | null;
 };
 export type HarnessRestartFact = {
     readonly harness: HarnessId;
@@ -18,11 +30,14 @@ export type AssistantFacts = {
     readonly excluded: readonly HarnessId[];
     readonly snapshotCommand: string | null;
     readonly triggerZone: string;
+    readonly triggerPercentage: number | null;
     readonly resumeCommand: string | null;
+    readonly invocations: readonly HarnessInvocationFact[];
     readonly restartOn: boolean;
     readonly restartLimit: number | null;
     readonly restartModes: readonly HarnessRestartFact[];
     readonly statuslineBridge: boolean | null;
+    readonly contextSource: ContextSource | null;
     readonly debug: boolean;
     readonly gitIgnore: boolean | null;
 };

package/dist/src/cli/commands/doctor.js

@@ -4,6 +4,7 @@ import { NodeManifestStore } from '../../infrastructure/storage/manifest-store.j
 import { NodeOverheadMeasurer } from '../../infrastructure/diagnostics/overhead-measurer.js';
 import { readPackageVersion } from '../../infrastructure/storage/package-metadata.js';
 import { getAllAdapters } from '../../infrastructure/harnesses/registry.js';
+import { resolveSkillInvocation } from '../../infrastructure/harnesses/skill-invocations.js';
 import { systemClock } from '../../infrastructure/runtime/runtime-composition.js';
 import { NodeRuntimeStateReader } from '../../infrastructure/runtime/runtime-state-reader.js';
 import { diagnoseProject } from '../../core/services/doctor-service.js';
@@ -42,7 +43,7 @@ export async function runDoctor(args, env) {
         projectRoot: env.projectRoot, config, configError, adapters, context: ctx, sources,
         ...(args.harness.length > 0 ? { explicitHarnesses: args.harness } : {}), measurer,
         manifest, allSnapshots, packageVersion, contextWindow: await readClaudeContextWindow(env.projectRoot),
-        runtimeState: await new NodeRuntimeStateReader(env.projectRoot, systemClock).read(), now: systemClock.now(),
+        runtimeState: await new NodeRuntimeStateReader(env.projectRoot, systemClock).read(), now: systemClock.now(), invocations: resolveSkillInvocation,
     });
     const installed = adapters.filter((adapter) => !reportsRestart(diagnosed.findings, adapter.id) && diagnosed.integrations.some((integration) => integration.harness === adapter.id && integration.state === 'installed'));
     const report = { ...diagnosed, findings: [...diagnosed.findings, ...await doctorRestartFindings(env.projectRoot, config, installed)] };

package/dist/src/cli/commands/remove.js

@@ -9,7 +9,7 @@ import { getAllAdapters } from '../../infrastructure/harnesses/registry.js';
 import { planRemoval } from '../../core/services/removal-service.js';
 import { buildInstallReport } from '../../core/services/report-service.js';
 import { renderJsonOutput } from '../output/json.js';
-import { renderInstallText } from '../output/text.js';
+import { renderInstallText } from '../output/install-text.js';
 import { collectProjectSnapshots } from '../snapshot-helper.js';
 import { buildHarnessContext } from '../detection-collector.js';
 import { authorizeWrite } from '../confirmation.js';

package/dist/src/cli/init-arguments.js

@@ -1,12 +1,12 @@
 import { parseArgs } from 'node:util';
 import { hasRestartMode } from '../core/services/restart-install-extras.js';
 import { CliArgumentError, validateHarnessIds, validateInclusionExclusion } from './argument-validator.js';
-import { assertGitIgnoreCompatible, assertInteractiveCompatible, assertMaxRestartsCompatible, parseMaxRestarts } from './init-option-rules.js';
+import { assertGitIgnoreCompatible, assertInteractiveCompatible, assertMaxRestartsCompatible, assertTriggerCompatible, parseMaxRestarts, parseTriggerPercentage } from './init-option-rules.js';
 const INIT_OPTIONS = {
     'dry-run': { type: 'boolean', default: false }, yes: { type: 'boolean', short: 'y', default: false },
     'json': { type: 'boolean', default: false }, harness: { type: 'string', multiple: true, default: [] },
     'exclude-harness': { type: 'string', multiple: true, default: [] },
-    'snapshot-command': { type: 'string' }, 'snapshot-trigger': { type: 'string' }, 'resume-command': { type: 'string' },
+    'snapshot-command': { type: 'string' }, 'snapshot-trigger': { type: 'string' }, 'snapshot-trigger-percentage': { type: 'string' }, 'resume-command': { type: 'string' },
     'no-snapshot-command': { type: 'boolean', default: false },
     debug: { type: 'boolean', default: false }, 'no-debug': { type: 'boolean', default: false },
     'statusline-bridge': { type: 'boolean', default: false }, 'no-statusline-bridge': { type: 'boolean', default: false },
@@ -21,6 +21,7 @@ export function parseInit(args) {
     validateInclusionExclusion(harness, excludeHarness);
     const maxRestarts = parseMaxRestarts(values['max-restarts']);
     assertMaxRestartsCompatible(maxRestarts, values['no-auto-restart']);
+    assertTriggerCompatible({ zone: values['snapshot-trigger'], percentage: parseTriggerPercentage(values['snapshot-trigger-percentage']) });
     assertGitIgnoreCompatible({ gitignore: values.gitignore, noGitignore: values['no-gitignore'] });
     assertInteractiveCompatible({ interactive: values.interactive, yes: values.yes, json: values.json });
     return {
@@ -33,12 +34,12 @@ export function parseInit(args) {
 }
 export function hasConfigurationFlag(args) {
     const snapshot = args.snapshot;
-    const hasSnapshotFlag = snapshot !== undefined && (snapshot.clearCommand || [snapshot.command, snapshot.triggerZone, snapshot.resumeCommand].some((value) => value !== undefined));
+    const hasSnapshotFlag = snapshot !== undefined && (snapshot.clearCommand || [snapshot.command, snapshot.triggerZone, snapshot.triggerPercentage, snapshot.resumeCommand].some((value) => value !== undefined));
     const flags = [args.debug, args.noDebug, args.autoRestart, args.noAutoRestart, args.gitignore, args.noGitignore, hasSnapshotFlag];
     return args.harness.length > 0 || args.excludeHarness.length > 0 || args.statuslineBridge !== undefined || args.maxRestarts !== undefined || flags.some(Boolean);
 }
 function snapshotFlags(values) {
-    return { command: values['snapshot-command'], triggerZone: values['snapshot-trigger'], resumeCommand: values['resume-command'], clearCommand: values['no-snapshot-command'] };
+    return { command: values['snapshot-command'], triggerZone: values['snapshot-trigger'], triggerPercentage: parseTriggerPercentage(values['snapshot-trigger-percentage']), resumeCommand: values['resume-command'], clearCommand: values['no-snapshot-command'] };
 }
 const STATUSLINE_TARGET_ERROR = '--statusline-bridge and --no-statusline-bridge require claude-code among the target harnesses.';
 function statuslineBridgeRequest(values, targets) {

package/dist/src/cli/init-flow.js

@@ -10,7 +10,7 @@ import { NodeProcessRunner } from '../infrastructure/process/node-process-runner
 import { planInstallation } from '../core/services/installation-service.js';
 import { buildInstallReport } from '../core/services/report-service.js';
 import { renderJsonOutput } from './output/json.js';
-import { renderInstallText } from './output/text.js';
+import { renderInstallText } from './output/install-text.js';
 import { collectProjectSnapshots, collectRestartLogSnapshots } from './snapshot-helper.js';
 import { buildHarnessContext, collectHarnessSources } from './detection-collector.js';
 import { authorizeWrite } from './confirmation.js';

package/dist/src/cli/init-option-rules.d.ts

@@ -1,4 +1,9 @@
 export declare function parseMaxRestarts(value: string | undefined): number | undefined;
+export declare function parseTriggerPercentage(value: string | undefined): number | undefined;
+export declare function assertTriggerCompatible(flags: {
+    readonly zone: string | undefined;
+    readonly percentage: number | undefined;
+}): void;
 export declare function assertMaxRestartsCompatible(maxRestarts: number | undefined, noAutoRestart: boolean): void;
 export declare function assertGitIgnoreCompatible(flags: {
     readonly gitignore: boolean;

package/dist/src/cli/init-option-rules.js

@@ -2,6 +2,10 @@ import { MAX_CONSECUTIVE_RESTARTS, MIN_CONSECUTIVE_RESTARTS } from '../core/cont
 import { CliArgumentError } from './argument-validator.js';
 const MAX_RESTARTS_RULE = `--max-restarts must be an integer from ${MIN_CONSECUTIVE_RESTARTS} to ${MAX_CONSECUTIVE_RESTARTS}.`;
 const MAX_RESTARTS_CONFLICT = '--max-restarts cannot be combined with --no-auto-restart.';
+const MIN_TRIGGER_PERCENTAGE = 1;
+const MAX_TRIGGER_PERCENTAGE = 100;
+const TRIGGER_PERCENTAGE_RULE = `--snapshot-trigger-percentage must be an integer from ${MIN_TRIGGER_PERCENTAGE} to ${MAX_TRIGGER_PERCENTAGE}.`;
+const TRIGGER_CONFLICT = '--snapshot-trigger cannot be combined with --snapshot-trigger-percentage.';
 const INTEGER_PATTERN = /^\d+$/;
 export function parseMaxRestarts(value) {
     if (value === undefined)
@@ -11,6 +15,18 @@ export function parseMaxRestarts(value) {
         throw new CliArgumentError(MAX_RESTARTS_RULE);
     return parsed;
 }
+export function parseTriggerPercentage(value) {
+    if (value === undefined)
+        return undefined;
+    const parsed = INTEGER_PATTERN.test(value) ? Number(value) : Number.NaN;
+    if (!(parsed >= MIN_TRIGGER_PERCENTAGE && parsed <= MAX_TRIGGER_PERCENTAGE))
+        throw new CliArgumentError(TRIGGER_PERCENTAGE_RULE);
+    return parsed;
+}
+export function assertTriggerCompatible(flags) {
+    if (flags.zone !== undefined && flags.percentage !== undefined)
+        throw new CliArgumentError(TRIGGER_CONFLICT);
+}
 export function assertMaxRestartsCompatible(maxRestarts, noAutoRestart) {
     if (maxRestarts !== undefined && noAutoRestart)
         throw new CliArgumentError(MAX_RESTARTS_CONFLICT);

package/dist/src/cli/output/card.d.ts

@@ -0,0 +1,8 @@
+import type { Style, Tone } from './style.js';
+export type CardRow = {
+    readonly label: string;
+    readonly value: string;
+    readonly tone?: Tone;
+    readonly notes?: readonly string[];
+};
+export declare function renderCard(title: string, rows: readonly CardRow[], style: Style): string[];

package/dist/src/cli/output/card.js

@@ -0,0 +1,30 @@
+const COLUMN_GAP = '  ';
+const NOTE_WIDTH = 76;
+function wrapWords(text, width) {
+    const lines = [];
+    for (const word of text.split(' ')) {
+        const last = lines.at(-1);
+        if (last !== undefined && last.length + 1 + word.length <= width)
+            lines[lines.length - 1] = `${last} ${word}`;
+        else
+            lines.push(word);
+    }
+    return lines;
+}
+function railed(style, content) {
+    return `${style.paint('muted', style.glyphs.rail)}${COLUMN_GAP}${content}`;
+}
+function renderRow(row, labelWidth, style) {
+    const label = style.paint('muted', row.label.padEnd(labelWidth));
+    const notes = (row.notes ?? []).flatMap((note) => wrapWords(note, NOTE_WIDTH));
+    const noteLines = notes.map((note) => railed(style, `${' '.repeat(labelWidth)}${COLUMN_GAP}${style.paint('muted', note)}`));
+    return [railed(style, `${label}${COLUMN_GAP}${style.paint(row.tone ?? 'plain', row.value)}`), ...noteLines];
+}
+export function renderCard(title, rows, style) {
+    const labelWidth = Math.max(...rows.map((row) => row.label.length));
+    return [
+        `${style.paint('muted', style.glyphs.top)} ${style.paint('title', title)}`,
+        ...rows.flatMap((row) => renderRow(row, labelWidth, style)),
+        style.paint('muted', style.glyphs.bottom),
+    ];
+}

package/dist/src/cli/output/doctor-mode-text.js

@@ -1,10 +1,16 @@
+import { describeTrigger } from '../../core/services/trigger-text.js';
+function renderInvocationLine(invocation) {
+    const resume = invocation.resumeCommand === null ? '' : `, resume: ${invocation.resumeCommand}`;
+    return `    - ${invocation.harness}: ${invocation.command}${resume}\n`;
+}
 function renderSnapshotLine(snapshot) {
     if (snapshot === undefined)
         return '';
     if (snapshot.command === null)
-        return `  - snapshot: not configured (zone headers only, trigger: ${snapshot.triggerZone})\n`;
+        return `  - snapshot: not configured (zone headers only, trigger: ${describeTrigger(snapshot)})\n`;
     const resume = snapshot.resumeCommand === null ? '' : `, resume: ${snapshot.resumeCommand}`;
-    return `  - snapshot: ${snapshot.command} at ${snapshot.triggerZone}${resume}\n`;
+    const forms = (snapshot.invocations ?? []).map(renderInvocationLine).join('');
+    return `  - snapshot: ${snapshot.command} at ${describeTrigger(snapshot)}${resume}\n${forms}`;
 }
 export function renderModeLines(report) {
     const debug = report.debugMode === true ? '  - debug mode: on\n' : '';

package/dist/src/cli/output/install-rows.d.ts

@@ -0,0 +1,6 @@
+import type { InstallReport } from '../../core/contracts/diagnostics.js';
+import type { CardRow } from './card.js';
+export declare function harnessRows(report: InstallReport): CardRow[];
+export declare function changeRows(report: InstallReport): CardRow[];
+export declare function conflictRows(report: InstallReport): CardRow[];
+export declare function findingRows(report: InstallReport): CardRow[];

package/dist/src/cli/output/install-rows.js

@@ -0,0 +1,31 @@
+const CHANGE_TONES = { create: 'good', update: 'accent', delete: 'plain' };
+const SEVERITY_LABELS = {
+    ok: { label: '[OK]', tone: 'good' },
+    warning: { label: '[WARN]', tone: 'warn' },
+    error: { label: '[ERROR]', tone: 'bad' },
+};
+export function harnessRows(report) {
+    const planned = report.plan.harnesses.map((h) => ({
+        label: h.harness, value: `${h.supportLevel} support (${h.outcome})`, tone: h.outcome === 'conflict' ? 'bad' : 'good',
+        notes: h.limitations.map((limitation) => `${limitation.capability}: ${limitation.impact}`),
+    }));
+    const excluded = report.detections.filter((detection) => detection.state === 'excluded');
+    return [...planned, ...excluded.map((detection) => ({ label: detection.harness, value: 'excluded by configuration', tone: 'muted' }))];
+}
+export function changeRows(report) {
+    const showSummary = report.command === 'init';
+    return report.plan.changes.map((change) => ({
+        label: change.kind, value: `${change.path} (${change.owner})`, tone: CHANGE_TONES[change.kind],
+        notes: showSummary && (change.owner === 'config' || change.owner === 'gitignore') ? [change.preview.summary] : [],
+    }));
+}
+export function conflictRows(report) {
+    return report.plan.conflicts.map((conflict) => ({ label: SEVERITY_LABELS.error.label, value: `${conflict.path}: ${conflict.detail}`, tone: 'bad' }));
+}
+export function findingRows(report) {
+    return report.findings.map((finding) => {
+        const { label, tone } = SEVERITY_LABELS[finding.severity];
+        const notes = [finding.impact ? `Impact: ${finding.impact}` : '', finding.remediation ? `Remediation: ${finding.remediation}` : ''];
+        return { label, value: `${finding.code}: ${finding.message}`, tone, notes: notes.filter((note) => note !== '') };
+    });
+}

package/dist/src/cli/output/install-text.d.ts

@@ -0,0 +1,4 @@
+import type { InstallReport } from '../../core/contracts/diagnostics.js';
+import { type Style } from './style.js';
+export declare function formatInstallReport(report: InstallReport, style: Style): string;
+export declare function renderInstallText(report: InstallReport, style?: Style): void;

package/dist/src/cli/output/install-text.js

@@ -0,0 +1,26 @@
+import { renderCard } from './card.js';
+import { changeRows, conflictRows, findingRows, harnessRows } from './install-rows.js';
+import { detectStyle } from './style.js';
+const STATUS_WORDS = {
+    success: { label: '[OK]', tone: 'good' },
+    warnings: { label: '[WARN]', tone: 'warn' },
+    errors: { label: '[ERROR]', tone: 'bad' },
+};
+function headerLine(report, style) {
+    const { label, tone } = STATUS_WORDS[report.status];
+    return `${style.paint(tone, label)} ${style.paint('title', `ContextBrake ${report.command} (${report.mode})`)}`;
+}
+function cardSections(report, style) {
+    const sections = [
+        ['Harnesses', harnessRows(report)], ['Planned changes', changeRows(report)], ['Conflicts', conflictRows(report)], ['Findings', findingRows(report)],
+    ];
+    return sections.filter(([, rows]) => rows.length > 0).flatMap(([title, rows]) => ['', ...renderCard(title, rows, style)]);
+}
+export function formatInstallReport(report, style) {
+    return `${[headerLine(report, style), ...cardSections(report, style)].join('\n')}\n`;
+}
+export function renderInstallText(report, style) {
+    const stream = report.status === 'errors' ? process.stderr : process.stdout;
+    const chosen = style ?? detectStyle({ env: process.env, platform: process.platform, isTty: stream.isTTY === true });
+    stream.write(formatInstallReport(report, chosen));
+}

package/dist/src/cli/output/style.d.ts

@@ -0,0 +1,22 @@
+export type Tone = 'plain' | 'title' | 'accent' | 'good' | 'muted' | 'warn' | 'bad';
+export type Glyphs = {
+    readonly top: string;
+    readonly rail: string;
+    readonly bottom: string;
+};
+export type Style = {
+    readonly paint: (tone: Tone, text: string) => string;
+    readonly glyphs: Glyphs;
+};
+export type StyleOptions = {
+    readonly color: boolean;
+    readonly unicode: boolean;
+};
+export type StyleEnvironment = {
+    readonly env: NodeJS.ProcessEnv;
+    readonly platform: NodeJS.Platform;
+    readonly isTty: boolean;
+};
+export declare function createStyle(options: StyleOptions): Style;
+export declare const PLAIN_STYLE: Style;
+export declare function detectStyle(environment: StyleEnvironment): Style;

package/dist/src/cli/output/style.js

@@ -0,0 +1,27 @@
+const ESCAPE = String.fromCharCode(27);
+const RESET = `${ESCAPE}[0m`;
+const DUMB_TERMINAL = 'dumb';
+const LINUX_CONSOLE = 'linux';
+const UNICODE_GLYPHS = { top: '┌─', rail: '│', bottom: '└─' };
+const ASCII_GLYPHS = { top: '+-', rail: '|', bottom: '+-' };
+const SGR_CODES = { plain: '', title: '1;36', accent: '36', good: '32', muted: '2', warn: '33', bad: '31' };
+const UNICODE_WINDOWS_SIGNALS = ['WT_SESSION', 'WT_PROFILE_ID', 'TERM_PROGRAM', 'COLORTERM', 'TERM', 'ConEmuTask', 'TERMINUS_SUBLIME'];
+function colorize(tone, text) {
+    return SGR_CODES[tone] === '' ? text : `${ESCAPE}[${SGR_CODES[tone]}m${text}${RESET}`;
+}
+export function createStyle(options) {
+    const glyphs = options.unicode ? UNICODE_GLYPHS : ASCII_GLYPHS;
+    return { paint: (tone, text) => (options.color ? colorize(tone, text) : text), glyphs };
+}
+export const PLAIN_STYLE = createStyle({ color: false, unicode: true });
+function isUnicodeTerminal({ env, platform }) {
+    if (platform !== 'win32')
+        return env.TERM !== LINUX_CONSOLE;
+    return UNICODE_WINDOWS_SIGNALS.some((name) => (env[name] ?? '') !== '');
+}
+function isColorTerminal({ env, isTty }) {
+    return isTty && (env.NO_COLOR ?? '') === '' && env.TERM !== DUMB_TERMINAL;
+}
+export function detectStyle(environment) {
+    return createStyle({ color: isColorTerminal(environment), unicode: isUnicodeTerminal(environment) });
+}

package/dist/src/cli/output/text.d.ts

@@ -1,5 +1,4 @@
-import type { CliErrorDocument, DiagnosticFinding, DoctorReport, InstallReport } from '../../core/contracts/diagnostics.js';
+import type { CliErrorDocument, DiagnosticFinding, DoctorReport } from '../../core/contracts/diagnostics.js';
 export declare function renderFinding(f: DiagnosticFinding): string;
-export declare function renderInstallText(report: InstallReport): void;
 export declare function renderDoctorText(report: DoctorReport): void;
 export declare function renderCliErrorText(doc: CliErrorDocument): void;

package/dist/src/cli/output/text.js

@@ -10,33 +10,6 @@ export function renderFinding(f) {
         lines.push(`    Remediation: ${f.remediation}`);
     return lines.join('\n');
 }
-export function renderInstallText(report) {
-    const stream = report.status === 'errors' ? process.stderr : process.stdout;
-    const label = report.status === 'errors' ? '[ERROR]' : report.status === 'warnings' ? '[WARN]' : '[OK]';
-    stream.write(`${label} ContextBrake ${report.command} (${report.mode})\n`);
-    for (const h of report.plan.harnesses) {
-        stream.write(`  - ${h.harness}: ${h.supportLevel} support (${h.outcome})\n`);
-        for (const lim of h.limitations)
-            stream.write(`    * ${lim.capability}: ${lim.impact}\n`);
-    }
-    for (const line of excludedDetectionLines(report.detections))
-        stream.write(line);
-    if (report.plan.changes.length > 0) {
-        stream.write('  Planned changes:\n');
-        for (const c of report.plan.changes) {
-            stream.write(`    [${c.kind}] ${c.path} (${c.owner})\n`);
-            if (report.command === 'init' && (c.owner === 'config' || c.owner === 'gitignore'))
-                stream.write(`      ${c.preview.summary}\n`);
-        }
-    }
-    if (report.plan.conflicts.length > 0) {
-        stream.write('  Conflicts:\n');
-        for (const c of report.plan.conflicts)
-            stream.write(`    [ERROR] ${c.path}: ${c.detail}\n`);
-    }
-    for (const f of report.findings)
-        stream.write(`${renderFinding(f)}\n`);
-}
 export function renderDoctorText(report) {
     const stream = report.status === 'errors' ? process.stderr : process.stdout;
     const label = report.status === 'errors' ? '[ERROR]' : report.status === 'warnings' ? '[WARN]' : '[OK]';
@@ -57,7 +30,7 @@ export function renderDoctorText(report) {
         stream.write(line);
     const window = report.contextWindow;
     if (window)
-        stream.write(`  - context window: ${window.source} (bridge: ${window.bridge}, last window: ${window.lastWindowTokens ?? 'unknown'})\n`);
+        stream.write(`  - context window: ${window.source} (mod: ${window.mod}, bridge: ${window.bridge}, last window: ${window.lastWindowTokens ?? 'unknown'})\n`);
     stream.write(renderModeLines(report));
     stream.write(renderActiveSessionsText(report.activeSessions, new Date()));
     for (const f of report.findings)

package/dist/src/core/contracts/adapter.d.ts

@@ -1,7 +1,7 @@
 import type { PlannedChange, PlanConflict } from './changes.js';
 import type { DiagnosticFinding } from './diagnostics.js';
 import type { CapabilityProfile, DetectionEvidence, HarnessId, VersionProbe } from './harness.js';
-import type { InstallationManifest, ManagedAsset, ManagedEntry } from './manifest.js';
+import type { ConfigOrigin, InstallationManifest, ManagedAsset, ManagedEntry } from './manifest.js';
 import type { ProcessRunner } from './processes.js';
 export type StatuslineBridgeRequest = 'install' | 'remove' | 'default';
 export type HarnessContext = {
@@ -19,6 +19,7 @@ export type AdapterPlan = {
     readonly entries: readonly ManagedEntry[];
     readonly assets?: readonly ManagedAsset[];
     readonly assetPaths?: readonly string[];
+    readonly configOrigins?: readonly ConfigOrigin[];
     readonly findings?: readonly DiagnosticFinding[];
 };
 export type BenchmarkFixture = {

package/dist/src/core/contracts/configuration.d.ts

@@ -1,11 +1,11 @@
 import { z } from 'zod/mini';
 export declare const INJECTION_MODES: readonly ["threshold_only", "always"];
-export declare const MAX_AGENT_COMMAND_LENGTH = 200;
 export declare const snapshotSchema: z.ZodMiniObject<{
     triggerZone: z.ZodMiniDefault<z.ZodMiniEnum<{
         YELLOW: "YELLOW";
         RED: "RED";
     }>>;
+    triggerPercentage: z.ZodMiniOptional<z.ZodMiniInt>;
     command: z.ZodMiniOptional<z.ZodMiniString<string>>;
     resumeCommand: z.ZodMiniOptional<z.ZodMiniString<string>>;
 }, z.core.$strict>;
@@ -65,6 +65,7 @@ export declare const configurationSchema: z.ZodMiniObject<{
             YELLOW: "YELLOW";
             RED: "RED";
         }>>;
+        triggerPercentage: z.ZodMiniOptional<z.ZodMiniInt>;
         command: z.ZodMiniOptional<z.ZodMiniString<string>>;
         resumeCommand: z.ZodMiniOptional<z.ZodMiniString<string>>;
     }, z.core.$strict>>;

package/dist/src/core/contracts/configuration.js

@@ -1,6 +1,7 @@
 import { z } from 'zod/mini';
 import { autoRestartSchema } from './auto-restart.js';
 import { HARNESS_IDS } from './harness.js';
+import { skillNameSchema } from './skill-name.js';
 import { SNAPSHOT_TRIGGER_ZONES } from './zones.js';
 export const INJECTION_MODES = ['threshold_only', 'always'];
 const DUPLICATE_ENTRIES_RULE = 'must not contain duplicates';
@@ -13,17 +14,8 @@ function uniqueCheck(message) {
     return (ctx) => { if (!isUnique(ctx.value))
         addIssue(ctx, { code: 'custom', path: [], input: ctx.value, message }); };
 }
-export const MAX_AGENT_COMMAND_LENGTH = 200;
-const TRIMMED_RULE = 'must not have leading or trailing whitespace';
 const RESUME_REQUIRES_COMMAND_RULE = 'requires snapshot.command';
-const SINGLE_LINE_RULE = 'must be a single line';
-const agentCommand = z.string().check(z.minLength(1), z.maxLength(MAX_AGENT_COMMAND_LENGTH), (ctx) => {
-    if (ctx.value.trim() !== ctx.value)
-        addIssue(ctx, { code: 'custom', path: [], input: ctx.value, message: TRIMMED_RULE });
-    if (/[\r\n]/.test(ctx.value))
-        addIssue(ctx, { code: 'custom', path: [], input: ctx.value, message: SINGLE_LINE_RULE });
-});
-export const snapshotSchema = z.strictObject({ triggerZone: z._default(z.enum(SNAPSHOT_TRIGGER_ZONES), 'RED'), command: z.optional(agentCommand), resumeCommand: z.optional(agentCommand) }).check((ctx) => {
+export const snapshotSchema = z.strictObject({ triggerZone: z._default(z.enum(SNAPSHOT_TRIGGER_ZONES), 'RED'), triggerPercentage: z.optional(z.int().check(z.minimum(1), z.maximum(100))), command: z.optional(skillNameSchema), resumeCommand: z.optional(skillNameSchema) }).check((ctx) => {
     if (ctx.value.resumeCommand !== undefined && ctx.value.command === undefined)
         addIssue(ctx, { code: 'custom', path: ['resumeCommand'], input: ctx.value.resumeCommand, message: RESUME_REQUIRES_COMMAND_RULE });
 });

package/dist/src/core/contracts/context-reading.d.ts

@@ -0,0 +1,16 @@
+import { z } from 'zod/mini';
+import type { HarnessId } from './harness.js';
+export declare const CONTEXT_READINGS_RELATIVE_DIR = ".context-brake/runtime/context-readings";
+export declare const CONTEXT_READING_MAXIMUM_CHARACTERS = 1024;
+export declare const RUNTIME_IGNORE_RELATIVE_PATH = ".context-brake/runtime/.gitignore";
+export declare const RUNTIME_IGNORE_CONTENT = "*\n";
+export declare const contextReadingSchema: z.ZodMiniObject<{
+    v: z.ZodMiniLiteral<1>;
+    at: z.ZodMiniString<string>;
+    windowTokens: z.ZodMiniNullable<z.ZodMiniInt>;
+    inputTokens: z.ZodMiniNullable<z.ZodMiniInt>;
+    usedPercentage: z.ZodMiniNullable<z.ZodMiniNumber<number>>;
+}, z.core.$strict>;
+export type ContextReading = z.infer<typeof contextReadingSchema>;
+export declare function isReadingSessionId(value: string | undefined): value is string;
+export declare function contextReadingRelativePath(harness: HarnessId, sessionId: string): string;

package/dist/src/core/contracts/context-reading.js

@@ -0,0 +1,20 @@
+import { z } from 'zod/mini';
+export const CONTEXT_READINGS_RELATIVE_DIR = '.context-brake/runtime/context-readings';
+export const CONTEXT_READING_MAXIMUM_CHARACTERS = 1024;
+export const RUNTIME_IGNORE_RELATIVE_PATH = '.context-brake/runtime/.gitignore';
+export const RUNTIME_IGNORE_CONTENT = '*\n';
+const SESSION_ID_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+const PERCENTAGE_MAXIMUM = 100;
+export const contextReadingSchema = z.strictObject({
+    v: z.literal(1),
+    at: z.string().check(z.minLength(1)),
+    windowTokens: z.nullable(z.int().check(z.positive())),
+    inputTokens: z.nullable(z.int().check(z.nonnegative())),
+    usedPercentage: z.nullable(z.number().check(z.gte(0), z.lte(PERCENTAGE_MAXIMUM))),
+});
+export function isReadingSessionId(value) {
+    return value !== undefined && SESSION_ID_PATTERN.test(value);
+}
+export function contextReadingRelativePath(harness, sessionId) {
+    return `${CONTEXT_READINGS_RELATIVE_DIR}/${harness}/${sessionId}.json`;
+}

package/dist/src/core/contracts/context-window-report.d.ts

@@ -1,14 +1,21 @@
 import { z } from 'zod';
 export declare const CONTEXT_WINDOW_BRIDGE_STATES: readonly ["absent", "installed", "inactive"];
-export declare const CONTEXT_WINDOW_SOURCES: readonly ["statusline", "contextWindowCeiling"];
+export declare const CONTEXT_MOD_STATES: readonly ["absent", "installed", "reporting"];
+export declare const CONTEXT_WINDOW_SOURCES: readonly ["mod", "statusline", "contextWindowCeiling"];
 export declare const contextWindowReportSchema: z.ZodObject<{
     bridge: z.ZodEnum<{
         inactive: "inactive";
         installed: "installed";
         absent: "absent";
     }>;
+    mod: z.ZodEnum<{
+        installed: "installed";
+        absent: "absent";
+        reporting: "reporting";
+    }>;
     source: z.ZodEnum<{
         contextWindowCeiling: "contextWindowCeiling";
+        mod: "mod";
         statusline: "statusline";
     }>;
     lastWindowTokens: z.ZodNullable<z.ZodNumber>;

package/dist/src/core/contracts/context-window-report.js

@@ -1,8 +1,10 @@
 import { z } from 'zod';
 export const CONTEXT_WINDOW_BRIDGE_STATES = ['absent', 'installed', 'inactive'];
-export const CONTEXT_WINDOW_SOURCES = ['statusline', 'contextWindowCeiling'];
+export const CONTEXT_MOD_STATES = ['absent', 'installed', 'reporting'];
+export const CONTEXT_WINDOW_SOURCES = ['mod', 'statusline', 'contextWindowCeiling'];
 export const contextWindowReportSchema = z.object({
     bridge: z.enum(CONTEXT_WINDOW_BRIDGE_STATES),
+    mod: z.enum(CONTEXT_MOD_STATES),
     source: z.enum(CONTEXT_WINDOW_SOURCES),
     lastWindowTokens: z.number().int().positive().nullable(),
 }).strict();