context-brake 0.0.0-stage → 1.1.0

package/dist/src/infrastructure/harnesses/common/change-target.js

@@ -0,0 +1,40 @@
+import { realpath } from 'node:fs/promises';
+import { basename, dirname, resolve } from 'node:path';
+import { assertWithinRepository, normalizeSeparators } from '../../storage/path-boundary.js';
+async function findExistingAncestor(startPath) {
+    let current = startPath;
+    const missing = [];
+    while (true) {
+        missing.unshift(basename(current));
+        const parent = dirname(current);
+        if (parent === current) {
+            return { ancestor: current, missing };
+        }
+        current = parent;
+        try {
+            const canonical = await realpath(current);
+            return { ancestor: canonical, missing };
+        }
+        catch {
+            /* climb up */
+        }
+    }
+}
+async function resolveCanonicalTarget(fullPath) {
+    try {
+        const existing = await realpath(fullPath);
+        return normalizeSeparators(existing);
+    }
+    catch {
+        const { ancestor, missing } = await findExistingAncestor(fullPath);
+        const target = missing.length > 0 ? resolve(ancestor, ...missing) : ancestor;
+        return normalizeSeparators(target);
+    }
+}
+export async function resolveChangeTarget(projectRoot, targetPath) {
+    await assertWithinRepository(projectRoot, targetPath);
+    const fullPath = resolve(projectRoot, targetPath);
+    const canonical = await resolveCanonicalTarget(fullPath);
+    await assertWithinRepository(projectRoot, canonical);
+    return canonical;
+}

package/dist/src/infrastructure/harnesses/common/codex-hooks-updater.d.ts

@@ -0,0 +1,13 @@
+export declare const CODEX_HOOK_FILE = ".codex/hooks/context-brake.mjs";
+export declare const CODEX_EVENTS: readonly ["PostToolUse", "SessionStart", "Stop"];
+export type CodexHook = {
+    type: string;
+    command: string;
+    commandWindows?: string;
+};
+export type CodexGroup = {
+    matcher: string;
+    hooks: CodexHook[];
+};
+export declare function isCodexOwnedHandler(handler: unknown): boolean;
+export declare function updateCodexHooks(content: string, clear: boolean, buildGroup: (event: string) => CodexGroup): string;

package/dist/src/infrastructure/harnesses/common/codex-hooks-updater.js

@@ -0,0 +1,79 @@
+import { findNodeAtLocation, getNodeValue } from 'jsonc-parser';
+import { removeOwnedFromOtherEvents } from './hook-event-cleanup.js';
+import { appendJsonArrayItem, parseAndValidateJson, removeJsonArrayItem, removeJsonProperty, setJsonProperty } from '../../storage/json-document-editor.js';
+export const CODEX_HOOK_FILE = '.codex/hooks/context-brake.mjs';
+export const CODEX_EVENTS = ['PostToolUse', 'SessionStart', 'Stop'];
+export function isCodexOwnedHandler(handler) {
+    if (typeof handler !== 'object' || handler === null)
+        return false;
+    const h = handler;
+    return (typeof h.command === 'string' && h.command.includes(CODEX_HOOK_FILE)) ||
+        (typeof h.commandWindows === 'string' && h.commandWindows.includes(CODEX_HOOK_FILE));
+}
+function isGroupPurelyOwned(group) {
+    if (typeof group !== 'object' || group === null)
+        return false;
+    const g = group;
+    return Array.isArray(g.hooks) && g.hooks.length > 0 && g.hooks.every(isCodexOwnedHandler);
+}
+function groupHasOwnedHandler(group) {
+    if (typeof group !== 'object' || group === null)
+        return false;
+    const g = group;
+    return Array.isArray(g.hooks) && g.hooks.some(isCodexOwnedHandler);
+}
+function groupMatchesDesired(group, desired) {
+    if (typeof group !== 'object' || group === null)
+        return false;
+    const g = group;
+    if (g.matcher !== desired.matcher || !Array.isArray(g.hooks) || g.hooks.length !== 1)
+        return false;
+    const h = g.hooks[0];
+    return h.type === desired.hooks[0].type && h.command === desired.hooks[0].command && h.commandWindows === desired.hooks[0].commandWindows;
+}
+function removeOwnedFromEvent(content, event) {
+    let text = content;
+    while (true) {
+        const next = removeJsonArrayItem(text, ['hooks', event], isGroupPurelyOwned);
+        if (next === text)
+            break;
+        text = next;
+    }
+    const tree = parseAndValidateJson(text);
+    const eventNode = findNodeAtLocation(tree, ['hooks', event]);
+    if (!eventNode)
+        return text;
+    const groups = Array.isArray(getNodeValue(eventNode)) ? getNodeValue(eventNode) : [];
+    for (let i = 0; i < groups.length; i++) {
+        while (true) {
+            const next = removeJsonArrayItem(text, ['hooks', event, i, 'hooks'], isCodexOwnedHandler);
+            if (next === text)
+                break;
+            text = next;
+        }
+    }
+    return groups.length === 0 ? removeJsonProperty(text, ['hooks', event]) : text;
+}
+export function updateCodexHooks(content, clear, buildGroup) {
+    let text = content;
+    for (const event of CODEX_EVENTS) {
+        const desired = buildGroup(event);
+        const tree = parseAndValidateJson(text);
+        const eventNode = findNodeAtLocation(tree, ['hooks', event]);
+        if (!eventNode) {
+            if (!clear)
+                text = setJsonProperty(text, ['hooks', event], [desired]);
+            continue;
+        }
+        const groups = Array.isArray(getNodeValue(eventNode)) ? getNodeValue(eventNode) : [];
+        const ownedGroups = groups.filter(groupHasOwnedHandler);
+        if (!clear && ownedGroups.length === 1 && groupMatchesDesired(ownedGroups[0], desired)) {
+            continue;
+        }
+        text = removeOwnedFromEvent(text, event);
+        if (!clear) {
+            text = appendJsonArrayItem(text, ['hooks', event], desired);
+        }
+    }
+    return removeOwnedFromOtherEvents(text, CODEX_EVENTS, isCodexOwnedHandler);
+}

