context-brake 1.0.0 → 1.1.0

package/dist/assets/runtime/pi-restart.js

@@ -18308,6 +18308,34 @@ async function handleTurnEnd(host, turn) {
   });
 }
 
+// src/core/contracts/skill-name.ts
+var MAX_SKILL_NAME_LENGTH = 64;
+var NAME_SEGMENT = "[a-z0-9]+(?:-[a-z0-9]+)*";
+var NAMESPACE_SEPARATOR = ":";
+var INVOCATION_CHARACTERS = ["/", "$", "@"];
+var MAX_QUALIFIED_LENGTH = MAX_SKILL_NAME_LENGTH * 2 + NAMESPACE_SEPARATOR.length;
+function segmentFits(end) {
+  return `(?=[^${NAMESPACE_SEPARATOR}]{1,${MAX_SKILL_NAME_LENGTH}}${end})`;
+}
+var PREFIX = `(?:${segmentFits(NAMESPACE_SEPARATOR)}${NAME_SEGMENT}${NAMESPACE_SEPARATOR})?`;
+var SKILL_NAME_PATTERN = new RegExp(`^${PREFIX}${segmentFits("$")}${NAME_SEGMENT}$`);
+var SHAPE_RULE = `lowercase letters, digits, and single hyphens, up to ${MAX_SKILL_NAME_LENGTH} characters, optionally prefixed by a plugin name and a colon`;
+function isSkillName(value) {
+  return SKILL_NAME_PATTERN.test(value);
+}
+function skillNameProblem(value) {
+  if (value === "") return "must not be empty";
+  if (isSkillName(value)) return null;
+  const bare = INVOCATION_CHARACTERS.includes(value.charAt(0)) ? value.slice(1) : null;
+  if (bare !== null && isSkillName(bare)) return `"${value}" is not a skill name; use the bare name ${bare}`;
+  return `"${value}" is not a skill name; use ${SHAPE_RULE}`;
+}
+var skillNameSchema = external_exports.string().check((ctx) => {
+  const message = skillNameProblem(ctx.value);
+  if (message !== null) ctx.issues.push({ code: "custom", input: ctx.value, message });
+});
+external_exports.globalRegistry.add(skillNameSchema, { pattern: SKILL_NAME_PATTERN.source, maxLength: MAX_QUALIFIED_LENGTH });
+
 // src/core/contracts/zones.ts
 var ZONES = ["GREEN", "YELLOW", "RED", "CRITICAL"];
 var USAGE_SOURCES = ["measured", "estimated"];
@@ -18331,15 +18359,8 @@ function uniqueCheck(message) {
     if (!isUnique(ctx.value)) addIssue(ctx, { code: "custom", path: [], input: ctx.value, message });
   };
 }
-var MAX_AGENT_COMMAND_LENGTH = 200;
-var TRIMMED_RULE = "must not have leading or trailing whitespace";
 var RESUME_REQUIRES_COMMAND_RULE = "requires snapshot.command";
-var SINGLE_LINE_RULE = "must be a single line";
-var agentCommand = external_exports.string().check(external_exports.minLength(1), external_exports.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 });
-});
-var snapshotSchema = external_exports.strictObject({ triggerZone: external_exports._default(external_exports.enum(SNAPSHOT_TRIGGER_ZONES), "RED"), command: external_exports.optional(agentCommand), resumeCommand: external_exports.optional(agentCommand) }).check((ctx) => {
+var snapshotSchema = external_exports.strictObject({ triggerZone: external_exports._default(external_exports.enum(SNAPSHOT_TRIGGER_ZONES), "RED"), triggerPercentage: external_exports.optional(external_exports.int().check(external_exports.minimum(1), external_exports.maximum(100))), command: external_exports.optional(skillNameSchema), resumeCommand: external_exports.optional(skillNameSchema) }).check((ctx) => {
   if (ctx.value.resumeCommand !== void 0 && ctx.value.command === void 0) addIssue(ctx, { code: "custom", path: ["resumeCommand"], input: ctx.value.resumeCommand, message: RESUME_REQUIRES_COMMAND_RULE });
 });
 var DEFAULT_SNAPSHOT = { triggerZone: "RED" };
@@ -18383,11 +18404,22 @@ var HANDOFF_ARCHIVE_LIMIT = 10;
 import { mkdir, writeFile } from "node:fs/promises";
 import { join, resolve } from "node:path";
 
+// src/core/contracts/context-reading.ts
+var RUNTIME_IGNORE_CONTENT = "*\n";
+var PERCENTAGE_MAXIMUM = 100;
+var contextReadingSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  at: external_exports.string().check(external_exports.minLength(1)),
+  windowTokens: external_exports.nullable(external_exports.int().check(external_exports.positive())),
+  inputTokens: external_exports.nullable(external_exports.int().check(external_exports.nonnegative())),
+  usedPercentage: external_exports.nullable(external_exports.number().check(external_exports.gte(0), external_exports.lte(PERCENTAGE_MAXIMUM)))
+});
+
 // src/infrastructure/storage/runtime-state-files.ts
 var RUNTIME_STATE_RELATIVE_DIR = ".context-brake/runtime";
 
 // src/infrastructure/runtime/runtime-paths.ts
