context-brake 1.0.0 → 1.1.0

package/dist/src/core/services/zone-guidance.js

@@ -1,5 +1,6 @@
 import { ZONES } from '../contracts/zones.js';
 import { SESSION_RESET_SIGNAL } from './reset-notice.js';
+import { sentenceInvocation } from './skill-invocation.js';
 const RESUME_PREFIX = '[ContextBrake resume v1]';
 const HANDOFF_PATH = '.context-brake/handoff.md';
 const GENERIC_ACTIONS = {
@@ -8,24 +9,29 @@ const GENERIC_ACTIONS = {
     RED: 'finish or pause the current unit and tell the user what remains',
     CRITICAL: 'stop starting new work; tell the user what remains',
 };
-export function zoneAction(zone, snapshot, mode = 'off') {
-    if (zone === 'GREEN' || !isAtOrAbove(zone, snapshot.triggerZone))
+export function isResetDue(reading, snapshot) {
+    if (snapshot.triggerPercentage !== undefined)
+        return reading.usagePercentage >= snapshot.triggerPercentage;
+    return reading.zone !== 'GREEN' && isAtOrAbove(reading.zone, snapshot.triggerZone);
+}
+export function zoneAction(zone, snapshot, options = {}) {
+    if (!isResetDue({ zone, usagePercentage: options.usagePercentage ?? 0 }, snapshot))
         return GENERIC_ACTIONS[zone];
     if (snapshot.command !== undefined)
-        return snapshotAction(zone, snapshot.command);
-    if (mode !== 'handoff')
+        return snapshotAction(zone, (options.invoke ?? sentenceInvocation)(snapshot.command));
+    if ((options.mode ?? 'off') !== 'handoff')
         return GENERIC_ACTIONS[zone];
     return `save handoff to ${HANDOFF_PATH}, end reply with ${SESSION_RESET_SIGNAL}`;
 }
-function snapshotAction(zone, command) {
+function snapshotAction(zone, invocation) {
     const now = zone === 'CRITICAL' ? ' now' : '';
-    return `run "${command}"${now}, then end reply with ${SESSION_RESET_SIGNAL}`;
+    return `run "${invocation}"${now}, then end reply with ${SESSION_RESET_SIGNAL}`;
 }
 export function handoffResumeText(archivedPath) {
     return `${RESUME_PREFIX} Read "${archivedPath}" and continue the previous work from it.`;
 }
-export function resumeText(snapshot) {
-    return snapshot.resumeCommand === undefined ? null : `${RESUME_PREFIX} Run "${snapshot.resumeCommand}" before continuing.`;
+export function resumeText(snapshot, invoke = sentenceInvocation) {
+    return snapshot.resumeCommand === undefined ? null : `${RESUME_PREFIX} Run "${invoke(snapshot.resumeCommand)}" before continuing.`;
 }
 function isAtOrAbove(zone, trigger) {
     return ZONES.indexOf(zone) >= ZONES.indexOf(trigger);

package/dist/src/infrastructure/harnesses/antigravity-cli/runtime.js

@@ -1,10 +1,11 @@
+import { ANTIGRAVITY_SKILL_INVOCATION } from './skill-invocation.js';
 import { asRecord, assetProjectRoot, characterLength, parsePayload, requireIdentifier, textValue } from '../common/runtime-support.js';
 import { runProcessHook } from '../../runtime/process-hook-host.js';
 import { ANTIGRAVITY_CAPABILITIES } from './capabilities.js';
 import { antigravityPayloadSchema } from './schemas.js';
 const HARNESS = 'antigravity-cli';
 const ESTIMATION = { baselineTokens: 15000, tokensPerTurn: 150 };
-export const antigravityDescriptor = { harness: HARNESS, capabilities: ANTIGRAVITY_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: null };
+export const antigravityDescriptor = { harness: HARNESS, capabilities: ANTIGRAVITY_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: null, skillInvocation: ANTIGRAVITY_SKILL_INVOCATION };
 function sessionOf(payload) {
     return { harness: HARNESS, sessionId: requireIdentifier(payload.conversationId), agentId: null };
 }

package/dist/src/infrastructure/harnesses/antigravity-cli/skill-folders.d.ts

@@ -0,0 +1 @@
+export declare const ANTIGRAVITY_SKILL_FOLDERS: readonly string[];

package/dist/src/infrastructure/harnesses/antigravity-cli/skill-folders.js

@@ -0,0 +1 @@
+export const ANTIGRAVITY_SKILL_FOLDERS = ['.agents/skills'];

package/dist/src/infrastructure/harnesses/antigravity-cli/skill-invocation.d.ts

@@ -0,0 +1,2 @@
+import type { SkillInvocationFormat } from '../../../core/contracts/skill-invocation.js';
+export declare const ANTIGRAVITY_SKILL_INVOCATION: SkillInvocationFormat;

package/dist/src/infrastructure/harnesses/antigravity-cli/skill-invocation.js

@@ -0,0 +1,2 @@
+import { sentenceInvocation } from '../../../core/services/skill-invocation.js';
+export const ANTIGRAVITY_SKILL_INVOCATION = sentenceInvocation;

package/dist/src/infrastructure/harnesses/claude-code/adapter.js

@@ -4,11 +4,13 @@ import {} from '../../../core/contracts/harness.js';
 import { deriveSupportProfile } from '../../../core/services/support-service.js';
 import { validateJsonDocument } from '../../storage/json-validator.js';
 import { createAssetMissingFinding, createIntegrationMissingFinding, createInvalidConfigFinding } from '../common/diagnostic-helpers.js';
+import { applyConfigOrigin, attachConfigOrigin } from '../common/config-origin.js';
 import { pathExists } from '../common/path-helpers.js';
 import { probeExecutableVersion } from '../common/version-probes.js';
 import { diagnoseAutoRestart } from './auto-restart-diagnostics.js';
 import { CLAUDE_CAPABILITIES } from './capabilities.js';
 import { isTargetGroup } from './claude-merger.js';
+import { detectContextSource } from './context-source.js';
 import { CLAUDE_EXECUTABLES, detectClaude } from './detector.js';
 import { CLAUDE_CONFIG_FILE, CLAUDE_HOOK_FILE, planClaudeInstall, planClaudeRemove } from './planner.js';
 import { diagnoseStatusline } from './statusline-diagnostics.js';
@@ -24,11 +26,11 @@ export class ClaudeAdapter {
     probeVersion(context) {
         return probeExecutableVersion(context.runner, CLAUDE_EXECUTABLES);
     }
-    planInstall(context) {
-        return planClaudeInstall(context);
+    async planInstall(context) {
+        return attachConfigOrigin(await planClaudeInstall(context, await detectContextSource(context)), { path: CLAUDE_CONFIG_FILE, manifest: context.manifest });
     }
-    planRemove(context) {
-        return planClaudeRemove(context.projectRoot);
+    async planRemove(context) {
+        return applyConfigOrigin(await planClaudeRemove(context.projectRoot), { path: CLAUDE_CONFIG_FILE, manifest: context.manifest });
     }
     async diagnose(context) {
         const findings = [];

package/dist/src/infrastructure/harnesses/claude-code/auto-restart-diagnostics.d.ts

@@ -7,3 +7,4 @@ export type AutoRestartDiagnosis = {
     readonly version: VersionProbe | null;
 };
 export declare function diagnoseAutoRestart(input: AutoRestartDiagnosis): Promise<DiagnosticFinding[]>;
+export declare function isModInstalled(projectRoot: string): Promise<boolean>;

package/dist/src/infrastructure/harnesses/claude-code/auto-restart-diagnostics.js

@@ -30,7 +30,7 @@ export async function diagnoseAutoRestart(input) {
     const normalized = input.version?.normalized ?? null;
     if (normalized !== null && semver.lt(normalized, MODS_MINIMUM_CLAUDE_VERSION))
         return [finding(tooOld(normalized))];
-    if (!(await isInstalled(input.projectRoot)))
+    if (!(await isModInstalled(input.projectRoot)))
         return [finding(FILES_DRIFTED)];
     const log = await latestRestartLog(input.projectRoot, 'claude-code');
     if (log === null)
@@ -41,7 +41,7 @@ export async function diagnoseAutoRestart(input) {
     const skip = last !== undefined && last.code !== 'RESTARTED' ? [finding(lastSkip(last.code, last.at))] : [];
     return [finding(READY), ...skip];
 }
-async function isInstalled(projectRoot) {
+export async function isModInstalled(projectRoot) {
     const present = await Promise.all(MOD_FILES.map((path) => pathExists(resolve(projectRoot, path))));
     if (present.includes(false))
         return false;

package/dist/src/infrastructure/harnesses/claude-code/auto-restart-planner.d.ts

@@ -4,4 +4,8 @@ export type AutoRestartPlan = {
     readonly changes: readonly PlannedChange[];
     readonly conflicts: readonly PlanConflict[];
 };
-export declare function planAutoRestart(context: HarnessContext, base: readonly PlannedChange[], deleteFiles?: boolean): Promise<AutoRestartPlan>;
+export type AutoRestartOptions = {
+    readonly deleteFiles?: boolean;
+    readonly forModFirst?: boolean;
+};
+export declare function planAutoRestart(context: HarnessContext, base: readonly PlannedChange[], options?: AutoRestartOptions): Promise<AutoRestartPlan>;

package/dist/src/infrastructure/harnesses/claude-code/auto-restart-planner.js

@@ -16,7 +16,7 @@ async function installChanges(root) {
     };
     return Promise.all(MOD_FILES.map(async (path) => ({
         path, realPath: await resolveChangeTarget(root, path), kind: 'create', owner: 'runtime_asset',
-        content: contents[path] ?? '', preview: { summary: 'Install the automatic restart mod' },
+        content: contents[path] ?? '', preview: { summary: 'Install the ContextBrake mod' },
     })));
 }
 async function isModified(context, path) {
@@ -27,7 +27,7 @@ async function isModified(context, path) {
     return current !== recorded.sha256;
 }
 async function deletion(root, path) {
-    return { path, realPath: await resolveChangeTarget(root, path), kind: 'delete', owner: 'runtime_asset', content: null, preview: { summary: 'Delete the automatic restart mod' } };
+    return { path, realPath: await resolveChangeTarget(root, path), kind: 'delete', owner: 'runtime_asset', content: null, preview: { summary: 'Delete the ContextBrake mod' } };
 }
 async function removalChanges(context) {
     const present = await Promise.all(MOD_FILES.map(async (path) => ((await pathExists(resolve(context.projectRoot, path))) ? path : undefined)));
@@ -53,7 +53,7 @@ async function settingsChange(root, base, wanted) {
     if (text === base.text && base.existing === undefined)
         return undefined;
     const drop = !wanted && base.owned && isEmptySettings(text);
-    const summary = wanted ? 'Register the automatic restart mod' : 'Unregister the automatic restart mod';
+    const summary = wanted ? 'Register the ContextBrake mod' : 'Unregister the ContextBrake mod';
     const kind = drop ? 'delete' : base.existing?.kind ?? (base.isNew ? 'create' : 'update');
     return { path: CLAUDE_LOCAL_SETTINGS_FILE, realPath: await resolveChangeTarget(root, CLAUDE_LOCAL_SETTINGS_FILE), kind, owner: 'harness_entry', content: drop ? null : text, preview: drop ? { summary: 'Delete the local settings left empty' } : base.existing?.preview ?? { summary } };
 }
@@ -66,9 +66,9 @@ async function fileChanges(context, wanted, deleteFiles) {
 function isLocalSettingsDeletion(change) {
     return change.path === CLAUDE_LOCAL_SETTINGS_FILE && change.kind === 'delete';
 }
-export async function planAutoRestart(context, base, deleteFiles = true) {
-    const wanted = context.autoRestart === true;
-    const files = await fileChanges(context, wanted, deleteFiles);
+export async function planAutoRestart(context, base, options = {}) {
+    const wanted = context.autoRestart === true || options.forModFirst === true;
+    const files = await fileChanges(context, wanted, options.deleteFiles ?? true);
     const deletesLocal = base.some(isLocalSettingsDeletion);
     if (deletesLocal && !wanted)
         return { changes: [...base, ...files.changes], conflicts: files.conflicts };

package/dist/src/infrastructure/harnesses/claude-code/capabilities.js

@@ -1,6 +1,6 @@
 export const CLAUDE_CAPABILITIES = [
     { id: 'post_tool_telemetry', state: 'supported' },
     { id: 'session_boot', state: 'supported' },
-    { id: 'context_usage', state: 'unknown', impact: 'Read from the session transcript, whose format is undocumented; falls back to an estimate. The context window comes from the status line bridge, which init installs by default; without it, the window falls back to contextWindowCeiling.' },
+    { id: 'context_usage', state: 'unknown', impact: 'Read from the session transcript, whose format is undocumented; falls back to an estimate. The context window comes from the mod that init installs on Claude Code 2.1.287 or later, or from the status line bridge on older versions; without either, it falls back to contextWindowCeiling.' },
     { id: 'auto_restart', state: 'unknown', impact: 'Opt-in through init --auto-restart; needs Claude Code 2.1.287 or later with mods enabled. Run doctor to check that the mod loads.' },
 ];

package/dist/src/infrastructure/harnesses/claude-code/context-readings-scan.d.ts

@@ -0,0 +1,2 @@
+import { type ContextReading } from '../../../core/contracts/context-reading.js';
+export declare function latestContextReading(projectRoot: string): Promise<ContextReading | null>;

package/dist/src/infrastructure/harnesses/claude-code/context-readings-scan.js

@@ -0,0 +1,21 @@
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { CONTEXT_READINGS_RELATIVE_DIR } from '../../../core/contracts/context-reading.js';
+import { parseContextReading } from './mod-reading.js';
+const READING_EXTENSION = '.json';
+async function modifiedMilliseconds(path) {
+    return (await stat(path).catch(() => null))?.mtimeMs ?? 0;
+}
+async function newestFirst(directory) {
+    const names = (await readdir(directory).catch(() => [])).filter((name) => name.endsWith(READING_EXTENSION));
+    const dated = await Promise.all(names.map(async (name) => ({ path: join(directory, name), time: await modifiedMilliseconds(join(directory, name)) })));
+    return dated.sort((left, right) => right.time - left.time).map((entry) => entry.path);
+}
+export async function latestContextReading(projectRoot) {
+    for (const path of await newestFirst(resolve(projectRoot, CONTEXT_READINGS_RELATIVE_DIR, 'claude-code'))) {
+        const reading = parseContextReading(await readFile(path, 'utf8').catch(() => ''));
+        if (reading !== null)
+            return reading;
+    }
+    return null;
+}

package/dist/src/infrastructure/harnesses/claude-code/context-source.d.ts

@@ -0,0 +1,10 @@
+import type { HarnessContext, StatuslineBridgeRequest } from '../../../core/contracts/adapter.js';
+import type { VersionProbe } from '../../../core/contracts/harness.js';
+export declare const CONTEXT_MOD_MINIMUM_CLAUDE_VERSION = "2.1.287";
+export type ContextSource = 'mod' | 'bridge';
+export type ContextSourceInput = {
+    readonly request: StatuslineBridgeRequest;
+    readonly version: VersionProbe;
+};
+export declare function decideContextSource(input: ContextSourceInput): ContextSource;
+export declare function detectContextSource(context: HarnessContext): Promise<ContextSource>;

package/dist/src/infrastructure/harnesses/claude-code/context-source.js

@@ -0,0 +1,16 @@
+import semver from 'semver';
+import { NodeProcessRunner } from '../../process/node-process-runner.js';
+import { probeExecutableVersion } from '../common/version-probes.js';
+import { MODS_MINIMUM_CLAUDE_VERSION } from './auto-restart-diagnostics.js';
+import { CLAUDE_EXECUTABLES } from './detector.js';
+export const CONTEXT_MOD_MINIMUM_CLAUDE_VERSION = MODS_MINIMUM_CLAUDE_VERSION;
+export function decideContextSource(input) {
+    if (input.request === 'install')
+        return 'bridge';
+    const version = input.version.normalized;
+    return version !== null && semver.gte(version, CONTEXT_MOD_MINIMUM_CLAUDE_VERSION) ? 'mod' : 'bridge';
+}
+export async function detectContextSource(context) {
+    const version = await probeExecutableVersion(context.runner ?? new NodeProcessRunner(), CLAUDE_EXECUTABLES);
+    return decideContextSource({ request: context.statuslineBridge ?? 'default', version });
+}

package/dist/src/infrastructure/harnesses/claude-code/mod/context-reading.d.ts

@@ -0,0 +1,2 @@
+import type { ModHost } from './host.js';
+export declare function publishContextReading($: ModHost): Promise<void>;

package/dist/src/infrastructure/harnesses/claude-code/mod/context-reading.js

@@ -0,0 +1,67 @@
+import { contextReadingRelativePath, contextReadingSchema, isReadingSessionId, RUNTIME_IGNORE_CONTENT, RUNTIME_IGNORE_RELATIVE_PATH } from '../../../../core/contracts/context-reading.js';
+import { lastRecordedCode } from './mod-log.js';
+import { reportSafely } from './restart-flow.js';
+const READING_HARNESS = 'claude-code';
+const READING_VERSION = 1;
+const PERCENTAGE_MAXIMUM = 100;
+const UNREADABLE_CODE = 'ERROR_INTERNAL';
+function positiveIntegerOrNull(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value > 0 ? value : null;
+}
+function countOrNull(value) {
+    return typeof value === 'number' && Number.isInteger(value) && value >= 0 ? value : null;
+}
+function percentageOrNull(value) {
+    return typeof value === 'number' && value >= 0 && value <= PERCENTAGE_MAXIMUM ? value : null;
+}
+function readingOf(context, at) {
+    return { v: READING_VERSION, at, windowTokens: positiveIntegerOrNull(context.window), inputTokens: countOrNull(context.tokens), usedPercentage: percentageOrNull(context.percent) };
+}
+async function isAlreadyPublished($, path, reading) {
+    if (!(await $.fs.exists(path)))
+        return false;
+    try {
+        const previous = contextReadingSchema.safeParse(JSON.parse(String(await $.fs.read(path))));
+        return previous.success && previous.data.windowTokens === reading.windowTokens && previous.data.inputTokens === reading.inputTokens;
+    }
+    catch {
+        return false;
+    }
+}
+async function ensureRuntimeIgnore($, root) {
+    const path = `${root}/${RUNTIME_IGNORE_RELATIVE_PATH}`;
+    if (!(await $.fs.exists(path)))
+        await $.fs.write(path, RUNTIME_IGNORE_CONTENT);
+}
+async function reportOnce($) {
+    try {
+        if ((await lastRecordedCode($)) === UNREADABLE_CODE)
+            return;
+    }
+    catch {
+        return;
+    }
+    await reportSafely($, UNREADABLE_CODE);
+}
+async function publishChanged($) {
+    const sessionId = await $.session.id();
+    if (!isReadingSessionId(sessionId))
+        return;
+    const reading = readingOf((await $.session.usage()).context, new Date(await $.clock.now()).toISOString());
+    if (reading.windowTokens === null)
+        return reportOnce($);
+    const root = await $.session.root();
+    const path = `${root}/${contextReadingRelativePath(READING_HARNESS, sessionId)}`;
+    if (await isAlreadyPublished($, path, reading))
+        return;
+    await ensureRuntimeIgnore($, root);
+    await $.fs.write(path, `${JSON.stringify(reading)}\n`);
+}
+export async function publishContextReading($) {
+    try {
+        await publishChanged($);
+    }
+    catch {
+        await reportOnce($);
+    }
+}

package/dist/src/infrastructure/harnesses/claude-code/mod/host.d.ts

@@ -1,3 +1,11 @@
+export type ModUsageContext = {
+    readonly tokens?: number | undefined;
+    readonly window?: number | undefined;
+    readonly percent?: number | undefined;
+};
+export type ModUsage = {
+    readonly context: ModUsageContext;
+};
 export type ModHost = {
     readonly fs: {
         read(path: string): Promise<unknown>;
@@ -22,6 +30,7 @@ export type ModHost = {
         version(): Promise<{
             readonly version: string;
         }>;
+        usage(): Promise<ModUsage>;
     };
     readonly command: {
         run(input: {

package/dist/src/infrastructure/harnesses/claude-code/mod/mod-info.d.ts

@@ -1,4 +1,4 @@
-export declare const MOD_VERSION = "1.0.0";
+export declare const MOD_VERSION = "1.1.0";
 export declare const MOD_LOG_DIR = ".context-brake/runtime/restart/claude-code";
 export declare const CONFIG_FILE = "context-brake.config.json";
 export declare const PERSON_PROMPT_ORIGINS: readonly string[];

package/dist/src/infrastructure/harnesses/claude-code/mod/mod-info.js

@@ -1,5 +1,5 @@
 import { RESTART_LOG_RELATIVE_DIR } from '../../../../core/contracts/restart-log.js';
-export const MOD_VERSION = '1.0.0';
+export const MOD_VERSION = '1.1.0';
 export const MOD_LOG_DIR = `${RESTART_LOG_RELATIVE_DIR}/claude-code`;
 export const CONFIG_FILE = 'context-brake.config.json';
 export const PERSON_PROMPT_ORIGINS = ['composer', 'bridge'];

package/dist/src/infrastructure/harnesses/claude-code/mod/mod-log.d.ts

@@ -1,4 +1,5 @@
 import type { RestartReasonCode } from '../../../../core/contracts/auto-restart.js';
 import type { ModHost } from './host.js';
+export declare function lastRecordedCode($: ModHost): Promise<RestartReasonCode | undefined>;
 export declare function recordLoaded($: ModHost): Promise<void>;
 export declare function recordDecision($: ModHost, code: RestartReasonCode): Promise<void>;

package/dist/src/infrastructure/harnesses/claude-code/mod/mod-log.js

@@ -21,6 +21,9 @@ async function readLog($, path) {
 async function writeLog($, path, log) {
     await $.fs.write(path, `${JSON.stringify(log, null, 2)}\n`);
 }
+export async function lastRecordedCode($) {
+    return (await readLog($, await logPath($))).records.at(-1)?.code;
+}
 export async function recordLoaded($) {
     const path = await logPath($);
     const log = await readLog($, path);

package/dist/src/infrastructure/harnesses/claude-code/mod/register.js

@@ -1,18 +1,23 @@
+import { publishContextReading } from './context-reading.js';
 import { onPromptSubmit, onSessionStart, onToolCall, onTurnComplete, onTurnStart } from './hooks.js';
 export function register(on) {
     on('session.start', async ($, e, next) => {
         await onSessionStart($);
+        await publishContextReading($);
         return next(e);
     });
     on('turn.start', async ($, e, next) => {
         await onTurnStart($);
+        await publishContextReading($);
         return next(e);
     });
-    on('tool.call', async (_$, e, next) => {
+    on('tool.call', async ($, e, next) => {
         onToolCall();
+        await publishContextReading($);
         return next(e);
     });
     on('turn.complete', async ($, e, next) => {
+        await publishContextReading($);
         await onTurnComplete($, e);
         return next(e);
     });

package/dist/src/infrastructure/harnesses/claude-code/mod-reading.d.ts

@@ -0,0 +1,6 @@
+import { type ContextReading } from '../../../core/contracts/context-reading.js';
+import type { MeasuredUsage } from '../../../core/services/session-zone.js';
+import type { TranscriptUsage } from './transcript-usage.js';
+export declare function parseContextReading(text: string): ContextReading | null;
+export declare function readContextReading(sessionId: string | undefined): Promise<ContextReading | null>;
+export declare function freshestMeasured(transcript: TranscriptUsage | null, reading: ContextReading | null): MeasuredUsage | undefined;

package/dist/src/infrastructure/harnesses/claude-code/mod-reading.js

@@ -0,0 +1,37 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { CONTEXT_READING_MAXIMUM_CHARACTERS, contextReadingRelativePath, contextReadingSchema, isReadingSessionId } from '../../../core/contracts/context-reading.js';
+import { resolveClaudeProjectRoot } from './project-root.js';
+export function parseContextReading(text) {
+    if (text.length > CONTEXT_READING_MAXIMUM_CHARACTERS)
+        return null;
+    try {
+        const parsed = contextReadingSchema.safeParse(JSON.parse(text));
+        return parsed.success ? parsed.data : null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readContextReading(sessionId) {
+    if (!isReadingSessionId(sessionId))
+        return null;
+    const path = resolve(await resolveClaudeProjectRoot(), contextReadingRelativePath('claude-code', sessionId));
+    return parseContextReading(await readFile(path, 'utf8').catch(() => ''));
+}
+function isNotOlder(reading, transcript) {
+    return transcript === null || Date.parse(reading.at) >= Date.parse(transcript.at);
+}
+function chooseTokens(transcript, reading) {
+    if (reading !== null && reading.inputTokens !== null && isNotOlder(reading, transcript))
+        return { tokens: reading.inputTokens, at: reading.at };
+    if (transcript === null)
+        return { tokens: null, at: reading?.at };
+    return { tokens: transcript.tokens, at: transcript.at };
+}
+export function freshestMeasured(transcript, reading) {
+    if (transcript === null && reading === null)
+        return undefined;
+    const choice = chooseTokens(transcript, reading);
+    return { tokens: choice.tokens, contextWindow: reading?.windowTokens ?? null, at: choice.at };
+}

package/dist/src/infrastructure/harnesses/claude-code/planner.d.ts

@@ -1,7 +1,8 @@
 import type { AdapterPlan, HarnessContext } from '../../../core/contracts/adapter.js';
 import type { ManagedEntry } from '../../../core/contracts/manifest.js';
+import type { ContextSource } from './context-source.js';
 export declare const CLAUDE_CONFIG_FILE = ".claude/settings.json";
 export declare const CLAUDE_HOOK_FILE = ".claude/hooks/context-brake.mjs";
 export declare function buildClaudeEntries(): ManagedEntry[];
-export declare function planClaudeInstall(context: HarnessContext): Promise<AdapterPlan>;
+export declare function planClaudeInstall(context: HarnessContext, source?: ContextSource): Promise<AdapterPlan>;
 export declare function planClaudeRemove(projectRoot: string): Promise<AdapterPlan>;

package/dist/src/infrastructure/harnesses/claude-code/planner.js

@@ -20,7 +20,7 @@ export function buildClaudeEntries() {
 function invalidConfigPlan(detail) {
     return { harness: 'claude-code', changes: [], conflicts: [{ path: CLAUDE_CONFIG_FILE, code: 'INVALID_HARNESS_CONFIG', detail }], entries: [] };
 }
-export async function planClaudeInstall(context) {
+export async function planClaudeInstall(context, source = 'bridge') {
     const projectRoot = context.projectRoot;
     const realConfig = await resolveChangeTarget(projectRoot, CLAUDE_CONFIG_FILE);
     let content = '{\n}\n';
@@ -42,13 +42,13 @@ export async function planClaudeInstall(context) {
         return invalidConfigPlan(error instanceof Error ? error.message : String(error));
     }
     const assetContent = await loadRuntimeAsset('claude-code-hook.mjs');
-    const statusline = await planStatuslineInstall(context);
+    const statusline = await planStatuslineInstall(context, source);
     const changes = [
         { path: CLAUDE_CONFIG_FILE, realPath: realConfig, kind: 'update', owner: 'harness_entry', content: updated, preview: { summary: 'Register Claude Code hooks' } },
         { path: CLAUDE_HOOK_FILE, realPath: await resolveChangeTarget(projectRoot, CLAUDE_HOOK_FILE), kind: 'create', owner: 'runtime_asset', content: assetContent, preview: { summary: 'Install ContextBrake hook script' } },
         ...statusline.changes,
     ];
-    const autoRestart = await planAutoRestart(context, changes);
+    const autoRestart = await planAutoRestart(context, changes, { forModFirst: source === 'mod' });
     return { harness: 'claude-code', changes: [...autoRestart.changes], conflicts: [...statusline.conflicts, ...autoRestart.conflicts], entries: buildClaudeEntries(), findings: statusline.findings };
 }
 export async function planClaudeRemove(projectRoot) {
@@ -67,6 +67,6 @@ export async function planClaudeRemove(projectRoot) {
     changes.push({ path: CLAUDE_HOOK_FILE, realPath: realHook, kind: 'delete', owner: 'runtime_asset', content: null, preview: { summary: 'Delete ContextBrake hook script' } });
     const statusline = await planStatuslineRemove(projectRoot);
     changes.push(...statusline.changes);
-    const autoRestart = await planAutoRestart({ projectRoot, autoRestart: false }, changes, false);
+    const autoRestart = await planAutoRestart({ projectRoot, autoRestart: false }, changes, { deleteFiles: false });
     return { harness: 'claude-code', changes: [...autoRestart.changes], conflicts: [...statusline.conflicts, ...autoRestart.conflicts], entries: buildClaudeEntries(), assetPaths: [CLAUDE_HOOK_FILE, STATUSLINE_BRIDGE_FILE, ...MOD_FILES] };
 }

package/dist/src/infrastructure/harnesses/claude-code/project-root.d.ts

@@ -0,0 +1,2 @@
+export declare const PROJECT_DIRECTORY_VARIABLE = "CLAUDE_PROJECT_DIR";
+export declare function resolveClaudeProjectRoot(): Promise<string>;

package/dist/src/infrastructure/harnesses/claude-code/project-root.js

@@ -0,0 +1,5 @@
+import { assetProjectRoot, projectRootFromEnvironment } from '../common/runtime-support.js';
+export const PROJECT_DIRECTORY_VARIABLE = 'CLAUDE_PROJECT_DIR';
+export async function resolveClaudeProjectRoot() {
+    return projectRootFromEnvironment([PROJECT_DIRECTORY_VARIABLE]) ?? await assetProjectRoot();
+}

package/dist/src/infrastructure/harnesses/claude-code/runtime.js

@@ -1,14 +1,17 @@
+import { CLAUDE_SKILL_INVOCATION } from './skill-invocation.js';
 import { failureDetail, recordRuntimeFailure } from '../../../core/services/failure-policy.js';
-import { asRecord, assetProjectRoot, characterLength, parsePayload, projectRootFromEnvironment, requireIdentifier, textValue } from '../common/runtime-support.js';
+import { asRecord, characterLength, parsePayload, requireIdentifier, textValue } from '../common/runtime-support.js';
 import { runProcessHook } from '../../runtime/process-hook-host.js';
 import { CLAUDE_CAPABILITIES } from './capabilities.js';
+import { freshestMeasured, readContextReading } from './mod-reading.js';
+import { resolveClaudeProjectRoot } from './project-root.js';
 import { claudePayloadSchema } from './schemas.js';
 import { readTranscriptUsage } from './transcript-usage.js';
 const HARNESS = 'claude-code';
 const ESTIMATION = { baselineTokens: 15000, tokensPerTurn: 150 };
 const WRITE_TOOLS = ['Write', 'Edit', 'MultiEdit', 'NotebookEdit'];
 const SKILL_TOOL = 'Skill';
-export const claudeDescriptor = { harness: HARNESS, capabilities: CLAUDE_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: '/clear' };
+export const claudeDescriptor = { harness: HARNESS, capabilities: CLAUDE_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: '/clear', skillInvocation: CLAUDE_SKILL_INVOCATION };
 function sessionOf(payload) {
     return { harness: HARNESS, sessionId: requireIdentifier(payload.session_id), agentId: payload.agent_id ?? null };
 }
@@ -49,18 +52,20 @@ export async function mapClaudeInput(eventName, payload, errors) {
     if (eventName !== 'PostToolUse')
         return {};
     const data = parsePayload(claudePayloadSchema, payload);
-    const measured = data.agent_id === undefined ? await measuredUsage({ path: data.transcript_path, eventName, errors }) : undefined;
+    const measured = data.agent_id === undefined ? await measuredUsage({ path: data.transcript_path, sessionId: data.session_id, eventName, errors }) : undefined;
     const usage = measured === undefined ? {} : { measured };
     return { ...usage, observedCharacters: characterLength(data.tool_input) + characterLength(data.tool_response) };
 }
 async function measuredUsage(input) {
+    return freshestMeasured(await transcriptUsage(input), await readContextReading(input.sessionId));
+}
+async function transcriptUsage(input) {
     try {
-        const usage = await readTranscriptUsage(input.path);
-        return usage === null ? undefined : { tokens: usage.tokens, contextWindow: null, at: usage.at };
+        return await readTranscriptUsage(input.path);
     }
     catch (error) {
         await recordRuntimeFailure(input.errors, { harness: HARNESS, event: input.eventName, code: 'UNEXPECTED', detail: failureDetail(error) });
-        return undefined;
+        return null;
     }
 }
 export function renderClaudeDecision(decision, eventName) {
@@ -75,7 +80,7 @@ export const claudeAdapter = {
     mapEvent: mapClaudeEvent,
     mapInput: mapClaudeInput,
     renderDecision: renderClaudeDecision,
-    resolveProjectRoot: async () => projectRootFromEnvironment(['CLAUDE_PROJECT_DIR']) ?? await assetProjectRoot(),
+    resolveProjectRoot: resolveClaudeProjectRoot,
 };
 export function runClaudeCodeHook() {
     return runProcessHook(claudeAdapter);

package/dist/src/infrastructure/harnesses/claude-code/skill-folders.d.ts

@@ -0,0 +1 @@
+export declare const CLAUDE_SKILL_FOLDERS: readonly string[];

package/dist/src/infrastructure/harnesses/claude-code/skill-folders.js

@@ -0,0 +1 @@
+export const CLAUDE_SKILL_FOLDERS = ['.claude/skills'];

package/dist/src/infrastructure/harnesses/claude-code/skill-invocation.d.ts

@@ -0,0 +1,2 @@
+import type { SkillInvocationFormat } from '../../../core/contracts/skill-invocation.js';
+export declare const CLAUDE_SKILL_INVOCATION: SkillInvocationFormat;

package/dist/src/infrastructure/harnesses/claude-code/skill-invocation.js

@@ -0,0 +1,2 @@
+import { slashInvocation } from '../../../core/services/skill-invocation.js';
+export const CLAUDE_SKILL_INVOCATION = slashInvocation;

package/dist/src/infrastructure/harnesses/claude-code/statusline-context-window.js

@@ -3,12 +3,25 @@ import { join, resolve } from 'node:path';
 import { parseLedgerLines } from '../../../core/contracts/session-ledger.js';
 import { summarizeStatusline } from '../../../core/services/statusline-summary.js';
 import { LEDGER_FILE_EXTENSION, sessionsDirectory } from '../../runtime/runtime-paths.js';
+import { isModInstalled } from './auto-restart-diagnostics.js';
+import { latestContextReading } from './context-readings-scan.js';
 import { CLAUDE_LOCAL_SETTINGS_FILE, commandOf, readSettings } from './statusline-settings.js';
 import { readStatuslineState } from './statusline-state.js';
 const ALL_LINES = -1;
 export async function readClaudeContextWindow(projectRoot) {
-    const lastWindowTokens = await lastRecordedWindow(projectRoot);
-    return { bridge: await bridgeState(projectRoot), source: lastWindowTokens === null ? 'contextWindowCeiling' : 'statusline', lastWindowTokens };
+    const reading = await latestContextReading(projectRoot);
+    const lastWindowTokens = reading?.windowTokens ?? await lastRecordedWindow(projectRoot);
+    return { bridge: await bridgeState(projectRoot), mod: await modState(projectRoot, reading), source: sourceOf(reading, lastWindowTokens), lastWindowTokens };
+}
+function sourceOf(reading, lastWindowTokens) {
+    if (reading !== null)
+        return 'mod';
+    return lastWindowTokens === null ? 'contextWindowCeiling' : 'statusline';
+}
+async function modState(projectRoot, reading) {
+    if (reading !== null)
+        return 'reporting';
+    return (await isModInstalled(projectRoot)) ? 'installed' : 'absent';
 }
 export async function localStatuslineCommand(projectRoot) {
     const local = await readSettings(resolve(projectRoot, CLAUDE_LOCAL_SETTINGS_FILE));