package/dist/src/infrastructure/harnesses/common/config-origin.d.ts

@@ -0,0 +1,10 @@
+import type { AdapterPlan } from '../../../core/contracts/adapter.js';
+import type { InstallationManifest } from '../../../core/contracts/manifest.js';
+export type ScalarDefaults = Readonly<Record<string, string | number | boolean>>;
+export type OriginTarget = {
+    readonly path: string;
+    readonly manifest?: InstallationManifest | null | undefined;
+    readonly defaults?: ScalarDefaults;
+};
+export declare function attachConfigOrigin(plan: AdapterPlan, target: OriginTarget): Promise<AdapterPlan>;
+export declare function applyConfigOrigin(plan: AdapterPlan, target: OriginTarget): AdapterPlan;

package/dist/src/infrastructure/harnesses/common/config-origin.js

@@ -0,0 +1,52 @@
+import { readFile } from 'node:fs/promises';
+import { findNodeAtLocation, getNodeValue, parseTree } from 'jsonc-parser';
+import { parseAndValidateJson, removeJsonProperty } from '../../storage/json-document-editor.js';
+function topLevelKeys(text) {
+    const root = parseTree(text, [], { disallowComments: false });
+    if (root?.type !== 'object')
+        return [];
+    return (root.children ?? []).map((property) => String(property.children?.[0]?.value));
+}
+function isEmptyContainer(value) {
+    if (Array.isArray(value))
+        return value.length === 0;
+    return typeof value === 'object' && value !== null && Object.keys(value).length === 0;
+}
+function removeAddedKeys(text, origin, defaults) {
+    return origin.addedKeys.reduce((current, key) => {
+        const node = findNodeAtLocation(parseAndValidateJson(current), [key]);
+        if (!node)
+            return current;
+        const value = getNodeValue(node);
+        return isEmptyContainer(value) || value === defaults[key] ? removeJsonProperty(current, [key]) : current;
+    }, text);
+}
+function restoreChange(change, origin, defaults) {
+    if (change.path !== origin.path || change.kind !== 'update' || change.content === null)
+        return change;
+    const content = removeAddedKeys(change.content, origin, defaults);
+    if (origin.created && /^\s*\{\s*\}\s*$/.test(content))
+        return { ...change, kind: 'delete', content: null, preview: { summary: `Delete ${origin.path}, created by init` } };
+    return { ...change, content };
+}
+function recordConfigOrigin(target, original, installed) {
+    const path = target.path;
+    const recorded = target.manifest?.configOrigins?.find((origin) => origin.path === path);
+    if (recorded)
+        return recorded;
+    const before = new Set(original === null ? [] : topLevelKeys(original));
+    return { path, created: original === null, addedKeys: topLevelKeys(installed).filter((key) => !before.has(key)) };
+}
+export async function attachConfigOrigin(plan, target) {
+    const change = plan.changes.find((item) => item.path === target.path);
+    if (!change || change.content === null)
+        return plan;
+    const original = await readFile(change.realPath, 'utf8').catch(() => null);
+    return { ...plan, configOrigins: [recordConfigOrigin(target, original, change.content)] };
+}
+export function applyConfigOrigin(plan, target) {
+    const origin = target.manifest?.configOrigins?.find((item) => item.path === target.path);
+    if (!origin)
+        return plan;
+    return { ...plan, changes: plan.changes.map((change) => restoreChange(change, origin, target.defaults ?? {})) };
+}

