context-brake 0.0.0-stage → 1.0.0

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

@@ -0,0 +1,28 @@
+type Payload = Record<string, unknown>;
+export type OmpRestartContext = {
+    readonly cwd?: string | undefined;
+    readonly mode?: string | undefined;
+    readonly hasUI?: boolean | undefined;
+    readonly sessionManager?: {
+        readonly getSessionId?: () => string;
+    } | undefined;
+    readonly ui?: {
+        readonly notify?: (message: string, level?: string) => void;
+        readonly getEditorText?: () => string;
+        readonly setEditorText?: (text: string) => void;
+    } | undefined;
+    readonly newSession?: () => Promise<{
+        cancelled: boolean;
+    }>;
+};
+type Handler = (payload: Payload, context: OmpRestartContext) => Promise<unknown>;
+export type OmpRestartApi = {
+    on(event: string, handler: Handler): void;
+    registerCommand(name: string, command: {
+        description: string;
+        handler(args: string, context: OmpRestartContext): Promise<void>;
+    }): void;
+    sendUserMessage(text: string): void;
+};
+export declare function createOmpRestartExtension(api: OmpRestartApi): void;
+export {};

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

@@ -0,0 +1,79 @@
+import { foldToolCalls, resetConsecutive } from '../../../core/services/restart-guards.js';
+import { handleTurnEnd } from '../../../core/services/restart-flow.js';
+import { systemClock } from '../../runtime/runtime-composition.js';
+import { NodeHandoffStore } from '../../storage/node-handoff-store.js';
+import { recordInProcessDecision } from '../common/in-process-restart-log.js';
+import { recordRestartLoaded, reportFailures } from '../common/in-process-restart-support.js';
+import { countToolCall, inProcessStandDown, memoryGuardStore, readRestartSettings, RESTART_COMMAND, startTurn, takeToolCalls, turnStartedAt } from '../common/in-process-restart-state.js';
+import { textValue } from '../common/runtime-support.js';
+import { stopMessageText } from './events.js';
+const HARNESS = 'oh-my-pi';
+const INTERACTIVE_MODE = 'tui';
+const INTERACTIVE_SOURCE = 'interactive';
+const COMMAND_TEXT = `/${RESTART_COMMAND}`;
+const pending = new Map();
+function prefill(context, root, request) {
+    const editor = context.ui;
+    if (editor?.setEditorText === undefined || (editor.getEditorText?.() ?? '').trim() !== '') {
+        void request.onRejected();
+        return;
+    }
+    pending.set(root, request);
+    editor.setEditorText(COMMAND_TEXT);
+}
+function hostFor(context, root) {
+    const target = { root, harness: HARNESS, sessionId: context.sessionManager?.getSessionId?.() ?? 'unknown' };
+    return {
+        guards: memoryGuardStore(root),
+        handoff: new NodeHandoffStore(root, systemClock),
+        standDown: async () => inProcessStandDown(context.mode === INTERACTIVE_MODE && context.hasUI === true),
+        turnStartedAt: () => turnStartedAt(root),
+        resumeForSeed: async () => null,
+        openSession: (request) => prefill(context, root, request),
+        log: (code) => recordInProcessDecision(target, code, systemClock.now()),
+        notify: (text) => context.ui?.notify?.(text, 'info'),
+    };
+}
+async function onSessionStop(payload, context) {
+    const root = textValue(context.cwd);
+    if (root === null)
+        return;
+    await foldToolCalls(memoryGuardStore(root), takeToolCalls(root));
+    const settings = await readRestartSettings(root);
+    if (settings === undefined)
+        return;
+    await handleTurnEnd(hostFor(context, root), { text: stopMessageText(payload['last_assistant_message']), settings });
+}
+async function runRestartCommand(api, context) {
+    const root = textValue(context.cwd);
+    const request = root === null ? undefined : pending.get(root);
+    if (root === null || request === undefined || context.newSession === undefined)
+        return;
+    pending.delete(root);
+    try {
+        if ((await context.newSession()).cancelled)
+            return request.onRejected();
+        await request.onOpened();
+        api.sendUserMessage(request.seed);
+    }
+    catch {
+        await request.onRejected();
+    }
+}
+async function onInput(payload, context) {
+    const root = textValue(context.cwd);
+    const typed = payload['source'] === INTERACTIVE_SOURCE && textValue(payload['text'])?.trim() !== COMMAND_TEXT;
+    if (root !== null && typed)
+        await resetConsecutive(memoryGuardStore(root));
+}
+export function createOmpRestartExtension(api) {
+    api.on('agent_start', async (_payload, context) => { const root = textValue(context.cwd); if (root !== null)
+        startTurn(root, systemClock.now().getTime()); });
+    api.on('tool_result', async (_payload, context) => { const root = textValue(context.cwd); if (root !== null)
+        countToolCall(root); });
+    api.on('input', (payload, context) => reportFailures(context, () => onInput(payload, context)));
+    api.on('session_start', (_payload, context) => reportFailures(context, () => recordRestartLoaded(context, HARNESS)));
+    api.on('session_switch', (_payload, context) => reportFailures(context, () => recordRestartLoaded(context, HARNESS)));
+    api.on('session_stop', (payload, context) => reportFailures(context, () => onSessionStop(payload, context)));
+    api.registerCommand(RESTART_COMMAND, { description: 'ContextBrake: open a new session and resume from the recorded state', handler: (_args, context) => reportFailures(context, () => runRestartCommand(api, context)) });
+}

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