-var RUNTIME_GITIGNORE_CONTENT = "*\n";
+var RUNTIME_GITIGNORE_CONTENT = RUNTIME_IGNORE_CONTENT;
 var SESSIONS_DIR_NAME = "sessions";
 var SESSIONS_RELATIVE_PREFIX = `${RUNTIME_STATE_RELATIVE_DIR}/${SESSIONS_DIR_NAME}/`;
 function runtimeDirectory(projectRoot) {

package/dist/src/cli/assistant/assistant-context.js

@@ -1,5 +1,8 @@
 import { detectHarnesses } from '../../core/services/detection-service.js';
 import { getAllAdapters } from '../../infrastructure/harnesses/registry.js';
+import { resolveSkillInvocation } from '../../infrastructure/harnesses/skill-invocations.js';
+import { createSkillCatalogReader } from '../../infrastructure/skills/skill-catalog.js';
+import { detectContextSource } from '../../infrastructure/harnesses/claude-code/context-source.js';
 import { hasStatuslineOptOut } from '../../infrastructure/harnesses/claude-code/statusline-default.js';
 import { isInsideGitWorkingTree } from '../../infrastructure/git/git-context.js';
 import { NodeManifestStore } from '../../infrastructure/storage/manifest-store.js';
@@ -13,6 +16,10 @@ export async function buildAssistantContext(env, state) {
         detections: detectHarnesses(sources, state.selection),
         adapters,
         hasStatuslineOptOut: await hasStatuslineOptOut(env.projectRoot),
+        contextSource: await detectContextSource(buildHarnessContext(env, manifest)),
         insideGit: await isInsideGitWorkingTree(env.projectRoot),
+        invocations: resolveSkillInvocation,
+        projectRoot: env.projectRoot,
+        catalog: createSkillCatalogReader(),
     };
 }

package/dist/src/cli/assistant/assistant-questions.js

@@ -1,3 +1,4 @@
+import { invocationFacts } from './invocation-facts.js';
 import { askHarnesses } from './questions-harness.js';
 import { askMisc } from './questions-misc.js';
 import { askRestart } from './questions-restart.js';