package/dist/src/infrastructure/harnesses/common/cursor-hooks-updater.d.ts

@@ -0,0 +1,3 @@
+export declare const CURSOR_HOOK_FILE = ".cursor/hooks/context-brake.mjs";
+export declare function isCursorOwned(entry: unknown): boolean;
+export declare function updateCursorHooks(content: string, clear: boolean): string;

package/dist/src/infrastructure/harnesses/common/cursor-hooks-updater.js

@@ -0,0 +1,63 @@
+import { findNodeAtLocation, getNodeValue } from 'jsonc-parser';
+import { removeOwnedFromOtherEvents } from './hook-event-cleanup.js';
+import { appendJsonArrayItem, parseAndValidateJson, removeJsonArrayItem, removeJsonProperty, setJsonProperty } from '../../storage/json-document-editor.js';
+export const CURSOR_HOOK_FILE = '.cursor/hooks/context-brake.mjs';
+const CURSOR_EVENTS = ['postToolUse', 'sessionStart', 'preCompact'];
+const CURSOR_DESIRED = {
+    postToolUse: { command: `node ${CURSOR_HOOK_FILE} postToolUse` },
+    sessionStart: { command: `node ${CURSOR_HOOK_FILE} sessionStart` },
+    preCompact: { command: `node ${CURSOR_HOOK_FILE} preCompact` },
+};
+export function isCursorOwned(entry) {
+    if (typeof entry !== 'object' || entry === null)
+        return false;
+    const cmd = entry.command;
+    return typeof cmd === 'string' && cmd.includes(CURSOR_HOOK_FILE);
+}
+function matchesDesired(entry, desired) {
+    if (typeof entry !== 'object' || entry === null)
+        return false;
+    return entry.command === desired.command;
+}
+function isEmptyEventArray(text, event) {
+    const tree = parseAndValidateJson(text);
+    const eventNode = findNodeAtLocation(tree, ['hooks', event]);
+    if (!eventNode)
+        return false;
+    const value = getNodeValue(eventNode);
+    return Array.isArray(value) && value.length === 0;
+}
+function updateCursorEvent(text, event, clear) {
+    const desired = CURSOR_DESIRED[event];
+    const tree = parseAndValidateJson(text);
+    const eventNode = findNodeAtLocation(tree, ['hooks', event]);
+    if (!eventNode) {
+        return clear ? text : setJsonProperty(text, ['hooks', event], [desired]);
+    }
+    const val = getNodeValue(eventNode);
+    const arr = Array.isArray(val) ? val : [];
+    const owned = arr.filter(isCursorOwned);
+    if (!clear && owned.length === 1 && matchesDesired(owned[0], desired))
+        return text;
+    let cur = text;
+    while (true) {
+        const next = removeJsonArrayItem(cur, ['hooks', event], isCursorOwned);
+        if (next === cur)
+            break;
+        cur = next;
+    }
+    if (!clear)
+        return appendJsonArrayItem(cur, ['hooks', event], desired);
+    return isEmptyEventArray(cur, event) ? removeJsonProperty(cur, ['hooks', event]) : cur;
+}
+export function updateCursorHooks(content, clear) {
+    let text = content;
+    const rootNode = parseAndValidateJson(text);
+    if (!clear && !findNodeAtLocation(rootNode, ['version'])) {
+        text = setJsonProperty(text, ['version'], 1);
+    }
+    for (const event of CURSOR_EVENTS) {
+        text = updateCursorEvent(text, event, clear);
+    }
+    return removeOwnedFromOtherEvents(text, CURSOR_EVENTS, isCursorOwned);
+}

