context-brake 0.0.0-stage → 1.0.0

package/dist/src/infrastructure/harnesses/cursor/schemas.d.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod/mini';
+export declare const cursorHookCommandSchema: z.ZodMiniObject<{
+    command: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    failClosed: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$loose>;
+export declare const cursorHooksFileSchema: z.ZodMiniObject<{
+    version: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    hooks: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniObject<{
+        command: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        failClosed: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+    }, z.core.$loose>>>>;
+}, z.core.$loose>;
+export declare const cursorPayloadSchema: z.ZodMiniObject<{
+    conversation_id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    session_id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tool_name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tool_input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    tool_output: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    tool_use_id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    trigger: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    context_usage_percent: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    context_tokens: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    context_window_size: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    is_first_compaction: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$loose>;
+export declare const cursorPostToolUsePayloadSchema: z.ZodMiniObject<{
+    conversation_id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    session_id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tool_name: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    tool_input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    tool_output: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    tool_use_id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    trigger: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    context_usage_percent: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    context_tokens: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    context_window_size: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    is_first_compaction: z.ZodMiniOptional<z.ZodMiniBoolean<boolean>>;
+}, z.core.$loose>;
+export type CursorPayload = z.infer<typeof cursorPayloadSchema>;

package/dist/src/infrastructure/harnesses/cursor/schemas.js

@@ -0,0 +1,23 @@
+import { z } from 'zod/mini';
+export const cursorHookCommandSchema = z.looseObject({
+    command: z.optional(z.string()),
+    failClosed: z.optional(z.boolean()),
+});
+export const cursorHooksFileSchema = z.looseObject({
+    version: z.optional(z.number()),
+    hooks: z.optional(z.record(z.string(), z.array(cursorHookCommandSchema))),
+});
+export const cursorPayloadSchema = z.looseObject({
+    conversation_id: z.optional(z.string()),
+    session_id: z.optional(z.string()),
+    tool_name: z.optional(z.string()),
+    tool_input: z.optional(z.unknown()),
+    tool_output: z.optional(z.unknown()),
+    tool_use_id: z.optional(z.string()),
+    trigger: z.optional(z.string()),
+    context_usage_percent: z.optional(z.number()),
+    context_tokens: z.optional(z.number()),
+    context_window_size: z.optional(z.number()),
+    is_first_compaction: z.optional(z.boolean()),
+});
+export const cursorPostToolUsePayloadSchema = cursorPayloadSchema;

package/dist/src/infrastructure/harnesses/github-copilot-cli/adapter.d.ts

@@ -0,0 +1,14 @@
+import type { BenchmarkFixture, HarnessAdapter, HarnessContext } from '../../../core/contracts/adapter.js';
+import type { DiagnosticFinding } from '../../../core/contracts/diagnostics.js';
+import type { CapabilityProfile, DetectionEvidence, VersionProbe } from '../../../core/contracts/harness.js';
+export declare class CopilotAdapter implements HarnessAdapter {
+    readonly id = "github-copilot-cli";
+    readonly executionModel: "process";
+    capabilityProfile(version?: VersionProbe): CapabilityProfile;
+    detect(context: HarnessContext): Promise<readonly DetectionEvidence[]>;
+    probeVersion(context: HarnessContext): Promise<VersionProbe>;
+    planInstall(context: HarnessContext): Promise<import("../../../core/contracts/adapter.js").AdapterPlan>;
+    planRemove(context: HarnessContext): Promise<import("../../../core/contracts/adapter.js").AdapterPlan>;
+    diagnose(context: HarnessContext): Promise<readonly DiagnosticFinding[]>;
+    benchmarkFixture(): BenchmarkFixture;
+}

package/dist/src/infrastructure/harnesses/github-copilot-cli/adapter.js

@@ -0,0 +1,69 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+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 { pathExists } from '../common/path-helpers.js';
+import { probeExecutableVersion } from '../common/version-probes.js';
+import { COPILOT_CAPABILITIES } from './capabilities.js';
+import { COPILOT_EXECUTABLES, detectCopilot } from './detector.js';
+import { COPILOT_CONFIG_FILE, COPILOT_HOOK_FILE, planCopilotInstall, planCopilotRemove } from './planner.js';
+export class CopilotAdapter {
+    id = 'github-copilot-cli';
+    executionModel = 'process';
+    capabilityProfile(version) {
+        return deriveSupportProfile({ harness: this.id, capabilities: COPILOT_CAPABILITIES, version });
+    }
+    detect(context) {
+        return detectCopilot(context.projectRoot, context.userHome);
+    }
+    probeVersion(context) {
+        return probeExecutableVersion(context.runner, COPILOT_EXECUTABLES);
+    }
+    planInstall(context) {
+        return planCopilotInstall(context.projectRoot);
+    }
+    planRemove(context) {
+        return planCopilotRemove(context.projectRoot);
+    }
+    async diagnose(context) {
+        const findings = [];
+        const configPath = resolve(context.projectRoot, COPILOT_CONFIG_FILE);
+        const hookPath = resolve(context.projectRoot, COPILOT_HOOK_FILE);
+        if (!(await pathExists(configPath))) {
+            findings.push(createIntegrationMissingFinding(this.id, COPILOT_CONFIG_FILE));
+        }
+        else {
+            try {
+                const raw = await readFile(configPath, 'utf8');
+                const validation = validateJsonDocument(raw);
+                if (!validation.valid) {
+                    findings.push(createInvalidConfigFinding(this.id, COPILOT_CONFIG_FILE, validation.errors.join('; ')));
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                findings.push(createInvalidConfigFinding(this.id, COPILOT_CONFIG_FILE, msg));
+            }
+        }
+        if (!(await pathExists(hookPath)))
+            findings.push(createAssetMissingFinding(this.id, COPILOT_HOOK_FILE));
+        return findings;
+    }
+    benchmarkFixture() {
+        return {
+            harness: this.id,
+            executionModel: 'process',
+            event: 'postToolUse',
+            targetMilliseconds: 100,
+            samplePayload: {
+                sessionId: 'bench-copilot',
+                timestamp: 0,
+                cwd: '/repo',
+                toolName: 'bash',
+                toolArgs: { command: 'ls' },
+                toolResult: { resultType: 'success', textResultForLlm: 'file.txt' },
+            },
+        };
+    }
+}

package/dist/src/infrastructure/harnesses/github-copilot-cli/capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { CapabilityDefinition } from '../../../core/contracts/harness.js';
+export declare const COPILOT_CAPABILITIES: readonly CapabilityDefinition[];

package/dist/src/infrastructure/harnesses/github-copilot-cli/capabilities.js

@@ -0,0 +1,6 @@
+export const COPILOT_CAPABILITIES = [
+    { id: 'post_tool_telemetry', state: 'supported' },
+    { id: 'session_boot', state: 'supported' },
+    { id: 'context_usage', state: 'unsupported', impact: 'Context usage is not exposed to GitHub Copilot CLI hooks.' },
+    { id: 'auto_restart', state: 'unsupported', impact: 'Semi-automatic restart: start a new session; it resumes by itself.' },
+];

package/dist/src/infrastructure/harnesses/github-copilot-cli/detector.d.ts

@@ -0,0 +1,6 @@
+import type { DetectionEvidence } from '../../../core/contracts/harness.js';
+export declare const COPILOT_PROJECT_FILES: readonly [".github/copilot/settings.json", ".github/copilot/settings.local.json", ".github/hooks/context-brake.json", "copilot-instructions.md"];
+export declare const COPILOT_PROJECT_DIRS: readonly [".github/copilot", ".github/hooks"];
+export declare const COPILOT_USER_FILES: readonly [".copilot/settings.json"];
+export declare const COPILOT_EXECUTABLES: readonly ["copilot"];
+export declare function detectCopilot(projectRoot: string, userHome?: string): Promise<readonly DetectionEvidence[]>;

package/dist/src/infrastructure/harnesses/github-copilot-cli/detector.js

@@ -0,0 +1,15 @@
+import { checkProjectEvidence, checkUserEvidence } from '../common/path-helpers.js';
+export const COPILOT_PROJECT_FILES = [
+    '.github/copilot/settings.json',
+    '.github/copilot/settings.local.json',
+    '.github/hooks/context-brake.json',
+    'copilot-instructions.md',
+];
+export const COPILOT_PROJECT_DIRS = ['.github/copilot', '.github/hooks'];
+export const COPILOT_USER_FILES = ['.copilot/settings.json'];
+export const COPILOT_EXECUTABLES = ['copilot'];
+export async function detectCopilot(projectRoot, userHome) {
+    const project = await checkProjectEvidence(projectRoot, COPILOT_PROJECT_FILES, COPILOT_PROJECT_DIRS);
+    const machine = await checkUserEvidence(COPILOT_USER_FILES, userHome);
+    return [...project, ...machine];
+}

package/dist/src/infrastructure/harnesses/github-copilot-cli/planner.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterPlan } from '../../../core/contracts/adapter.js';
+import type { ManagedEntry } from '../../../core/contracts/manifest.js';
+export declare const COPILOT_CONFIG_FILE = ".github/hooks/context-brake.json";
+export declare const COPILOT_HOOK_FILE = ".github/hooks/context-brake.mjs";
+export declare function buildCopilotEntries(): ManagedEntry[];
+export declare function planCopilotInstall(projectRoot: string): Promise<AdapterPlan>;
+export declare function planCopilotRemove(projectRoot: string): Promise<AdapterPlan>;

package/dist/src/infrastructure/harnesses/github-copilot-cli/planner.js

@@ -0,0 +1,66 @@
+import { readFile } from 'node:fs/promises';
+import { validateJsonDocument } from '../../storage/json-validator.js';
+import { resolveChangeTarget } from '../common/change-target.js';
+import { loadRuntimeAsset } from '../common/runtime-assets.js';
+export const COPILOT_CONFIG_FILE = '.github/hooks/context-brake.json';
+export const COPILOT_HOOK_FILE = '.github/hooks/context-brake.mjs';
+const REPOSITORY_ROOT = '.';
+function buildHookEntry(event) {
+    return {
+        type: 'command',
+        exec: 'node',
+        args: [COPILOT_HOOK_FILE, event],
+        cwd: REPOSITORY_ROOT,
+    };
+}
+export function buildCopilotEntries() {
+    return [
+        { harness: 'github-copilot-cli', path: COPILOT_CONFIG_FILE, identity: `postToolUse|${COPILOT_HOOK_FILE}` },
+        { harness: 'github-copilot-cli', path: COPILOT_CONFIG_FILE, identity: `sessionStart|${COPILOT_HOOK_FILE}` },
+        { harness: 'github-copilot-cli', path: COPILOT_CONFIG_FILE, identity: `preCompact|${COPILOT_HOOK_FILE}` },
+    ];
+}
+function buildConfigFile() {
+    const content = {
+        version: 1,
+        hooks: {
+            postToolUse: [buildHookEntry('postToolUse')],
+            sessionStart: [buildHookEntry('sessionStart')],
+            preCompact: [buildHookEntry('preCompact')],
+        },
+    };
+    return `${JSON.stringify(content, null, 2)}\n`;
+}
+export async function planCopilotInstall(projectRoot) {
+    const realConfig = await resolveChangeTarget(projectRoot, COPILOT_CONFIG_FILE);
+    try {
+        const raw = await readFile(realConfig, 'utf8');
+        const validation = validateJsonDocument(raw);
+        if (!validation.valid) {
+            const detail = validation.errors.join('; ');
+            return { harness: 'github-copilot-cli', changes: [], conflicts: [{ path: COPILOT_CONFIG_FILE, code: 'INVALID_HARNESS_CONFIG', detail }], entries: [] };
+        }
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT') {
+            const msg = error instanceof Error ? error.message : String(error);
+            return { harness: 'github-copilot-cli', changes: [], conflicts: [{ path: COPILOT_CONFIG_FILE, code: 'INVALID_HARNESS_CONFIG', detail: msg }], entries: [] };
+        }
+    }
+    const assetContent = await loadRuntimeAsset('github-copilot-cli-hook.mjs');
+    const realHook = await resolveChangeTarget(projectRoot, COPILOT_HOOK_FILE);
+    const changes = [
+        { path: COPILOT_CONFIG_FILE, realPath: realConfig, kind: 'create', owner: 'harness_entry', content: buildConfigFile(), preview: { summary: 'Create Copilot hooks config' } },
+        { path: COPILOT_HOOK_FILE, realPath: realHook, kind: 'create', owner: 'runtime_asset', content: assetContent, preview: { summary: 'Install ContextBrake hook script' } },
+    ];
+    return { harness: 'github-copilot-cli', changes, conflicts: [], entries: buildCopilotEntries() };
+}
+export async function planCopilotRemove(projectRoot) {
+    const realConfig = await resolveChangeTarget(projectRoot, COPILOT_CONFIG_FILE);
+    const realHook = await resolveChangeTarget(projectRoot, COPILOT_HOOK_FILE);
+    const changes = [
+        { path: COPILOT_CONFIG_FILE, realPath: realConfig, kind: 'delete', owner: 'harness_entry', content: null, preview: { summary: 'Delete Copilot hooks config' } },
+        { path: COPILOT_HOOK_FILE, realPath: realHook, kind: 'delete', owner: 'runtime_asset', content: null, preview: { summary: 'Delete ContextBrake hook script' } },
+    ];
+    return { harness: 'github-copilot-cli', changes, conflicts: [], entries: buildCopilotEntries() };
+}

package/dist/src/infrastructure/harnesses/github-copilot-cli/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeDecision, RuntimeDescriptor, RuntimeEvent } from '../../../core/contracts/runtime.js';
+import type { RuntimeInput } from '../../../core/services/brake-engine.js';
+import { type ProcessHarnessAdapter } from '../../runtime/process-hook-host.js';
+export declare const copilotDescriptor: RuntimeDescriptor;
+export declare function mapCopilotEvent(eventName: string, payload: unknown): RuntimeEvent | null;
+export declare function mapCopilotInput(eventName: string, payload: unknown): RuntimeInput;
+export declare function renderCopilotDecision(decision: RuntimeDecision): string | null;
+export declare const copilotAdapter: ProcessHarnessAdapter;
+export declare function runCopilotHook(): Promise<number>;