@@ -0,0 +1,17 @@
+import type { RuntimeDescriptor } from '../../../core/contracts/runtime.js';
+export { mapOmpEvent, mapOmpInput, renderOmpToolResult } from './events.js';
+export declare const ompDescriptor: RuntimeDescriptor;
+export type OmpContext = {
+    readonly cwd?: string | undefined;
+    readonly sessionManager?: {
+        readonly getSessionId?: () => string;
+    } | undefined;
+    readonly getContextUsage?: (() => unknown) | undefined;
+    readonly ui?: {
+        readonly notify?: (message: string, level?: string) => void;
+    } | undefined;
+};
+export type OmpApi = {
+    on?: (event: string, handler: (payload: unknown, context: OmpContext) => Promise<unknown>) => void;
+};
+export declare function createOmpExtension(api: OmpApi): void;

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

@@ -0,0 +1,69 @@
+import { createRuntimeResolver, measuredUsageFrom, runInProcessEvent } from '../common/in-process-support.js';
+import { requireIdentifier, textValue } from '../common/runtime-support.js';
+import { OMP_CAPABILITIES } from './capabilities.js';
+import { mapOmpEvent, mapOmpInput, renderOmpToolResult } from './events.js';
+export { mapOmpEvent, mapOmpInput, renderOmpToolResult } from './events.js';
+const HARNESS = 'oh-my-pi';
+const ESTIMATION = { baselineTokens: 15000, tokensPerTurn: 150 };
+export const ompDescriptor = { harness: HARNESS, capabilities: OMP_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: '/new' };
+function rootOf(context) {
+    return textValue(context.cwd);
+}
+function sessionOf(context) {
+    return { harness: HARNESS, sessionId: requireIdentifier(context.sessionManager?.getSessionId?.()), agentId: null };
+}
+function measuredOf(context) {
+    return measuredUsageFrom(context.getContextUsage?.());
+}
+function eventOf(eventName, payload, context) {
+    try {
+        return mapOmpEvent(eventName, payload, sessionOf(context));
+    }
+    catch {
+        return null;
+    }
+}
+async function handleToolResult(payload, context, resolver) {
+    const event = eventOf('tool_result', payload, context);
+    if (event === null)
+        return undefined;
+    const engineInput = { measured: measuredOf(context), ...mapOmpInput('tool_result', payload) };
+    const decision = await runInProcessEvent({ resolver, projectRoot: rootOf(context), event, engineInput });
+    return decision.kind === 'context' ? renderOmpToolResult(payload, decision.block) : undefined;
+}
+async function recordBoot(event, context, state) {
+    if (event === null)
+        return;
+    const decision = await runInProcessEvent({ resolver: state.resolver, projectRoot: rootOf(context), event });
+    if (decision.kind === 'context')
+        state.pendingBoots.set(event.session.sessionId, decision.block);
+}
+async function handleBeforeAgentStart(context, pendingBoots) {
+    const sessionId = context.sessionManager?.getSessionId?.();
+    if (!sessionId)
+        return undefined;
+    const message = pendingBoots.get(sessionId);
+    if (!message)
+        return undefined;
+    pendingBoots.delete(sessionId);
+    return { message };
+}
+async function handleSessionStop(payload, context, resolver) {
+    const event = eventOf('session_stop', payload, context);
+    if (event === null)
+        return;
+    const decision = await runInProcessEvent({ resolver, projectRoot: rootOf(context), event });
+    if (decision.kind === 'notify_user')
+        context.ui?.notify?.(decision.text, 'info');
+}
+export function createOmpExtension(api) {
+    const resolver = createRuntimeResolver(ompDescriptor);
+    const pendingBoots = new Map();
+    api.on?.('tool_result', (payload, context) => handleToolResult(payload, context, resolver));
+    api.on?.('session_start', (payload, context) => recordBoot(eventOf('session_start', payload, context), context, { resolver, pendingBoots }));
+    api.on?.('session_switch', (payload, context) => recordBoot(eventOf('session_switch', payload, context), context, { resolver, pendingBoots }));
+    api.on?.('session_compact', (payload, context) => recordBoot(eventOf('session_compact', payload, context), context, { resolver, pendingBoots }));
+    api.on?.('auto_compaction_end', (payload, context) => recordBoot(eventOf('auto_compaction_end', payload, context), context, { resolver, pendingBoots }));
+    api.on?.('before_agent_start', (_payload, context) => handleBeforeAgentStart(context, pendingBoots));
+    api.on?.('session_stop', (payload, context) => handleSessionStop(payload, context, resolver));
+}

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