package/dist/src/infrastructure/harnesses/common/diagnostic-helpers.d.ts

@@ -0,0 +1,7 @@
+import type { DiagnosticFinding } from '../../../core/contracts/diagnostics.js';
+import type { HarnessId } from '../../../core/contracts/harness.js';
+export declare function createIntegrationMissingFinding(harness: HarnessId, path: string): DiagnosticFinding;
+export declare function createAssetMissingFinding(harness: HarnessId, path: string): DiagnosticFinding;
+export declare function createInvalidConfigFinding(harness: HarnessId, path: string, detail: string): DiagnosticFinding;
+export declare function createLimitationFinding(harness: HarnessId, code: string, impact: string): DiagnosticFinding;
+export declare function createCodexRootNotGitWarning(): DiagnosticFinding;

package/dist/src/infrastructure/harnesses/common/diagnostic-helpers.js

@@ -0,0 +1,60 @@
+export function createIntegrationMissingFinding(harness, path) {
+    return {
+        code: 'INTEGRATION_MISSING',
+        severity: 'error',
+        scope: 'harness',
+        harness,
+        path,
+        message: `The ${harness} integration is missing from ${path}.`,
+        impact: 'ContextBrake cannot stop or annotate tool calls in this harness.',
+        remediation: `Run context-brake init --harness ${harness} --yes.`,
+    };
+}
+export function createAssetMissingFinding(harness, path) {
+    return {
+        code: 'ASSET_MISSING',
+        severity: 'error',
+        scope: 'harness',
+        harness,
+        path,
+        message: `The runtime asset ${path} for ${harness} is missing.`,
+        impact: 'The harness cannot execute the ContextBrake hook or plugin.',
+        remediation: `Run context-brake init --harness ${harness} --yes.`,
+    };
+}
+export function createInvalidConfigFinding(harness, path, detail) {
+    return {
+        code: 'INVALID_HARNESS_CONFIG',
+        severity: 'error',
+        scope: 'file',
+        harness,
+        path,
+        message: `Configuration file ${path} for ${harness} is invalid: ${detail}`,
+        impact: 'ContextBrake cannot safely read or modify this configuration.',
+        remediation: `Fix syntax or structure errors in ${path}.`,
+    };
+}
+export function createLimitationFinding(harness, code, impact) {
+    return {
+        code,
+        severity: 'warning',
+        scope: 'harness',
+        harness,
+        path: null,
+        message: `Harness ${harness} has an active limitation.`,
+        impact,
+        remediation: null,
+    };
+}
+export function createCodexRootNotGitWarning() {
+    return {
+        code: 'CODEX_ROOT_NOT_GIT_TOPLEVEL',
+        severity: 'warning',
+        scope: 'harness',
+        harness: 'codex-cli',
+        path: null,
+        message: 'The project root is not a git repository root, so Codex CLI hooks cannot locate the ContextBrake hook script.',
+        impact: 'Codex CLI reports a hook failure on every event and runs the tool call without ContextBrake.',
+        remediation: 'Run context-brake init from the git repository root, or run git init here.',
+    };
+}

package/dist/src/infrastructure/harnesses/common/hook-event-cleanup.d.ts

@@ -0,0 +1,3 @@
+export type OwnedHandlerPredicate = (handler: unknown) => boolean;
+export declare function removeOwnedFromEvent(text: string, event: string, isOwned: OwnedHandlerPredicate): string;
+export declare function removeOwnedFromOtherEvents(text: string, currentEvents: readonly string[], isOwned: OwnedHandlerPredicate): string;

package/dist/src/infrastructure/harnesses/common/hook-event-cleanup.js