package/dist/src/infrastructure/harnesses/github-copilot-cli/runtime.js

@@ -0,0 +1,67 @@
+import { asRecord, assetProjectRoot, characterLength, parsePayload, requireIdentifier, textValue } from '../common/runtime-support.js';
+import { runProcessHook } from '../../runtime/process-hook-host.js';
+import { COPILOT_CAPABILITIES } from './capabilities.js';
+import { copilotPayloadSchema } from './schemas.js';
+const HARNESS = 'github-copilot-cli';
+const ESTIMATION = { baselineTokens: 15000, tokensPerTurn: 150 };
+const READ_TOOLS = ['view'];
+const WRITE_TOOLS = ['edit', 'create'];
+const SHELL_TOOLS = ['bash', 'powershell'];
+export const copilotDescriptor = { harness: HARNESS, capabilities: COPILOT_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: null };
+function sessionOf(payload) {
+    return { harness: HARNESS, sessionId: requireIdentifier(payload.sessionId), agentId: null };
+}
+function resultCharacters(payload) {
+    const result = asRecord(payload.toolResult);
+    return characterLength(result?.['textResultForLlm'] ?? payload.toolResult);
+}
+function toolOf(payload) {
+    const name = payload.toolName ?? 'unknown';
+    const input = asRecord(payload.toolArgs);
+    if (SHELL_TOOLS.includes(name))
+        return { name, category: 'shell', paths: [], command: textValue(input?.['command']) };
+    const path = textValue(input?.['path']);
+    if (path === null)
+        return { name, category: 'other', paths: [], command: null };
+    if (WRITE_TOOLS.includes(name))
+        return { name, category: 'file_write', paths: [path], command: null };
+    if (READ_TOOLS.includes(name))
+        return { name, category: 'file_read', paths: [path], command: null };
+    return { name, category: 'other', paths: [], command: null };
+}
+function resetEvent(session, source) {
+    if (source === 'startup' || source === 'new')
+        return { kind: 'session_reset', session, reason: 'new' };
+    return null;
+}
+export function mapCopilotEvent(eventName, payload) {
+    const data = parsePayload(copilotPayloadSchema, payload);
+    const session = sessionOf(data);
+    switch (eventName) {
+        case 'postToolUse': return { kind: 'post_tool', session, tool: toolOf(data), toolUseId: null };
+        case 'sessionStart': return resetEvent(session, data.source ?? null);
+        case 'preCompact': return { kind: 'session_reset', session, reason: 'compact' };
+        default: return null;
+    }
+}
+export function mapCopilotInput(eventName, payload) {
+    if (eventName !== 'postToolUse')
+        return {};
+    const data = parsePayload(copilotPayloadSchema, payload);
+    return { observedCharacters: characterLength(data.toolArgs) + resultCharacters(data) };
+}
+export function renderCopilotDecision(decision) {
+    if (decision.kind === 'context')
+        return JSON.stringify({ additionalContext: decision.block });
+    return null;
+}
+export const copilotAdapter = {
+    descriptor: copilotDescriptor,
+    mapEvent: mapCopilotEvent,
+    mapInput: mapCopilotInput,
+    renderDecision: renderCopilotDecision,
+    resolveProjectRoot: async () => await assetProjectRoot(),
+};
+export function runCopilotHook() {
+    return runProcessHook(copilotAdapter);
+}