@@ -6,7 +7,7 @@ export async function runQuestions(context, prompts) {
     const harness = await askHarnesses(context, prompts);
     if (harness === null)
         return null;
-    const snapshot = await askSnapshot(context, prompts);
+    const snapshot = await askSnapshot(context, harness.selected, prompts);
     if (snapshot === null)
         return null;
     const restart = await askRestart(context, { selected: harness.selected, hasSnapshotCommand: snapshot.command !== null }, prompts);
@@ -18,9 +19,9 @@ export async function runQuestions(context, prompts) {
     return {
         flags: [...harness.flags, ...snapshot.flags, ...restart.flags, ...misc.flags],
         facts: {
-            selected: harness.selected, excluded: harness.excluded, snapshotCommand: snapshot.command, triggerZone: snapshot.triggerZone,
-            resumeCommand: snapshot.resumeCommand, restartOn: restart.on, restartLimit: restart.limit, restartModes: restart.modes,
-            statuslineBridge: misc.statuslineBridge, debug: misc.debug, gitIgnore: misc.gitIgnore,
+            selected: harness.selected, excluded: harness.excluded, snapshotCommand: snapshot.command, triggerZone: snapshot.triggerZone, triggerPercentage: snapshot.triggerPercentage,
+            resumeCommand: snapshot.resumeCommand, invocations: invocationFacts(context.invocations, harness.selected, snapshot), restartOn: restart.on, restartLimit: restart.limit, restartModes: restart.modes,
+            statuslineBridge: misc.statuslineBridge, contextSource: misc.contextSource, debug: misc.debug, gitIgnore: misc.gitIgnore,
         },
     };
 }

package/dist/src/cli/assistant/assistant-session.js

@@ -1,5 +1,6 @@
 import { parseInit } from '../init-arguments.js';
 import { loadInitConfigState } from '../init-config-state.js';
+import { detectStyle } from '../output/style.js';
 import { buildAssistantContext } from './assistant-context.js';
 import { runQuestions } from './assistant-questions.js';
 import { formatEquivalentCommand } from './equivalent-command.js';
@@ -14,7 +15,8 @@ async function askForFlags(env, prompts) {
     const result = await runQuestions(await buildAssistantContext(env, state), prompts);
     if (result === null)
         return null;
-    process.stdout.write(`${renderSummary(result.facts, formatEquivalentCommand(result.flags)).join('\n')}\n`);
+    const style = detectStyle({ env: process.env, platform: process.platform, isTty: process.stdout.isTTY === true });
+    process.stdout.write(`${renderSummary(result.facts, formatEquivalentCommand(result.flags), style).join('\n')}\n`);
     return result.flags;
 }
 export async function resolveAssistedArgs(args, env, prompts) {

package/dist/src/cli/assistant/invocation-facts.d.ts

@@ -0,0 +1,5 @@
+import type { HarnessId } from '../../core/contracts/harness.js';
+import type { SkillInvocationResolver } from '../../core/contracts/skill-invocation.js';
+import type { SnapshotChoice } from './questions-snapshot.js';
+import type { HarnessInvocationFact } from './types.js';
+export declare function invocationFacts(resolve: SkillInvocationResolver, selected: readonly HarnessId[], snapshot: SnapshotChoice): HarnessInvocationFact[];

package/dist/src/cli/assistant/invocation-facts.js

@@ -0,0 +1,6 @@
+export function invocationFacts(resolve, selected, snapshot) {
+    const { command, resumeCommand } = snapshot;
+    if (command === null)
+        return [];
+    return selected.map((harness) => ({ harness, command: resolve(harness)(command), resumeCommand: resumeCommand === null ? null : resolve(harness)(resumeCommand) }));
+}

package/dist/src/cli/assistant/questions-misc.d.ts

@@ -3,6 +3,7 @@ import type { PromptPort } from './prompt-port.js';
 import type { AssistantContext } from './types.js';
 export type MiscChoice = {
     readonly statuslineBridge: boolean | null;
+    readonly contextSource: AssistantContext['contextSource'] | null;
     readonly debug: boolean;
     readonly gitIgnore: boolean | null;
     readonly flags: readonly string[];

package/dist/src/cli/assistant/questions-misc.js

@@ -10,7 +10,8 @@ async function askBridge(context, prompts) {
     return { answer: answer.value, flags: [answer.value ? '--statusline-bridge' : '--no-statusline-bridge'] };
 }
 export async function askMisc(context, selected, prompts) {
-    const bridge = selected.includes('claude-code') ? await askBridge(context, prompts) : { answer: null, flags: [] };
+    const isClaudeSelected = selected.includes('claude-code');
+    const bridge = isClaudeSelected && context.contextSource === 'bridge' ? await askBridge(context, prompts) : { answer: null, flags: [] };
     if (bridge === null)
         return null;
     const wasDebug = context.config?.debug === true;
@@ -21,5 +22,5 @@ export async function askMisc(context, selected, prompts) {
     const gitIgnore = await askGitIgnore(context, prompts);
     if (gitIgnore === null)
         return null;
-    return { statuslineBridge: bridge.answer, debug: debug.value, gitIgnore: gitIgnore.answer, flags: [...bridge.flags, ...debugFlags, ...gitIgnore.flags] };
+    return { statuslineBridge: bridge.answer, contextSource: isClaudeSelected ? context.contextSource : null, debug: debug.value, gitIgnore: gitIgnore.answer, flags: [...bridge.flags, ...debugFlags, ...gitIgnore.flags] };
 }

package/dist/src/cli/assistant/questions-skill.d.ts

@@ -0,0 +1,21 @@
+import type { HarnessId } from '../../core/contracts/harness.js';
+import { type SkillCandidate } from '../../core/services/skill-candidates.js';
+import { type SkillRole } from '../../core/services/skill-ranking.js';
+import { type Answer } from './ask.js';
+import type { PromptPort } from './prompt-port.js';
+import type { AssistantContext, Validation } from './types.js';
+import type { PromptSpec } from './ui-prompt.js';
+export type TypedSkill = {
+    readonly spec: PromptSpec;
+    readonly validate: (answer: string) => Validation<string | null>;
+};
+export type SkillQuestion = {
+    readonly role: SkillRole;
+    readonly current: string | undefined;
+    readonly exclude?: string | undefined;
+    readonly candidates: readonly SkillCandidate[];
+    readonly selectedCount: number;
+    readonly typed: TypedSkill;
+};
+export declare function loadCandidates(context: AssistantContext, selected: readonly HarnessId[]): Promise<SkillCandidate[]>;
+export declare function askSkill(question: SkillQuestion, prompts: PromptPort): Promise<Answer<string | null> | null>;

package/dist/src/cli/assistant/questions-skill.js

@@ -0,0 +1,45 @@
+import { mergeCatalogs } from '../../core/services/skill-candidates.js';
+import { rankSkills } from '../../core/services/skill-ranking.js';
+import { askValidated } from './ask.js';
+import { buildOptions, initialValue, NONE_VALUE, optionFor, OTHER_VALUE, pickSpec } from './skill-options.js';
+function warn(message) {
+    process.stderr.write(`WARN: ${message}\n`);
+}
+export async function loadCandidates(context, selected) {
+    try {
+        const read = await Promise.all(selected.map(async (harness) => ({ harness, catalog: await context.catalog(harness, context.projectRoot) })));
+        const warnings = read.flatMap(({ catalog }) => catalog.warnings);
+        if (warnings.length > 0)
+            warn(`Some skill folders could not be read (${warnings.join('; ')}); the list may be incomplete.`);
+        return mergeCatalogs(read.map(({ harness, catalog }) => ({ harness, skills: catalog.skills })));
+    }
+    catch (error) {
+        warn(`Could not read the project skills (${error instanceof Error ? error.message : 'unknown error'}); type the skill name instead.`);
+        return [];
+    }
+}
+function pickValidator(options, typed, initial) {
+    return (answer) => {
+        if (answer === '')
+            return { value: initial };
+        const option = optionFor(options, answer);
+        if (option !== null)
+            return { value: option };
+        const result = typed.validate(answer);
+        return 'error' in result ? result : { value: result.value ?? NONE_VALUE };
+    };
+}
+export async function askSkill(question, prompts) {
+    const { role, current, typed } = question;
+    const ranked = rankSkills(role, question.candidates, { exclude: question.exclude });
+    if (ranked.length === 0)
+        return askValidated(prompts, typed.spec, typed.validate);
+    const options = buildOptions({ role, ranked, current, selectedCount: question.selectedCount });
+    const initial = initialValue(options, current);
+    const picked = await askValidated(prompts, pickSpec(role, options, initial), pickValidator(options, typed, initial));
+    if (picked === null)
+        return null;
+    if (picked.value === OTHER_VALUE)
+        return askValidated(prompts, typed.spec, typed.validate);
+    return { value: picked.value === NONE_VALUE ? null : picked.value };
+}

package/dist/src/cli/assistant/questions-snapshot.d.ts

@@ -1,9 +1,11 @@
+import type { HarnessId } from '../../core/contracts/harness.js';
 import type { PromptPort } from './prompt-port.js';
 import type { AssistantContext } from './types.js';
 export type SnapshotChoice = {
     readonly command: string | null;
     readonly triggerZone: string;
+    readonly triggerPercentage: number | null;
     readonly resumeCommand: string | null;
     readonly flags: readonly string[];
 };
-export declare function askSnapshot(context: AssistantContext, prompts: PromptPort): Promise<SnapshotChoice | null>;
+export declare function askSnapshot(context: AssistantContext, selected: readonly HarnessId[], prompts: PromptPort): Promise<SnapshotChoice | null>;

package/dist/src/cli/assistant/questions-snapshot.js

@@ -1,7 +1,9 @@
 import { mergeSnapshot } from '../../core/services/snapshot-merge.js';
-import { askValidated } from './ask.js';
-import { commandSpec, resumeSpec, triggerSpec } from './snapshot-specs.js';
+import { askSkill, loadCandidates } from './questions-skill.js';
+import { askTrigger } from './questions-trigger.js';
+import { commandSpec, resumeSpec } from './snapshot-specs.js';
 const NONE_WORD = 'none';
+const RESUME_NONE_MESSAGE = 'Enter keeps the current resume skill; to remove it use --no-snapshot-command, which clears both skills.';
 const DEFAULT_ZONE = 'RED';
 function checked(candidate) {
     const merge = mergeSnapshot(undefined, { ...candidate, clearCommand: false });
@@ -17,48 +19,41 @@ function validateCommand(current) {
         return error === null ? { value: answer } : { error };
     };
 }
-function validateTrigger(current) {
-    return (answer) => {
-        if (answer === '')
-            return { value: current };
-        const error = checked({ triggerZone: answer });
-        return error === null ? { value: answer } : { error };
-    };
-}
 function validateResume(current) {
     return (answer) => {
         if (answer === '')
             return { value: current ?? null };
+        if (answer.toLowerCase() === NONE_WORD)
+            return { error: RESUME_NONE_MESSAGE };
         const error = checked({ command: 'placeholder', resumeCommand: answer });
         return error === null ? { value: answer } : { error };
     };
 }
-function valueFlag(name, value) {
-    return value.startsWith('-') ? [`${name}=${value}`] : [name, value];
-}
 async function askCommandOptions(input, prompts) {
-    const { current, command } = input;
-    const currentZone = current?.triggerZone ?? DEFAULT_ZONE;
-    const zone = await askValidated(prompts, triggerSpec(currentZone), validateTrigger(currentZone));
-    if (zone === null)
+    const { current, command, pool } = input;
+    const trigger = await askTrigger({ zone: current?.triggerZone ?? DEFAULT_ZONE, percentage: current?.triggerPercentage ?? null }, prompts);
+    if (trigger === null)
         return null;
-    const resume = await askValidated(prompts, resumeSpec(current?.resumeCommand), validateResume(current?.resumeCommand));
+    const typed = { spec: resumeSpec(current?.resumeCommand), validate: validateResume(current?.resumeCommand) };
+    const resume = await askSkill({ role: 'resume', current: current?.resumeCommand, exclude: command, ...pool, typed }, prompts);
     if (resume === null)
         return null;
     const flags = [
-        ...(command === current?.command ? [] : valueFlag('--snapshot-command', command)),
-        ...(zone.value === currentZone ? [] : ['--snapshot-trigger', zone.value]),
-        ...(resume.value === null || resume.value === current?.resumeCommand ? [] : valueFlag('--resume-command', resume.value)),
+        ...(command === current?.command ? [] : ['--snapshot-command', command]),
+        ...trigger.flags,
+        ...(resume.value === null || resume.value === current?.resumeCommand ? [] : ['--resume-command', resume.value]),
     ];
-    return { command, triggerZone: zone.value, resumeCommand: resume.value, flags };
+    return { command, triggerZone: trigger.zone, triggerPercentage: trigger.percentage, resumeCommand: resume.value, flags };
 }
-export async function askSnapshot(context, prompts) {
+export async function askSnapshot(context, selected, prompts) {
     const current = context.config?.snapshot;
-    const command = await askValidated(prompts, commandSpec(current?.command), validateCommand(current?.command));
+    const pool = { candidates: await loadCandidates(context, selected), selectedCount: selected.length };
+    const typed = { spec: commandSpec(current?.command), validate: validateCommand(current?.command) };
+    const command = await askSkill({ role: 'snapshot', current: current?.command, ...pool, typed }, prompts);
     if (command === null)
         return null;
     if (command.value !== null)
-        return askCommandOptions({ current, command: command.value }, prompts);
+        return askCommandOptions({ current, command: command.value, pool }, prompts);
     const flags = current?.command === undefined ? [] : ['--no-snapshot-command'];
-    return { command: null, triggerZone: current?.triggerZone ?? DEFAULT_ZONE, resumeCommand: null, flags };
+    return { command: null, triggerZone: current?.triggerZone ?? DEFAULT_ZONE, triggerPercentage: current?.triggerPercentage ?? null, resumeCommand: null, flags };
 }

package/dist/src/cli/assistant/questions-trigger.d.ts

@@ -0,0 +1,6 @@
+import type { PromptPort } from './prompt-port.js';
+import { type TriggerState } from './snapshot-specs.js';
+export type TriggerChoice = TriggerState & {
+    readonly flags: readonly string[];
+};
+export declare function askTrigger(current: TriggerState, prompts: PromptPort): Promise<TriggerChoice | null>;

package/dist/src/cli/assistant/questions-trigger.js

@@ -0,0 +1,56 @@
+import { mergeSnapshot } from '../../core/services/snapshot-merge.js';
+import { askValidated } from './ask.js';
+import { PERCENTAGE_OPTION, percentageSpec, triggerSpec } from './snapshot-specs.js';
+const PERCENTAGE_RULE = 'Enter a whole number from 1 to 100.';
+const INTEGER_PATTERN = /^\d+$/;
+function checked(candidate) {
+    const merge = mergeSnapshot(undefined, { ...candidate, clearCommand: false });
+    return 'error' in merge ? merge.error : null;
+}
+function validatePercentage(current) {
+    return (answer) => {
+        if (answer === '' && current !== null)
+            return { value: current };
+        if (!INTEGER_PATTERN.test(answer))
+            return { error: PERCENTAGE_RULE };
+        const error = checked({ triggerPercentage: Number(answer) });
+        return error === null ? { value: Number(answer) } : { error };
+    };
+}
+function typedPercentage(answer) {
+    const result = validatePercentage(null)(answer);
+    return 'error' in result ? result : { value: { zone: null, percentage: result.value } };
+}
+function validateTrigger(current) {
+    return (answer) => {
+        if (answer === '')
+            return { value: current.percentage === null ? { zone: current.zone, percentage: null } : { zone: null, percentage: current.percentage } };
+        if (answer.toLowerCase() === PERCENTAGE_OPTION)
+            return { value: { zone: null, percentage: null } };
+        if (INTEGER_PATTERN.test(answer))
+            return typedPercentage(answer);
+        const error = checked({ triggerZone: answer });
+        return error === null ? { value: { zone: answer, percentage: null } } : { error };
+    };
+}
+function triggerFlags(current, choice) {
+    if (choice.percentage !== null)
+        return choice.percentage === current.percentage ? [] : ['--snapshot-trigger-percentage', String(choice.percentage)];
+    return choice.zone === current.zone && current.percentage === null ? [] : ['--snapshot-trigger', choice.zone];
+}
+async function askPercentage(current, prompts) {
+    const answer = await askValidated(prompts, percentageSpec(current.percentage), validatePercentage(current.percentage));
+    return answer === null ? null : answer.value;
+}
+export async function askTrigger(current, prompts) {
+    const answer = await askValidated(prompts, triggerSpec(current), validateTrigger(current));
+    if (answer === null)
+        return null;
+    const { zone } = answer.value;
+    if (zone !== null)
+        return { zone, percentage: null, flags: triggerFlags(current, { zone, percentage: null }) };
+    const percentage = answer.value.percentage ?? (await askPercentage(current, prompts));
+    if (percentage === null)
+        return null;
+    return { zone: current.zone, percentage, flags: triggerFlags(current, { zone: current.zone, percentage }) };
+}

package/dist/src/cli/assistant/skill-options.d.ts

@@ -0,0 +1,20 @@
+import type { SkillCandidate } from '../../core/services/skill-candidates.js';
+import type { SkillRole } from '../../core/services/skill-ranking.js';
+import type { PromptSpec } from './ui-prompt.js';
+export declare const OTHER_VALUE = "?other";
+export declare const NONE_VALUE = "?none";
+export type PickOption = {
+    readonly value: string;
+    readonly label: string;
+    readonly hint: string;
+};
+export type OptionsInput = {
+    readonly role: SkillRole;
+    readonly ranked: readonly SkillCandidate[];
+    readonly current: string | undefined;
+    readonly selectedCount: number;
+};
+export declare function buildOptions(input: OptionsInput): PickOption[];
+export declare function initialValue(options: readonly PickOption[], current: string | undefined): string;
+export declare function optionFor(options: readonly PickOption[], answer: string): string | null;
+export declare function pickSpec(role: SkillRole, options: readonly PickOption[], initial: string): PromptSpec;

package/dist/src/cli/assistant/skill-options.js

@@ -0,0 +1,40 @@
+export const OTHER_VALUE = '?other';
+export const NONE_VALUE = '?none';
+const PICK_COUNT = 4;
+const TITLES = { snapshot: 'Snapshot skill', resume: 'Resume skill' };
+function foundIn(candidate, selectedCount) {
+    if (candidate.origins.length >= selectedCount)
+        return `found in ${[...new Set(candidate.origins.map((origin) => origin.folder))].join(', ')}`;
+    return `found in ${candidate.origins.map((origin) => `${origin.harness} (${origin.folder})`).join(', ')}`;
+}
+function pickOption(candidate, index, input) {
+    const tags = [...(index === 0 ? ['recommended'] : []), ...(candidate.name === input.current ? ['current'] : [])];
+    return { value: candidate.name, label: tags.length === 0 ? candidate.name : `${candidate.name} (${tags.join(', ')})`, hint: foundIn(candidate, input.selectedCount) };
+}
+export function buildOptions(input) {
+    const picks = input.ranked.slice(0, PICK_COUNT);
+    const options = picks.map((candidate, index) => pickOption(candidate, index, input));
+    const { current } = input;
+    if (current !== undefined && !picks.some((candidate) => candidate.name === current)) {
+        options.unshift({ value: current, label: `${current} (current)`, hint: 'configured, not found in the project skill folders' });
+    }
+    const none = input.role === 'snapshot' ? [{ value: NONE_VALUE, label: 'none', hint: 'no snapshot skill' }] : [];
+    return [...options, { value: OTHER_VALUE, label: 'type another', hint: 'enter a skill name' }, ...none];
+}
+export function initialValue(options, current) {
+    return current ?? options[0]?.value ?? NONE_VALUE;
+}
+export function optionFor(options, answer) {
+    const named = options.find((option) => option.value === answer);
+    if (named !== undefined)
+        return named.value;
+    const number = Number(answer);
+    return Number.isInteger(number) && number >= 1 && number <= options.length ? options[number - 1]?.value ?? null : null;
+}
+export function pickSpec(role, options, initial) {
+    const lines = options.map((option, index) => `  ${String(index + 1)}) ${option.label} — ${option.hint}`);
+    return {
+        line: `${TITLES[role]}:\n${lines.join('\n')}\nNumber or skill name (Enter keeps [${initial}]): `,
+        ui: { kind: 'select', message: TITLES[role], options: options.map((option) => ({ value: option.value, label: option.label, hint: option.hint })), initial },
+    };
+}

package/dist/src/cli/assistant/snapshot-specs.d.ts

@@ -1,4 +1,10 @@
 import type { PromptSpec } from './ui-prompt.js';
 export declare function commandSpec(current: string | undefined): PromptSpec;
-export declare function triggerSpec(currentZone: string): PromptSpec;
+export declare const PERCENTAGE_OPTION = "percentage";
+export type TriggerState = {
+    readonly zone: string;
+    readonly percentage: number | null;
+};
+export declare function triggerSpec(current: TriggerState): PromptSpec;
+export declare function percentageSpec(current: number | null): PromptSpec;
 export declare function resumeSpec(current: string | undefined): PromptSpec;

package/dist/src/cli/assistant/snapshot-specs.js

@@ -3,20 +3,30 @@ const NONE_WORD = 'none';
 export function commandSpec(current) {
     const shown = current ?? NONE_WORD;
     return {
-        line: `Snapshot command (Enter keeps [${shown}], type none for no command): `,
-        ui: { kind: 'text', message: 'Snapshot command the agent runs before a reset (type none for no command)', placeholder: `Enter keeps ${shown}` },
+        line: `Snapshot skill name (Enter keeps [${shown}], type none for no skill): `,
+        ui: { kind: 'text', message: 'Name of the skill the agent runs before a reset, without a leading slash (type none for no skill)', placeholder: `Enter keeps ${shown}` },
     };
 }
-export function triggerSpec(currentZone) {
+export const PERCENTAGE_OPTION = 'percentage';
+export function triggerSpec(current) {
+    const shown = current.percentage === null ? current.zone : `${current.percentage}%`;
+    const options = [...SNAPSHOT_TRIGGER_ZONES.map((zone) => ({ value: zone, label: zone })), { value: PERCENTAGE_OPTION, label: 'Percentage of the context window' }];
     return {
-        line: `Snapshot trigger ${SNAPSHOT_TRIGGER_ZONES.join(' or ')} [${currentZone}]: `,
-        ui: { kind: 'select', message: 'Zone where the snapshot is requested', options: SNAPSHOT_TRIGGER_ZONES.map((zone) => ({ value: zone, label: zone })), initial: currentZone },
+        line: `Snapshot trigger ${SNAPSHOT_TRIGGER_ZONES.join(', ')} or a percentage 1-100 [${shown}]: `,
+        ui: { kind: 'select', message: 'Where the snapshot is requested: a zone or a percentage of the context window', options, initial: current.percentage === null ? current.zone : PERCENTAGE_OPTION },
+    };
+}
+export function percentageSpec(current) {
+    const shown = current === null ? 'none' : `${current}%`;
+    return {
+        line: `Trigger percentage 1-100 [${shown}]: `,
+        ui: { kind: 'text', message: 'Percentage of the context window that requests the snapshot (1-100)', placeholder: `Enter keeps ${shown}` },
     };
 }
 export function resumeSpec(current) {
     const shown = current ?? NONE_WORD;
     return {
-        line: `Resume command (Enter keeps [${shown}]): `,
-        ui: { kind: 'text', message: 'Command that resumes the work in the new session', placeholder: `Enter keeps ${shown}` },
+        line: `Resume skill name (Enter keeps [${shown}]): `,
+        ui: { kind: 'text', message: 'Name of the skill that resumes the work in the new session', placeholder: `Enter keeps ${shown}` },
     };
 }

package/dist/src/cli/assistant/summary-rows.d.ts

@@ -0,0 +1,5 @@
+import type { CardRow } from '../output/card.js';
+import type { AssistantFacts } from './types.js';
+export declare function harnessRows(facts: AssistantFacts): CardRow[];
+export declare function snapshotRows(facts: AssistantFacts): CardRow[];
+export declare function optionRows(facts: AssistantFacts): CardRow[];

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

@@ -0,0 +1,47 @@
+import { describeTrigger } from '../../core/services/trigger-text.js';
+function enabledRow(facts, harness) {
+    const mode = facts.restartModes.find((fact) => fact.harness === harness)?.mode;
+    return { label: harness, value: mode === undefined ? 'enabled' : `enabled, restart: ${mode}`, tone: 'good' };
+}
+export function harnessRows(facts) {
+    const selected = facts.selected.map((harness) => enabledRow(facts, harness));
+    const excluded = facts.excluded.map((harness) => ({ label: harness, value: 'turned off', tone: 'muted' }));
+    if (selected.length > 0)
+        return [...selected, ...excluded];
+    return [{ label: 'none', value: 'no harness selected', tone: 'warn' }, ...excluded];
+}
+function triggerRow(facts) {
+    if (facts.triggerPercentage === null)
+        return { label: 'Trigger zone', value: facts.triggerZone };
+    return { label: 'Trigger', value: describeTrigger(facts) };
+}
+export function snapshotRows(facts) {
+    if (facts.snapshotCommand === null)
+        return [{ label: 'Command', value: 'none (only zone headers are injected)', tone: 'muted' }];
+    const resume = facts.resumeCommand === null ? { label: 'Resume', value: 'none', tone: 'muted' } : { label: 'Resume', value: facts.resumeCommand, tone: 'accent' };
+    const received = facts.invocations.map((fact) => ({ label: `In ${fact.harness}`, value: `${fact.command}${fact.resumeCommand === null ? '' : `, resume: ${fact.resumeCommand}`}`, tone: 'accent' }));
+    return [{ label: 'Command', value: facts.snapshotCommand, tone: 'accent' }, triggerRow(facts), resume, ...received];
+}
+function switchRow(label, isOn, words) {
+    return isOn ? { label, value: words[0], tone: 'good' } : { label, value: words[1], tone: 'muted' };
+}
+function restartRow(facts) {
+    if (!facts.restartOn)
+        return switchRow('Restart', false, ['on', 'off']);
+    return { label: 'Restart', value: `on, at most ${facts.restartLimit ?? 'the default number of'} consecutive restarts`, tone: 'good' };
+}
+function contextRow(facts) {
+    if (facts.contextSource === 'mod')
+        return { label: 'Context source', value: 'mod (your status line is left alone)', tone: 'good' };
+    if (facts.statuslineBridge === null)
+        return { label: 'Status line bridge', value: 'not applicable (Claude Code not selected)', tone: 'muted' };
+    return switchRow('Status line bridge', facts.statuslineBridge, ['yes', 'no']);
+}
+function gitIgnoreRow(facts) {
+    if (facts.gitIgnore === null)
+        return { label: 'Git ignore', value: 'not applicable (not a Git repository)', tone: 'muted' };
+    return switchRow('Git ignore', facts.gitIgnore, ['yes', 'no']);
+}
+export function optionRows(facts) {
+    return [restartRow(facts), contextRow(facts), switchRow('Debug mode', facts.debug, ['on', 'off']), gitIgnoreRow(facts)];
+}

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

@@ -1,2 +1,3 @@
+import { type Style } from '../output/style.js';
 import type { AssistantFacts } from './types.js';
-export declare function renderSummary(facts: AssistantFacts, command: readonly string[]): string[];
+export declare function renderSummary(facts: AssistantFacts, command: readonly string[], style?: Style): string[];