@@ -0,0 +1,50 @@
+import { findNodeAtLocation, getNodeValue } from 'jsonc-parser';
+import { parseAndValidateJson, removeJsonArrayItem, removeJsonProperty } from '../../storage/json-document-editor.js';
+function groupHandlers(item) {
+    if (typeof item !== 'object' || item === null)
+        return null;
+    const handlers = item.hooks;
+    return Array.isArray(handlers) ? handlers : null;
+}
+function isRemovableItem(item, isOwned) {
+    const handlers = groupHandlers(item);
+    if (handlers === null)
+        return isOwned(item);
+    return handlers.length > 0 && handlers.every(isOwned);
+}
+function hasOwnedHandler(item, isOwned) {
+    const handlers = groupHandlers(item);
+    if (handlers === null)
+        return isOwned(item);
+    return handlers.some(isOwned);
+}
+function readEventItems(text, event) {
+    const node = findNodeAtLocation(parseAndValidateJson(text), ['hooks', event]);
+    const value = node ? getNodeValue(node) : undefined;
+    return Array.isArray(value) ? value : [];
+}
+function removeRepeatedly(text, remove) {
+    const next = remove(text);
+    return next === text ? text : removeRepeatedly(next, remove);
+}
+export function removeOwnedFromEvent(text, event, isOwned) {
+    const path = ['hooks', event];
+    const withoutGroups = removeRepeatedly(text, (current) => removeJsonArrayItem(current, path, (item) => isRemovableItem(item, isOwned)));
+    const remaining = readEventItems(withoutGroups, event).length;
+    let cleaned = withoutGroups;
+    for (let index = 0; index < remaining; index++) {
+        cleaned = removeRepeatedly(cleaned, (current) => removeJsonArrayItem(current, [...path, index, 'hooks'], isOwned));
+    }
+    return remaining === 0 ? removeJsonProperty(cleaned, path) : cleaned;
+}
+export function removeOwnedFromOtherEvents(text, currentEvents, isOwned) {
+    const hooksNode = findNodeAtLocation(parseAndValidateJson(text), ['hooks']);
+    const hooks = hooksNode ? getNodeValue(hooksNode) : undefined;
+    if (typeof hooks !== 'object' || hooks === null || Array.isArray(hooks))
+        return text;
+    const retired = Object.keys(hooks).filter((event) => !currentEvents.includes(event));
+    return retired.reduce((acc, event) => {
+        const isOwnedHere = readEventItems(acc, event).some((item) => hasOwnedHandler(item, isOwned));
+        return isOwnedHere ? removeOwnedFromEvent(acc, event, isOwned) : acc;
+    }, text);
+}

package/dist/src/infrastructure/harnesses/common/in-process-restart-log.d.ts

@@ -0,0 +1,9 @@
+import type { RestartReasonCode } from '../../../core/contracts/auto-restart.js';
+import type { HarnessId } from '../../../core/contracts/harness.js';
+export type RestartLogTarget = {
+    readonly root: string;
+    readonly harness: HarnessId;
+    readonly sessionId: string;
+};
+export declare function recordInProcessLoaded(target: RestartLogTarget): Promise<void>;
+export declare function recordInProcessDecision(target: RestartLogTarget, code: RestartReasonCode, at: Date): Promise<void>;

package/dist/src/infrastructure/harnesses/common/in-process-restart-log.js

@@ -0,0 +1,36 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { RESTART_LOG_RELATIVE_DIR, RESTART_LOG_VERSION, restartLogSchema, UNKNOWN_HARNESS_VERSION } from '../../../core/contracts/restart-log.js';
+import { appendLogRecord, buildLogRecord } from '../../../core/services/auto-restart-notices.js';
+import { ensureRuntimeDirectory, isMissingFileError } from '../../runtime/runtime-paths.js';
+import { RESTART_COMPONENT_VERSION } from './in-process-restart-state.js';
+const LINE_END = '\n';
+function logPath(target) {
+    return join(target.root, RESTART_LOG_RELATIVE_DIR, target.harness, `${target.sessionId}.json`);
+}
+function emptyLog(harness) {
+    return { v: RESTART_LOG_VERSION, harness, componentVersion: RESTART_COMPONENT_VERSION, harnessVersion: UNKNOWN_HARNESS_VERSION, records: [] };
+}
+async function readLog(target) {
+    try {
+        const parsed = restartLogSchema.safeParse(JSON.parse(await readFile(logPath(target), 'utf8')));
+        return parsed.success ? parsed.data : emptyLog(target.harness);
+    }
+    catch (error) {
+        if (isMissingFileError(error) || error instanceof SyntaxError)
+            return emptyLog(target.harness);
+        throw error;
+    }
+}
+async function writeLog(target, log) {
+    await ensureRuntimeDirectory(target.root);
+    await mkdir(join(target.root, RESTART_LOG_RELATIVE_DIR, target.harness), { recursive: true });
+    await writeFile(logPath(target), JSON.stringify({ ...log, componentVersion: RESTART_COMPONENT_VERSION }, null, 2) + LINE_END, 'utf8');
+}
+export async function recordInProcessLoaded(target) {
+    await writeLog(target, await readLog(target));
+}
+export async function recordInProcessDecision(target, code, at) {
+    const log = await readLog(target);
+    await writeLog(target, { ...log, records: [...appendLogRecord(log.records, buildLogRecord(code, at.toISOString()))] });
+}