package/dist/src/infrastructure/harnesses/github-copilot-cli/schemas.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod/mini';
+export declare const copilotHookItemSchema: z.ZodMiniObject<{
+    type: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    exec: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+    command: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    cwd: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$loose>;
+export declare const copilotHooksFileSchema: z.ZodMiniObject<{
+    version: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
+    hooks: z.ZodMiniOptional<z.ZodMiniRecord<z.ZodMiniString<string>, z.ZodMiniArray<z.ZodMiniObject<{
+        type: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        exec: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        args: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+        command: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        cwd: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>>>>;
+}, z.core.$loose>;
+export declare const copilotPayloadSchema: z.ZodMiniObject<{
+    sessionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolArgs: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    toolResult: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    hookName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$loose>;
+export declare const copilotPostToolUsePayloadSchema: z.ZodMiniObject<{
+    sessionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    source: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolArgs: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    toolResult: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    hookName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$loose>;
+export type CopilotPayload = z.infer<typeof copilotPayloadSchema>;

package/dist/src/infrastructure/harnesses/github-copilot-cli/schemas.js

@@ -0,0 +1,21 @@
+import { z } from 'zod/mini';
+export const copilotHookItemSchema = z.looseObject({
+    type: z.optional(z.string()),
+    exec: z.optional(z.string()),
+    args: z.optional(z.array(z.string())),
+    command: z.optional(z.string()),
+    cwd: z.optional(z.string()),
+});
+export const copilotHooksFileSchema = z.looseObject({
+    version: z.optional(z.number()),
+    hooks: z.optional(z.record(z.string(), z.array(copilotHookItemSchema))),
+});
+export const copilotPayloadSchema = z.looseObject({
+    sessionId: z.optional(z.string()),
+    source: z.optional(z.string()),
+    toolName: z.optional(z.string()),
+    toolArgs: z.optional(z.unknown()),
+    toolResult: z.optional(z.unknown()),
+    hookName: z.optional(z.string()),
+});
+export const copilotPostToolUsePayloadSchema = copilotPayloadSchema;

package/dist/src/infrastructure/harnesses/oh-my-pi/adapter.d.ts

@@ -0,0 +1,14 @@
+import type { BenchmarkFixture, HarnessAdapter, HarnessContext } from '../../../core/contracts/adapter.js';
+import type { DiagnosticFinding } from '../../../core/contracts/diagnostics.js';
+import { type CapabilityProfile, type DetectionEvidence, type VersionProbe } from '../../../core/contracts/harness.js';
+export declare class OhMyPiAdapter implements HarnessAdapter {
+    readonly id = "oh-my-pi";
+    readonly executionModel: "in_process";
+    capabilityProfile(version?: VersionProbe): CapabilityProfile;
+    detect(context: HarnessContext): Promise<readonly DetectionEvidence[]>;
+    probeVersion(context: HarnessContext): Promise<VersionProbe>;
+    planInstall(context: HarnessContext): Promise<import("../../../core/contracts/adapter.js").AdapterPlan>;
+    planRemove(context: HarnessContext): Promise<import("../../../core/contracts/adapter.js").AdapterPlan>;
+    diagnose(context: HarnessContext): Promise<readonly DiagnosticFinding[]>;
+    benchmarkFixture(): BenchmarkFixture;
+}

package/dist/src/infrastructure/harnesses/oh-my-pi/adapter.js

@@ -0,0 +1,64 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import {} from '../../../core/contracts/harness.js';
+import { deriveSupportProfile } from '../../../core/services/support-service.js';
+import { validateJsonDocument } from '../../storage/json-validator.js';
+import { createIntegrationMissingFinding, createInvalidConfigFinding } from '../common/diagnostic-helpers.js';
+import { pathExists } from '../common/path-helpers.js';
+import { probeExecutableVersion } from '../common/version-probes.js';
+import { detectOmp, OMP_EXECUTABLES } from './detector.js';
+import { OMP_CAPABILITIES } from './capabilities.js';
+import { diagnoseInProcessRestart } from '../common/restart-diagnostics.js';
+import { harnessRestartMode } from '../../../core/services/restart-install-extras.js';
+import { OMP_EXTENSION_FILE, OMP_RESTART_FILE, planOmpInstall, planOmpRemove } from './planner.js';
+export class OhMyPiAdapter {
+    id = 'oh-my-pi';
+    executionModel = 'in_process';
+    capabilityProfile(version) {
+        return deriveSupportProfile({ harness: this.id, capabilities: OMP_CAPABILITIES, version });
+    }
+    detect(context) {
+        return detectOmp(context.projectRoot, context.userHome);
+    }
+    probeVersion(context) {
+        return probeExecutableVersion(context.runner, OMP_EXECUTABLES);
+    }
+    planInstall(context) {
+        return planOmpInstall(context);
+    }
+    planRemove(context) {
+        return planOmpRemove(context);
+    }
+    async diagnose(context) {
+        const findings = [];
+        const extensionPath = resolve(context.projectRoot, OMP_EXTENSION_FILE);
+        const settingsPath = resolve(context.projectRoot, '.omp/settings.json');
+        if (!(await pathExists(extensionPath))) {
+            findings.push(createIntegrationMissingFinding(this.id, OMP_EXTENSION_FILE));
+        }
+        if (await pathExists(settingsPath)) {
+            try {
+                const raw = await readFile(settingsPath, 'utf8');
+                const validation = validateJsonDocument(raw);
+                if (!validation.valid) {
+                    findings.push(createInvalidConfigFinding(this.id, '.omp/settings.json', validation.errors.join('; ')));
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                findings.push(createInvalidConfigFinding(this.id, '.omp/settings.json', msg));
+            }
+        }
+        findings.push(...await diagnoseInProcessRestart(context, { harness: this.id, label: 'Oh-My-Pi', restartFile: OMP_RESTART_FILE, modeText: harnessRestartMode(this.capabilityProfile()).reason }));
+        return findings;
+    }
+    benchmarkFixture() {
+        return {
+            harness: this.id,
+            executionModel: 'in_process',
+            event: 'tool_result',
+            targetMilliseconds: 15,
+            samplePayload: { toolName: 'read', toolCallId: 'call_bench', input: { path: 'file.txt' }, content: [{ type: 'text', text: 'file.txt' }] },
+        };
+    }
+}

package/dist/src/infrastructure/harnesses/oh-my-pi/capabilities.d.ts

@@ -0,0 +1,2 @@
+import type { CapabilityDefinition } from '../../../core/contracts/harness.js';
+export declare const OMP_CAPABILITIES: readonly CapabilityDefinition[];

package/dist/src/infrastructure/harnesses/oh-my-pi/capabilities.js

@@ -0,0 +1,6 @@
+export const OMP_CAPABILITIES = [
+    { id: 'post_tool_telemetry', state: 'supported' },
+    { id: 'session_boot', state: 'supported' },
+    { id: 'context_usage', state: 'supported' },
+    { id: 'auto_restart', state: 'unsupported', impact: 'Semi-automatic restart: press Enter on the prefilled /context-brake-restart; the new session resumes by itself.' },
+];

package/dist/src/infrastructure/harnesses/oh-my-pi/detector.d.ts

@@ -0,0 +1,6 @@
+import type { DetectionEvidence } from '../../../core/contracts/harness.js';
+export declare const OMP_PROJECT_FILES: readonly [".omp/config.yml", ".omp/settings.json"];
+export declare const OMP_PROJECT_DIRS: readonly [".omp/extensions", ".omp"];
+export declare const OMP_USER_FILES: readonly [".omp/agent/extensions", ".omp/settings.json"];
+export declare const OMP_EXECUTABLES: readonly ["omp"];
+export declare function detectOmp(projectRoot: string, userHome?: string): Promise<readonly DetectionEvidence[]>;

package/dist/src/infrastructure/harnesses/oh-my-pi/detector.js

@@ -0,0 +1,13 @@
+import { checkProjectEvidence, checkUserEvidence } from '../common/path-helpers.js';
+export const OMP_PROJECT_FILES = [
+    '.omp/config.yml',
+    '.omp/settings.json',
+];
+export const OMP_PROJECT_DIRS = ['.omp/extensions', '.omp'];
+export const OMP_USER_FILES = ['.omp/agent/extensions', '.omp/settings.json'];
+export const OMP_EXECUTABLES = ['omp'];
+export async function detectOmp(projectRoot, userHome) {
+    const project = await checkProjectEvidence(projectRoot, OMP_PROJECT_FILES, OMP_PROJECT_DIRS);
+    const machine = await checkUserEvidence(OMP_USER_FILES, userHome);
+    return [...project, ...machine];
+}

package/dist/src/infrastructure/harnesses/oh-my-pi/events.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeEvent, SessionKey } from '../../../core/contracts/runtime.js';
+import type { RuntimeInput } from '../../../core/services/brake-engine.js';
+export declare function stopMessageText(message: unknown): string;
+export declare function mapOmpEvent(eventName: string, payload: unknown, session: SessionKey): RuntimeEvent | null;
+export declare function mapOmpInput(eventName: string, payload: unknown): RuntimeInput;
+export declare function renderOmpToolResult(payload: unknown, block: string): {
+    content: unknown[];
+};

package/dist/src/infrastructure/harnesses/oh-my-pi/events.js

@@ -0,0 +1,65 @@
+import { asRecord, characterLength, parsePayload, textValue } from '../common/runtime-support.js';
+import { ompPayloadSchema } from './schemas.js';
+const SHELL_TOOLS = ['bash', 'run_command'];
+const WRITE_TOOLS = ['write', 'edit'];
+const READ_TOOLS = ['read'];
+function toolOf(name, input) {
+    const tool = name ?? 'unknown';
+    const args = asRecord(input);
+    if (SHELL_TOOLS.includes(tool))
+        return { name: tool, category: 'shell', paths: [], command: textValue(args?.['command']) };
+    const path = textValue(args?.['path']);
+    if (path === null)
+        return { name: tool, category: 'other', paths: [], command: null };
+    if (WRITE_TOOLS.includes(tool))
+        return { name: tool, category: 'file_write', paths: [path], command: null };
+    if (READ_TOOLS.includes(tool))
+        return { name: tool, category: 'file_read', paths: [path], command: null };
+    return { name: tool, category: 'other', paths: [], command: null };
+}
+function assistantText(message) {
+    const record = asRecord(message);
+    if (record?.['role'] !== 'assistant')
+        return '';
+    const content = record['content'];
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    return content.flatMap((part) => {
+        const entry = asRecord(part);
+        return entry?.['type'] === 'text' && typeof entry['text'] === 'string' ? [entry['text']] : [];
+    }).join('\n');
+}
+export function stopMessageText(message) {
+    return typeof message === 'string' ? message : assistantText(message);
+}
+function resetOf(session, reason) {
+    if (reason === 'new' || reason === 'startup')
+        return { kind: 'session_reset', session, reason: 'new' };
+    return null;
+}
+export function mapOmpEvent(eventName, payload, session) {
+    const data = parsePayload(ompPayloadSchema, payload);
+    switch (eventName) {
+        case 'tool_result': return { kind: 'post_tool', session, tool: toolOf(data.toolName, data.input), toolUseId: data.toolCallId ?? null };
+        case 'session_start':
+        case 'session_switch': return resetOf(session, data.reason);
+        case 'session_compact':
+        case 'auto_compaction_end': return { kind: 'session_reset', session, reason: 'compact' };
+        case 'session_stop': return { kind: 'response_end', session, text: stopMessageText(data.last_assistant_message) };
+        case 'message_end': return asRecord(data.message)?.['role'] === 'assistant' ? { kind: 'response_end', session, text: assistantText(data.message) } : null;
+        default: return null;
+    }
+}
+export function mapOmpInput(eventName, payload) {
+    if (eventName !== 'tool_result')
+        return {};
+    const data = parsePayload(ompPayloadSchema, payload);
+    return { observedCharacters: characterLength(data.input) + characterLength(data.content) };
+}
+export function renderOmpToolResult(payload, block) {
+    const data = parsePayload(ompPayloadSchema, payload);
+    const parts = Array.isArray(data.content) ? [...data.content] : typeof data.content === 'string' ? [{ type: 'text', text: data.content }] : [];
+    return { content: [...parts, { type: 'text', text: block }] };
+}

package/dist/src/infrastructure/harnesses/oh-my-pi/planner.d.ts

@@ -0,0 +1,7 @@
+import type { AdapterPlan, HarnessContext } from '../../../core/contracts/adapter.js';
+import type { ManagedEntry } from '../../../core/contracts/manifest.js';
+export declare const OMP_EXTENSION_FILE = ".omp/extensions/context-brake.js";
+export declare function buildOmpEntries(): ManagedEntry[];
+export declare const OMP_RESTART_FILE = ".omp/extensions/context-brake-restart.js";
+export declare function planOmpInstall(context: HarnessContext): Promise<AdapterPlan>;
+export declare function planOmpRemove(context: HarnessContext): Promise<AdapterPlan>;

package/dist/src/infrastructure/harnesses/oh-my-pi/planner.js

@@ -0,0 +1,32 @@
+import { resolveChangeTarget } from '../common/change-target.js';
+import { mergeRestartPlan, planRestartAsset, planRestartRemoval } from '../common/restart-asset-plan.js';
+import { loadRuntimeAsset } from '../common/runtime-assets.js';
+export const OMP_EXTENSION_FILE = '.omp/extensions/context-brake.js';
+export function buildOmpEntries() {
+    return [
+        { harness: 'oh-my-pi', path: OMP_EXTENSION_FILE, identity: `extension|${OMP_EXTENSION_FILE}` },
+    ];
+}
+export const OMP_RESTART_FILE = '.omp/extensions/context-brake-restart.js';
+const RESTART_SPEC = { harness: 'oh-my-pi', path: OMP_RESTART_FILE, asset: 'omp-restart.js' };
+export async function planOmpInstall(context) {
+    return mergeRestartPlan(await planBaseInstall(context.projectRoot), await planRestartAsset(context, RESTART_SPEC));
+}
+export async function planOmpRemove(context) {
+    return mergeRestartPlan(await planBaseRemove(context.projectRoot), await planRestartRemoval(context, RESTART_SPEC));
+}
+async function planBaseInstall(projectRoot) {
+    const realExt = await resolveChangeTarget(projectRoot, OMP_EXTENSION_FILE);
+    const content = await loadRuntimeAsset('omp-extension.js');
+    const changes = [
+        { path: OMP_EXTENSION_FILE, realPath: realExt, kind: 'create', owner: 'runtime_asset', content, preview: { summary: 'Install Oh-My-Pi extension' } },
+    ];
+    return { harness: 'oh-my-pi', changes, conflicts: [], entries: buildOmpEntries() };
+}
+async function planBaseRemove(projectRoot) {
+    const realExt = await resolveChangeTarget(projectRoot, OMP_EXTENSION_FILE);
+    const changes = [
+        { path: OMP_EXTENSION_FILE, realPath: realExt, kind: 'delete', owner: 'runtime_asset', content: null, preview: { summary: 'Delete Oh-My-Pi extension' } },
+    ];
+    return { harness: 'oh-my-pi', changes, conflicts: [], entries: buildOmpEntries() };
+}