@@ -0,0 +1,50 @@
+import { z } from 'zod/mini';
+export declare const ompSettingsFileSchema: z.ZodMiniObject<{
+    extensions: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+}, z.core.$loose>;
+export declare const ompPayloadSchema: z.ZodMiniObject<{
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolCallId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    content: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    last_assistant_message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$loose>;
+export declare const ompToolResultPayloadSchema: z.ZodMiniObject<{
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolCallId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    content: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    last_assistant_message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$loose>;
+export declare const ompSessionStartPayloadSchema: z.ZodMiniObject<{
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolCallId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    content: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    last_assistant_message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$loose>;
+export declare const ompSessionCompactPayloadSchema: z.ZodMiniObject<{
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolCallId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    content: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    last_assistant_message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$loose>;
+export declare const ompSessionStopPayloadSchema: z.ZodMiniObject<{
+    toolName: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    toolCallId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    input: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    content: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    reason: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    last_assistant_message: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$loose>;
+export type OmpPayload = z.infer<typeof ompPayloadSchema>;

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

@@ -0,0 +1,17 @@
+import { z } from 'zod/mini';
+export const ompSettingsFileSchema = z.looseObject({
+    extensions: z.optional(z.array(z.string())),
+});
+export const ompPayloadSchema = z.looseObject({
+    toolName: z.optional(z.string()),
+    toolCallId: z.optional(z.string()),
+    input: z.optional(z.unknown()),
+    content: z.optional(z.unknown()),
+    reason: z.optional(z.string()),
+    message: z.optional(z.unknown()),
+    last_assistant_message: z.optional(z.unknown()),
+});
+export const ompToolResultPayloadSchema = ompPayloadSchema;
+export const ompSessionStartPayloadSchema = ompPayloadSchema;
+export const ompSessionCompactPayloadSchema = ompPayloadSchema;
+export const ompSessionStopPayloadSchema = ompPayloadSchema;

package/dist/src/infrastructure/harnesses/opencode/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 OpenCodeAdapter implements HarnessAdapter {
+    readonly id = "opencode";
+    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/opencode/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 { detectOpenCode, OPENCODE_EXECUTABLES } from './detector.js';
+import { OPENCODE_CAPABILITIES } from './capabilities.js';
+import { OPENCODE_PLUGIN_FILE, planOpenCodeInstall, planOpenCodeRemove } from './planner.js';
+export class OpenCodeAdapter {
+    id = 'opencode';
+    executionModel = 'in_process';
+    capabilityProfile(version) {
+        return deriveSupportProfile({ harness: this.id, capabilities: OPENCODE_CAPABILITIES, version });
+    }
+    detect(context) {
+        return detectOpenCode(context.projectRoot, context.userHome);
+    }
+    probeVersion(context) {
+        return probeExecutableVersion(context.runner, OPENCODE_EXECUTABLES);
+    }
+    planInstall(context) {
+        return planOpenCodeInstall(context.projectRoot);
+    }
+    planRemove(context) {
+        return planOpenCodeRemove(context.projectRoot);
+    }
+    async diagnose(context) {
+        const findings = [];
+        const pluginPath = resolve(context.projectRoot, OPENCODE_PLUGIN_FILE);
+        const jsonPath = resolve(context.projectRoot, 'opencode.json');
+        if (!(await pathExists(pluginPath))) {
+            findings.push(createIntegrationMissingFinding(this.id, OPENCODE_PLUGIN_FILE));
+        }
+        if (await pathExists(jsonPath)) {
+            try {
+                const raw = await readFile(jsonPath, 'utf8');
+                const validation = validateJsonDocument(raw);
+                if (!validation.valid) {
+                    findings.push(createInvalidConfigFinding(this.id, 'opencode.json', validation.errors.join('; ')));
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                findings.push(createInvalidConfigFinding(this.id, 'opencode.json', msg));
+            }
+        }
+        return findings;
+    }
+    benchmarkFixture() {
+        return {
+            harness: this.id,
+            executionModel: 'in_process',
+            event: 'tool.execute.after',
+            targetMilliseconds: 15,
+            samplePayload: {
+                input: { tool: 'bash', sessionID: 'bench-opencode', callID: 'call_bench' },
+                output: { args: { command: 'ls' }, output: 'file.txt' },
+            },
+        };
+    }
+}

package/dist/src/infrastructure/harnesses/opencode/capabilities.d.ts

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

package/dist/src/infrastructure/harnesses/opencode/capabilities.js

@@ -0,0 +1,6 @@
+export const OPENCODE_CAPABILITIES = [
+    { id: 'post_tool_telemetry', state: 'unsupported', impact: 'Model visibility of post-tool output modification is unconfirmed in OpenCode.' },
+    { id: 'session_boot', state: 'unsupported', impact: 'Stable boot injection is experimental in OpenCode.' },
+    { id: 'context_usage', state: 'unsupported', impact: 'No documented API exposes context usage to OpenCode plugins.' },
+    { id: 'auto_restart', state: 'unsupported', impact: 'No restart: this harness cannot inject the resume instruction.' },
+];

package/dist/src/infrastructure/harnesses/opencode/detector.d.ts

@@ -0,0 +1,6 @@
+import type { DetectionEvidence } from '../../../core/contracts/harness.js';
+export declare const OPENCODE_PROJECT_FILES: readonly ["opencode.json", "opencode.jsonc"];
+export declare const OPENCODE_PROJECT_DIRS: readonly [".opencode"];
+export declare const OPENCODE_USER_FILES: readonly [".config/opencode/plugins", ".config/opencode/opencode.json"];
+export declare const OPENCODE_EXECUTABLES: readonly ["opencode"];
+export declare function detectOpenCode(projectRoot: string, userHome?: string): Promise<readonly DetectionEvidence[]>;

package/dist/src/infrastructure/harnesses/opencode/detector.js

@@ -0,0 +1,16 @@
+import { checkProjectEvidence, checkUserEvidence } from '../common/path-helpers.js';
+export const OPENCODE_PROJECT_FILES = [
+    'opencode.json',
+    'opencode.jsonc',
+];
+export const OPENCODE_PROJECT_DIRS = ['.opencode'];
+export const OPENCODE_USER_FILES = [
+    '.config/opencode/plugins',
+    '.config/opencode/opencode.json',
+];
+export const OPENCODE_EXECUTABLES = ['opencode'];
+export async function detectOpenCode(projectRoot, userHome) {
+    const project = await checkProjectEvidence(projectRoot, OPENCODE_PROJECT_FILES, OPENCODE_PROJECT_DIRS);
+    const machine = await checkUserEvidence(OPENCODE_USER_FILES, userHome);
+    return [...project, ...machine];
+}

package/dist/src/infrastructure/harnesses/opencode/events.d.ts

@@ -0,0 +1,8 @@
+import type { RuntimeEvent, SessionKey } from '../../../core/contracts/runtime.js';
+export declare function mapOpenCodeToolResult(input: unknown, output: unknown, session: SessionKey): RuntimeEvent;
+export declare function openCodeObservedCharacters(output: unknown): number;
+export type OpenCodeSessionEvent = {
+    readonly type: 'session.created' | 'session.compacted';
+    readonly sessionId: string | null;
+};
+export declare function mapOpenCodeSessionEvent(payload: unknown): OpenCodeSessionEvent | null;

package/dist/src/infrastructure/harnesses/opencode/events.js

@@ -0,0 +1,36 @@
+import { asRecord, characterLength, parsePayload, textValue } from '../common/runtime-support.js';
+import { opencodeEventPayloadSchema, opencodeToolAfterOutputSchema, opencodeToolExecuteInputSchema } from './schemas.js';
+const SHELL_TOOLS = ['bash'];
+const WRITE_TOOLS = ['write', 'edit'];
+const READ_TOOLS = ['read'];
+function toolOf(name, args) {
+    const tool = name ?? 'unknown';
+    const record = asRecord(args);
+    if (SHELL_TOOLS.includes(tool))
+        return { name: tool, category: 'shell', paths: [], command: textValue(record?.['command']) };
+    const path = textValue(record?.['filePath']);
+    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 };
+}
+export function mapOpenCodeToolResult(input, output, session) {
+    const data = parsePayload(opencodeToolExecuteInputSchema, input);
+    const args = parsePayload(opencodeToolAfterOutputSchema, output ?? {}).args;
+    return { kind: 'post_tool', session, tool: toolOf(data.tool, args), toolUseId: data.callID ?? null };
+}
+export function openCodeObservedCharacters(output) {
+    return characterLength(parsePayload(opencodeToolAfterOutputSchema, output ?? {}).args);
+}
+export function mapOpenCodeSessionEvent(payload) {
+    const data = parsePayload(opencodeEventPayloadSchema, payload);
+    const type = data.event?.type;
+    if (type !== 'session.created' && type !== 'session.compacted')
+        return null;
+    const properties = data.event?.properties;
+    const sessionId = textValue(properties?.sessionID) ?? textValue(properties?.sessionId) ?? textValue(properties?.info?.id) ?? textValue(properties?.id);
+    return { type, sessionId };
+}

package/dist/src/infrastructure/harnesses/opencode/planner.d.ts

@@ -0,0 +1,6 @@
+import type { AdapterPlan } from '../../../core/contracts/adapter.js';
+import type { ManagedEntry } from '../../../core/contracts/manifest.js';
+export declare const OPENCODE_PLUGIN_FILE = ".opencode/plugins/context-brake.js";
+export declare function buildOpenCodeEntries(): ManagedEntry[];
+export declare function planOpenCodeInstall(projectRoot: string): Promise<AdapterPlan>;
+export declare function planOpenCodeRemove(projectRoot: string): Promise<AdapterPlan>;

package/dist/src/infrastructure/harnesses/opencode/planner.js

@@ -0,0 +1,23 @@
+import { resolveChangeTarget } from '../common/change-target.js';
+import { loadRuntimeAsset } from '../common/runtime-assets.js';
+export const OPENCODE_PLUGIN_FILE = '.opencode/plugins/context-brake.js';
+export function buildOpenCodeEntries() {
+    return [
+        { harness: 'opencode', path: OPENCODE_PLUGIN_FILE, identity: `plugin|${OPENCODE_PLUGIN_FILE}` },
+    ];
+}
+export async function planOpenCodeInstall(projectRoot) {
+    const realPlugin = await resolveChangeTarget(projectRoot, OPENCODE_PLUGIN_FILE);
+    const content = await loadRuntimeAsset('opencode-plugin.js');
+    const changes = [
+        { path: OPENCODE_PLUGIN_FILE, realPath: realPlugin, kind: 'create', owner: 'runtime_asset', content, preview: { summary: 'Install OpenCode plugin' } },
+    ];
+    return { harness: 'opencode', changes, conflicts: [], entries: buildOpenCodeEntries() };
+}
+export async function planOpenCodeRemove(projectRoot) {
+    const realPlugin = await resolveChangeTarget(projectRoot, OPENCODE_PLUGIN_FILE);
+    const changes = [
+        { path: OPENCODE_PLUGIN_FILE, realPath: realPlugin, kind: 'delete', owner: 'runtime_asset', content: null, preview: { summary: 'Delete OpenCode plugin' } },
+    ];
+    return { harness: 'opencode', changes, conflicts: [], entries: buildOpenCodeEntries() };
+}

package/dist/src/infrastructure/harnesses/opencode/runtime.d.ts

@@ -0,0 +1,20 @@
+import type { RuntimeDescriptor } from '../../../core/contracts/runtime.js';
+import { type InProcessRuntimeResolver } from '../common/in-process-support.js';
+export { mapOpenCodeSessionEvent, mapOpenCodeToolResult, openCodeObservedCharacters } from './events.js';
+export declare const openCodeDescriptor: RuntimeDescriptor;
+export type OpenCodePluginHooks = {
+    readonly 'tool.execute.after'?: (input: unknown, output: unknown) => Promise<void>;
+    readonly event?: (payload: unknown) => Promise<void>;
+};
+export type OpenCodeHandlerInput = {
+    readonly input: unknown;
+    readonly output: unknown;
+    readonly projectRoot: string;
+    readonly resolver: InProcessRuntimeResolver;
+};
+export type OpenCodeEventHandlerInput = {
+    readonly payload: unknown;
+    readonly projectRoot: string;
+    readonly resolver: InProcessRuntimeResolver;
+};
+export declare function createOpenCodePlugin(context?: unknown): OpenCodePluginHooks;

package/dist/src/infrastructure/harnesses/opencode/runtime.js

@@ -0,0 +1,51 @@
+import { createRuntimeResolver, runInProcessEvent } from '../common/in-process-support.js';
+import { asRecord, parsePayload, textValue } from '../common/runtime-support.js';
+import { OPENCODE_CAPABILITIES } from './capabilities.js';
+import { mapOpenCodeSessionEvent, mapOpenCodeToolResult, openCodeObservedCharacters } from './events.js';
+import { opencodeToolExecuteInputSchema } from './schemas.js';
+export { mapOpenCodeSessionEvent, mapOpenCodeToolResult, openCodeObservedCharacters } from './events.js';
+const HARNESS = 'opencode';
+const ESTIMATION = { baselineTokens: 15000, tokensPerTurn: 150 };
+const FALLBACK_SESSION_ID = 'project';
+export const openCodeDescriptor = { harness: HARNESS, capabilities: OPENCODE_CAPABILITIES, estimation: ESTIMATION, newSessionCommand: null };
+function resolveProjectRoot(context) {
+    const record = asRecord(context);
+    return textValue(record?.['directory']) ?? textValue(record?.['worktree']) ?? process.cwd();
+}
+function sessionKeyOf(input, fallbackSessionId) {
+    const data = parsePayload(opencodeToolExecuteInputSchema, input);
+    return { harness: HARNESS, sessionId: textValue(data.sessionID) ?? textValue(data.sessionId) ?? fallbackSessionId ?? FALLBACK_SESSION_ID, agentId: null };
+}
+async function handleAfter(args) {
+    let event;
+    try {
+        event = mapOpenCodeToolResult(args.input, args.output, sessionKeyOf(args.input, null));
+    }
+    catch {
+        return;
+    }
+    const engineInput = { observedCharacters: openCodeObservedCharacters(args.output) };
+    await runInProcessEvent({ resolver: args.resolver, projectRoot: args.projectRoot, event, engineInput });
+}
+async function handleEvent(args) {
+    let mapped;
+    try {
+        mapped = mapOpenCodeSessionEvent(args.payload);
+    }
+    catch {
+        return;
+    }
+    if (mapped === null)
+        return;
+    const reason = mapped.type === 'session.created' ? 'new' : 'compact';
+    const event = { kind: 'session_reset', session: sessionKeyOf({}, mapped.sessionId), reason };
+    await runInProcessEvent({ resolver: args.resolver, projectRoot: args.projectRoot, event });
+}
+export function createOpenCodePlugin(context) {
+    const resolver = createRuntimeResolver(openCodeDescriptor);
+    const projectRoot = resolveProjectRoot(context);
+    return {
+        'tool.execute.after': (input, output) => handleAfter({ input, output, projectRoot, resolver }),
+        event: (payload) => handleEvent({ payload, projectRoot, resolver }),
+    };
+}

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

@@ -0,0 +1,51 @@
+import { z } from 'zod/mini';
+export declare const opencodeConfigFileSchema: z.ZodMiniObject<{
+    plugin: z.ZodMiniOptional<z.ZodMiniArray<z.ZodMiniString<string>>>;
+}, z.core.$loose>;
+export declare const opencodeToolExecuteInputSchema: z.ZodMiniObject<{
+    tool: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    sessionID: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    sessionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    callID: z.ZodMiniOptional<z.ZodMiniString<string>>;
+}, z.core.$loose>;
+export declare const opencodeToolAfterOutputSchema: z.ZodMiniObject<{
+    args: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    output: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    metadata: z.ZodMiniOptional<z.ZodMiniUnknown>;
+}, z.core.$loose>;
+export declare const opencodeSessionPropertiesSchema: z.ZodMiniObject<{
+    sessionID: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    sessionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    info: z.ZodMiniOptional<z.ZodMiniObject<{
+        id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const opencodeEventPayloadSchema: z.ZodMiniObject<{
+    event: z.ZodMiniOptional<z.ZodMiniObject<{
+        type: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        properties: z.ZodMiniOptional<z.ZodMiniObject<{
+            sessionID: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            sessionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            info: z.ZodMiniOptional<z.ZodMiniObject<{
+                id: z.ZodMiniOptional<z.ZodMiniString<string>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+export declare const opencodeToolExecuteAfterPayloadSchema: z.ZodMiniObject<{
+    input: z.ZodMiniOptional<z.ZodMiniObject<{
+        tool: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        sessionID: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        sessionId: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        callID: z.ZodMiniOptional<z.ZodMiniString<string>>;
+    }, z.core.$loose>>;
+    output: z.ZodMiniOptional<z.ZodMiniObject<{
+        args: z.ZodMiniOptional<z.ZodMiniUnknown>;
+        output: z.ZodMiniOptional<z.ZodMiniUnknown>;
+        title: z.ZodMiniOptional<z.ZodMiniString<string>>;
+        metadata: z.ZodMiniOptional<z.ZodMiniUnknown>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;

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

@@ -0,0 +1,32 @@
+import { z } from 'zod/mini';
+export const opencodeConfigFileSchema = z.looseObject({
+    plugin: z.optional(z.array(z.string())),
+});
+export const opencodeToolExecuteInputSchema = z.looseObject({
+    tool: z.optional(z.string()),
+    sessionID: z.optional(z.string()),
+    sessionId: z.optional(z.string()),
+    callID: z.optional(z.string()),
+});
+export const opencodeToolAfterOutputSchema = z.looseObject({
+    args: z.optional(z.unknown()),
+    output: z.optional(z.unknown()),
+    title: z.optional(z.string()),
+    metadata: z.optional(z.unknown()),
+});
+export const opencodeSessionPropertiesSchema = z.looseObject({
+    sessionID: z.optional(z.string()),
+    sessionId: z.optional(z.string()),
+    id: z.optional(z.string()),
+    info: z.optional(z.looseObject({ id: z.optional(z.string()) })),
+});
+export const opencodeEventPayloadSchema = z.looseObject({
+    event: z.optional(z.looseObject({
+        type: z.optional(z.string()),
+        properties: z.optional(opencodeSessionPropertiesSchema),
+    })),
+});
+export const opencodeToolExecuteAfterPayloadSchema = z.looseObject({
+    input: z.optional(opencodeToolExecuteInputSchema),
+    output: z.optional(opencodeToolAfterOutputSchema),
+});

package/dist/src/infrastructure/harnesses/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 PiAdapter implements HarnessAdapter {
+    readonly id = "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;
+}