package/dist/src/infrastructure/harnesses/common/in-process-restart-state.d.ts

@@ -0,0 +1,11 @@
+import { type RestartGuardStore, type StandDownFacts } from '../../../core/contracts/restart-host.js';
+import type { RestartSettings } from '../../../core/services/restart-flow.js';
+export declare const RESTART_COMMAND = "context-brake-restart";
+export declare const RESTART_COMPONENT_VERSION = "1.0.0";
+export declare function memoryGuardStore(root: string): RestartGuardStore;
+export declare function startTurn(root: string, at: number): void;
+export declare function countToolCall(root: string): void;
+export declare function turnStartedAt(root: string): number | undefined;
+export declare function takeToolCalls(root: string): number;
+export declare function inProcessStandDown(interactive: boolean): StandDownFacts;
+export declare function readRestartSettings(root: string): Promise<RestartSettings | undefined>;

package/dist/src/infrastructure/harnesses/common/in-process-restart-state.js

@@ -0,0 +1,50 @@
+import { readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { configurationSchema } from '../../../core/contracts/configuration.js';
+import { IDLE_GUARD_STATE } from '../../../core/contracts/restart-host.js';
+import { restartMode } from '../../../core/services/restart-mode.js';
+import { isMissingFileError } from '../../runtime/runtime-paths.js';
+export const RESTART_COMMAND = 'context-brake-restart';
+export const RESTART_COMPONENT_VERSION = '1.0.0';
+const CONFIG_FILE = 'context-brake.config.json';
+const SWITCHED_OFF = '0';
+const guards = new Map();
+const turnStarts = new Map();
+const turnToolCalls = new Map();
+export function memoryGuardStore(root) {
+    return {
+        read: async () => guards.get(root) ?? IDLE_GUARD_STATE,
+        write: async (state) => { guards.set(root, state); },
+    };
+}
+export function startTurn(root, at) {
+    turnStarts.set(root, at);
+    turnToolCalls.set(root, 0);
+}
+export function countToolCall(root) {
+    turnToolCalls.set(root, (turnToolCalls.get(root) ?? 0) + 1);
+}
+export function turnStartedAt(root) {
+    return turnStarts.get(root);
+}
+export function takeToolCalls(root) {
+    const calls = turnToolCalls.get(root) ?? 0;
+    turnToolCalls.set(root, 0);
+    return calls;
+}
+export function inProcessStandDown(interactive) {
+    return { disabledByEnv: process.env['CONTEXT_BRAKE_AUTO_RESTART'] === SWITCHED_OFF, interactive };
+}
+export async function readRestartSettings(root) {
+    try {
+        const parsed = configurationSchema.safeParse(JSON.parse(await readFile(join(root, CONFIG_FILE), 'utf8')));
+        if (!parsed.success || parsed.data.autoRestart === undefined)
+            return undefined;
+        return { maxConsecutive: parsed.data.autoRestart.maxConsecutiveRestarts, mode: restartMode(parsed.data) };
+    }
+    catch (error) {
+        if (isMissingFileError(error) || error instanceof SyntaxError)
+            return undefined;
+        throw error;
+    }
+}

package/dist/src/infrastructure/harnesses/common/in-process-restart-support.d.ts

@@ -0,0 +1,13 @@
+import type { HarnessId } from '../../../core/contracts/harness.js';
+export type RestartSessionContext = {
+    readonly cwd?: string | undefined;
+    readonly sessionManager?: {
+        readonly getSessionId?: () => string;
+    } | undefined;
+    readonly ui?: {
+        readonly notify?: (message: string, level?: string) => void;
+    } | undefined;
+};
+export declare function sessionIdOf(context: RestartSessionContext): string;
+export declare function recordRestartLoaded(context: RestartSessionContext, harness: HarnessId): Promise<void>;
+export declare function reportFailures(context: RestartSessionContext, step: () => Promise<void>): Promise<void>;

package/dist/src/infrastructure/harnesses/common/in-process-restart-support.js

@@ -0,0 +1,15 @@
+import { renderRestartNotice } from '../../../core/services/auto-restart-notices.js';
+import { recordInProcessLoaded } from './in-process-restart-log.js';
+import { readRestartSettings } from './in-process-restart-state.js';
+import { textValue } from './runtime-support.js';
+export function sessionIdOf(context) {
+    return context.sessionManager?.getSessionId?.() ?? 'unknown';
+}
+export async function recordRestartLoaded(context, harness) {
+    const root = textValue(context.cwd);
+    if (root !== null && (await readRestartSettings(root)) !== undefined)
+        await recordInProcessLoaded({ root, harness, sessionId: sessionIdOf(context) });
+}
+export function reportFailures(context, step) {
+    return step().catch(() => context.ui?.notify?.(renderRestartNotice('ERROR_INTERNAL') ?? '', 'info'));
+}

package/dist/src/infrastructure/harnesses/common/in-process-support.d.ts

@@ -0,0 +1,18 @@
+import type { RuntimeDecision, RuntimeDescriptor, RuntimeEvent } from '../../../core/contracts/runtime.js';
+import type { Clock } from '../../../core/contracts/session-ledger.js';
+import type { RuntimeInput } from '../../../core/services/brake-engine.js';
+import { type InProcessRuntime } from '../../runtime/in-process-host.js';
+export type InProcessRuntimeResolver = (projectRoot: string) => Promise<InProcessRuntime>;
+export type MeasuredUsageInput = {
+    readonly tokens: number | null;
+    readonly contextWindow: number;
+};
+export declare function createRuntimeResolver(descriptor: RuntimeDescriptor, clock?: Clock): InProcessRuntimeResolver;
+export type InProcessEventInput = {
+    readonly resolver: InProcessRuntimeResolver;
+    readonly projectRoot: string | null;
+    readonly event: RuntimeEvent;
+    readonly engineInput?: RuntimeInput | undefined;
+};
+export declare function runInProcessEvent(input: InProcessEventInput): Promise<RuntimeDecision>;
+export declare function measuredUsageFrom(value: unknown): MeasuredUsageInput | undefined;

package/dist/src/infrastructure/harnesses/common/in-process-support.js

@@ -0,0 +1,40 @@
+import { failureDetail, failureErrorCode, resolveFailure } from '../../../core/services/failure-policy.js';
+import { createInProcessRuntime } from '../../runtime/in-process-host.js';
+import { createRuntimePorts, loadRuntimeConfiguration, systemClock } from '../../runtime/runtime-composition.js';
+import { asRecord } from './runtime-support.js';
+export function createRuntimeResolver(descriptor, clock = systemClock) {
+    let currentRoot = null;
+    let current = null;
+    return (projectRoot) => {
+        if (current === null || currentRoot !== projectRoot) {
+            currentRoot = projectRoot;
+            current = loadRuntimeConfiguration(projectRoot)
+                .then((config) => createInProcessRuntime({ projectRoot, descriptor, config, clock }))
+                .catch((error) => { current = null; throw error; });
+        }
+        return current;
+    };
+}
+export async function runInProcessEvent(input) {
+    if (input.projectRoot === null)
+        return { kind: 'neutral' };
+    try {
+        const runtime = await input.resolver(input.projectRoot);
+        return await runtime.handle(input.event, input.engineInput);
+    }
+    catch (error) {
+        return await resolveInProcessFailure(input.projectRoot, input.event, error);
+    }
+}
+export function measuredUsageFrom(value) {
+    const record = asRecord(value);
+    const contextWindow = record?.['contextWindow'];
+    if (typeof contextWindow !== 'number' || contextWindow <= 0)
+        return undefined;
+    const tokens = record?.['tokens'];
+    return { tokens: typeof tokens === 'number' ? tokens : null, contextWindow };
+}
+async function resolveInProcessFailure(projectRoot, event, error) {
+    const ports = createRuntimePorts({ projectRoot, config: null, clock: systemClock });
+    return await resolveFailure({ event, code: failureErrorCode(error), detail: failureDetail(error), config: null, descriptor: null, ledger: ports.ledger, errors: ports.errors });
+}

package/dist/src/infrastructure/harnesses/common/jsonl-tail-reader.d.ts

@@ -0,0 +1,6 @@
+export type LineReader<T> = (line: string) => T | null;
+export declare class TranscriptUnreadableError extends Error {
+    constructor(options?: ErrorOptions);
+}
+export declare function readLatestLine<T>(path: string | undefined, readLine: LineReader<T>): Promise<T | null>;
+export declare function parseJsonLine(line: string): unknown;