@mxalbert/context-mode 2.0.0

package/build/adapters/openclaw/session-db.d.ts

@@ -0,0 +1,55 @@
+/**
+ * OpenClawSessionDB — OpenClaw-specific extension of SessionDB.
+ *
+ * Adds session_key mapping (openclaw_session_map table) and session
+ * rename support needed for OpenClaw's gateway restart re-keying.
+ *
+ * The shared SessionDB remains unaware of session_key; all OpenClaw-specific
+ * session mapping lives here.
+ */
+import { SessionDB } from "../../session/db.js";
+/** Row from the openclaw_session_map table. */
+export interface SessionMapRow {
+    session_key: string;
+    session_id: string;
+    created_at: string;
+}
+export declare class OpenClawSessionDB extends SessionDB {
+    /**
+     * OpenClaw-specific prepared statements, separate from the parent's
+     * private statement cache. Created in prepareStatements() after
+     * super.prepareStatements() finishes.
+     *
+     * `declare` prevents TypeScript from emitting a field initializer
+     * that would wipe the value set during the base constructor's
+     * prepareStatements() call chain.
+     */
+    private ocStmts;
+    protected initSchema(): void;
+    protected prepareStatements(): void;
+    /** Shorthand to retrieve an OpenClaw-specific cached statement. */
+    private oc;
+    /**
+     * Ensure a session metadata entry exists with an associated session_key.
+     * Calls the parent's 2-param ensureSession and also records the mapping
+     * in openclaw_session_map.
+     */
+    ensureSessionWithKey(sessionId: string, projectDir: string, sessionKey: string): void;
+    /**
+     * Get the session_id of the most recently mapped session for a given sessionKey.
+     * Returns null if no sessions exist for that key.
+     */
+    getMostRecentSession(sessionKey: string): string | null;
+    /**
+     * Rename a session ID in-place across all tables (session_meta, session_events,
+     * session_resume, openclaw_session_map), preserving all events, metadata,
+     * and resume snapshots. Used when OpenClaw re-keys session IDs on gateway
+     * restart so accumulated events survive the re-key.
+     */
+    renameSession(oldId: string, newId: string): void;
+    /**
+     * Remove a session_key mapping from openclaw_session_map.
+     * Called on command:stop to clean up agent session tracking.
+     */
+    removeSessionKey(sessionKey: string): void;
+}

package/build/adapters/openclaw/session-db.js

@@ -0,0 +1,88 @@
+/**
+ * OpenClawSessionDB — OpenClaw-specific extension of SessionDB.
+ *
+ * Adds session_key mapping (openclaw_session_map table) and session
+ * rename support needed for OpenClaw's gateway restart re-keying.
+ *
+ * The shared SessionDB remains unaware of session_key; all OpenClaw-specific
+ * session mapping lives here.
+ */
+import { SessionDB } from "../../session/db.js";
+// ─────────────────────────────────────────────────────────
+// OpenClawSessionDB
+// ─────────────────────────────────────────────────────────
+export class OpenClawSessionDB extends SessionDB {
+    // ── Schema ──
+    initSchema() {
+        super.initSchema();
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS openclaw_session_map (
+        session_key TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        created_at TEXT NOT NULL DEFAULT (datetime('now'))
+      );
+    `);
+    }
+    prepareStatements() {
+        super.prepareStatements();
+        this.ocStmts = new Map();
+        const p = (key, sql) => {
+            this.ocStmts.set(key, this.db.prepare(sql));
+        };
+        p("getMostRecentSession", `SELECT session_id FROM openclaw_session_map WHERE session_key = ?`);
+        p("upsertSessionMap", `INSERT INTO openclaw_session_map (session_key, session_id)
+       VALUES (?, ?)
+       ON CONFLICT(session_key) DO UPDATE SET
+         session_id = excluded.session_id`);
+        p("deleteSessionMap", `DELETE FROM openclaw_session_map WHERE session_key = ?`);
+        p("renameSessionMeta", `UPDATE session_meta SET session_id = ? WHERE session_id = ?`);
+        p("renameSessionEvents", `UPDATE session_events SET session_id = ? WHERE session_id = ?`);
+        p("renameSessionResume", `UPDATE session_resume SET session_id = ? WHERE session_id = ?`);
+        p("renameSessionMap", `UPDATE openclaw_session_map SET session_id = ? WHERE session_id = ?`);
+    }
+    /** Shorthand to retrieve an OpenClaw-specific cached statement. */
+    oc(key) {
+        return this.ocStmts.get(key);
+    }
+    // ═══════════════════════════════════════════
+    // Session key mapping
+    // ═══════════════════════════════════════════
+    /**
+     * Ensure a session metadata entry exists with an associated session_key.
+     * Calls the parent's 2-param ensureSession and also records the mapping
+     * in openclaw_session_map.
+     */
+    ensureSessionWithKey(sessionId, projectDir, sessionKey) {
+        this.ensureSession(sessionId, projectDir);
+        this.oc("upsertSessionMap").run(sessionKey, sessionId);
+    }
+    /**
+     * Get the session_id of the most recently mapped session for a given sessionKey.
+     * Returns null if no sessions exist for that key.
+     */
+    getMostRecentSession(sessionKey) {
+        const row = this.oc("getMostRecentSession").get(sessionKey);
+        return row?.session_id ?? null;
+    }
+    /**
+     * Rename a session ID in-place across all tables (session_meta, session_events,
+     * session_resume, openclaw_session_map), preserving all events, metadata,
+     * and resume snapshots. Used when OpenClaw re-keys session IDs on gateway
+     * restart so accumulated events survive the re-key.
+     */
+    renameSession(oldId, newId) {
+        this.db.transaction(() => {
+            this.oc("renameSessionMeta").run(newId, oldId);
+            this.oc("renameSessionEvents").run(newId, oldId);
+            this.oc("renameSessionResume").run(newId, oldId);
+            this.oc("renameSessionMap").run(newId, oldId);
+        })();
+    }
+    /**
+     * Remove a session_key mapping from openclaw_session_map.
+     * Called on command:stop to clean up agent session tracking.
+     */
+    removeSessionKey(sessionKey) {
+        this.oc("deleteSessionMap").run(sessionKey);
+    }
+}

package/build/adapters/openclaw/usage.d.ts

@@ -0,0 +1,34 @@
+/**
+ * adapters/openclaw/usage — per-turn token + cost capture handler.
+ *
+ * openclaw emits a first-class `model.usage` diagnostic event once per turn
+ * (`DiagnosticUsageEvent`, refs/platforms/openclaw/src/infra/diagnostic-events.ts:18-47),
+ * carrying the full usage breakdown {input, output, cacheRead, cacheWrite} plus
+ * a PRE-COMPUTED `costUsd` (estimateUsageCost, agent-runner.ts:1995). Consumers
+ * subscribe via `onDiagnosticEvent(listener)` (diagnostic-events.ts:1156) — the
+ * exact bus the first-party diagnostics-otel / diagnostics-prometheus extensions
+ * read.
+ *
+ * This module is the parse→build→insert handler the plugin's diagnostic-event
+ * listener invokes. It is deliberately decoupled from the openclaw plugin SDK so
+ * it stays unit-testable: the caller passes the raw payload and an `insert`
+ * callback (the plugin hands it `db.insertEvent`-bound-to-sessionId). The handler
+ * never throws — a usage-capture failure must never break the agent turn.
+ *
+ * Capture surface: the diagnostic-event bus, NOT the tool-call hook. The native
+ * before_tool_call / after_tool_call relay carries only approval/policy data and
+ * NO token usage (matrix §4) — so usage cannot be captured from after_tool_call.
+ */
+import type { SessionEvent } from "../../session/extract.js";
+/** Minimal event-insert surface the handler needs (satisfied by SessionDB.insertEvent bound to a sessionId). */
+export type OpenClawUsageInsert = (event: SessionEvent) => void;
+/**
+ * Handle one openclaw `model.usage` diagnostic payload: parse the per-turn usage
+ * (NOT lastCallUsage), build the structured `agent_usage` event with openclaw's
+ * native `costUsd` (preferred over the pricing catalog), and insert it.
+ *
+ * Returns the inserted event (for tests / callers that want to forward) or null
+ * when the payload is not a usage event, carries no usage, or sums to zero.
+ * Best-effort: swallows any insert failure.
+ */
+export declare function handleOpenclawUsageEvent(payload: unknown, insert: OpenClawUsageInsert): SessionEvent | null;

package/build/adapters/openclaw/usage.js

@@ -0,0 +1,52 @@
+/**
+ * adapters/openclaw/usage — per-turn token + cost capture handler.
+ *
+ * openclaw emits a first-class `model.usage` diagnostic event once per turn
+ * (`DiagnosticUsageEvent`, refs/platforms/openclaw/src/infra/diagnostic-events.ts:18-47),
+ * carrying the full usage breakdown {input, output, cacheRead, cacheWrite} plus
+ * a PRE-COMPUTED `costUsd` (estimateUsageCost, agent-runner.ts:1995). Consumers
+ * subscribe via `onDiagnosticEvent(listener)` (diagnostic-events.ts:1156) — the
+ * exact bus the first-party diagnostics-otel / diagnostics-prometheus extensions
+ * read.
+ *
+ * This module is the parse→build→insert handler the plugin's diagnostic-event
+ * listener invokes. It is deliberately decoupled from the openclaw plugin SDK so
+ * it stays unit-testable: the caller passes the raw payload and an `insert`
+ * callback (the plugin hands it `db.insertEvent`-bound-to-sessionId). The handler
+ * never throws — a usage-capture failure must never break the agent turn.
+ *
+ * Capture surface: the diagnostic-event bus, NOT the tool-call hook. The native
+ * before_tool_call / after_tool_call relay carries only approval/policy data and
+ * NO token usage (matrix §4) — so usage cannot be captured from after_tool_call.
+ */
+import { parseOpenclawUsage, buildAgentUsageEvent } from "../../session/extract.js";
+/**
+ * Handle one openclaw `model.usage` diagnostic payload: parse the per-turn usage
+ * (NOT lastCallUsage), build the structured `agent_usage` event with openclaw's
+ * native `costUsd` (preferred over the pricing catalog), and insert it.
+ *
+ * Returns the inserted event (for tests / callers that want to forward) or null
+ * when the payload is not a usage event, carries no usage, or sums to zero.
+ * Best-effort: swallows any insert failure.
+ */
+export function handleOpenclawUsageEvent(payload, insert) {
+    // parseOpenclawUsage maps cacheWrite→cache_creation_tokens,
+    // cacheRead→cache_read_tokens, costUsd→native_cost_usd, and reads ONLY the
+    // per-turn `usage` total — never the lastCallUsage delta.
+    const counts = parseOpenclawUsage(payload);
+    if (!counts)
+        return null;
+    // native_cost_usd (openclaw's pre-computed costUsd) is preferred over the
+    // catalog inside buildAgentUsageEvent.
+    const event = buildAgentUsageEvent(counts);
+    if (!event)
+        return null;
+    try {
+        insert(event);
+    }
+    catch {
+        // Usage capture must never break the agent turn.
+        return null;
+    }
+    return event;
+}

package/build/adapters/openclaw/workspace-router.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Extract the agent workspace path from tool call params.
+ * Looks for /openclaw/workspace-<name> patterns in cwd, file_path, and command.
+ * Returns the workspace root (e.g. "/openclaw/workspace-trainer") or null.
+ */
+export declare function extractWorkspace(params: Record<string, unknown>): string | null;
+/**
+ * Maps agent workspaces to sessionIds using sessionKey convention.
+ * sessionKey pattern: "agent:<name>:main" → workspace "/openclaw/workspace-<name>"
+ *
+ * Why this exists alongside per-session closures:
+ * Each register() call creates its own closure with its own sessionId, which
+ * naturally isolates sessions. The WorkspaceRouter acts as a safety net for
+ * after_tool_call events where OpenClaw may deliver the event to the wrong
+ * closure (e.g. tool calls interleaving across agents). It resolves the correct
+ * sessionId from workspace paths in tool params, falling back to the closure
+ * sessionId when no workspace is detected.
+ */
+export declare class WorkspaceRouter {
+    private map;
+    /** Register a session from session_start event. */
+    registerSession(sessionKey: string, sessionId: string): void;
+    /** Remove a session (e.g. on command:stop). */
+    removeSession(sessionKey: string): void;
+    /** Resolve sessionId from tool call params. Returns null if no match. */
+    resolveSessionId(params: Record<string, unknown>): string | null;
+    /** Derive workspace path from sessionKey. */
+    private workspaceFromKey;
+}

package/build/adapters/openclaw/workspace-router.js

@@ -0,0 +1,64 @@
+/**
+ * Extract the agent workspace path from tool call params.
+ * Looks for /openclaw/workspace-<name> patterns in cwd, file_path, and command.
+ * Returns the workspace root (e.g. "/openclaw/workspace-trainer") or null.
+ */
+export function extractWorkspace(params) {
+    // Priority: cwd > file_path > command (most specific first)
+    const sources = [
+        params.cwd,
+        params.file_path,
+        params.command,
+    ].filter((v) => typeof v === "string");
+    for (const src of sources) {
+        const match = src.match(/\/openclaw\/workspace-[a-zA-Z0-9_-]+/);
+        if (match)
+            return match[0];
+    }
+    return null;
+}
+/**
+ * Maps agent workspaces to sessionIds using sessionKey convention.
+ * sessionKey pattern: "agent:<name>:main" → workspace "/openclaw/workspace-<name>"
+ *
+ * Why this exists alongside per-session closures:
+ * Each register() call creates its own closure with its own sessionId, which
+ * naturally isolates sessions. The WorkspaceRouter acts as a safety net for
+ * after_tool_call events where OpenClaw may deliver the event to the wrong
+ * closure (e.g. tool calls interleaving across agents). It resolves the correct
+ * sessionId from workspace paths in tool params, falling back to the closure
+ * sessionId when no workspace is detected.
+ */
+export class WorkspaceRouter {
+    // workspace path → sessionId
+    map = new Map();
+    /** Register a session from session_start event. */
+    registerSession(sessionKey, sessionId) {
+        const workspace = this.workspaceFromKey(sessionKey);
+        if (workspace) {
+            this.map.set(workspace, sessionId);
+        }
+    }
+    /** Remove a session (e.g. on command:stop). */
+    removeSession(sessionKey) {
+        const workspace = this.workspaceFromKey(sessionKey);
+        if (workspace) {
+            this.map.delete(workspace);
+        }
+    }
+    /** Resolve sessionId from tool call params. Returns null if no match. */
+    resolveSessionId(params) {
+        const workspace = extractWorkspace(params);
+        if (!workspace)
+            return null;
+        return this.map.get(workspace) ?? null;
+    }
+    /** Derive workspace path from sessionKey. */
+    workspaceFromKey(key) {
+        // Pattern: "agent:<name>:main" or "agent:<name>:<channel>"
+        const match = key.match(/^agent:([^:]+):/);
+        if (!match)
+            return null;
+        return `/openclaw/workspace-${match[1]}`;
+    }
+}

package/build/adapters/opencode/config.d.ts

@@ -0,0 +1,8 @@
+/**
+ * adapters/opencode/config — Thin re-exports from OpenCodeAdapter.
+ *
+ * This module exists for backward compatibility. All logic lives in the
+ * adapter class (index.ts). New code should use getAdapter() from detect.ts.
+ */
+export { OpenCodeAdapter } from "./index.js";
+export { HOOK_TYPES, REQUIRED_HOOKS, OPTIONAL_HOOKS } from "./hooks.js";

package/build/adapters/opencode/config.js

@@ -0,0 +1,8 @@
+/**
+ * adapters/opencode/config — Thin re-exports from OpenCodeAdapter.
+ *
+ * This module exists for backward compatibility. All logic lives in the
+ * adapter class (index.ts). New code should use getAdapter() from detect.ts.
+ */
+export { OpenCodeAdapter } from "./index.js";
+export { HOOK_TYPES, REQUIRED_HOOKS, OPTIONAL_HOOKS } from "./hooks.js";

package/build/adapters/opencode/hooks.d.ts

@@ -0,0 +1,38 @@
+/**
+ * adapters/opencode/hooks — OpenCode hook definitions and validators.
+ *
+ * Defines the hook types and validation helpers specific to OpenCode's
+ * TypeScript plugin paradigm. This module is used by:
+ *   - CLI setup/upgrade commands (to configure plugin in opencode.json)
+ *   - Doctor command (to validate plugin configuration)
+ *
+ * OpenCode hook system reference:
+ *   - I/O: TS plugin functions (not JSON stdin/stdout)
+ *   - Hook names: tool.execute.before, tool.execute.after, experimental.session.compacting
+ *   - Arg modification: output.args mutation
+ *   - Blocking: throw Error in tool.execute.before
+ *   - SessionStart: broken (#14808, no hook #5409)
+ *   - Config: opencode.json plugin array, .opencode/plugins/*.ts
+ */
+/** OpenCode hook types (TS plugin event names). */
+export declare const HOOK_TYPES: {
+    readonly BEFORE: "tool.execute.before";
+    readonly AFTER: "tool.execute.after";
+    readonly COMPACTING: "experimental.session.compacting";
+};
+export type HookType = (typeof HOOK_TYPES)[keyof typeof HOOK_TYPES];
+/**
+ * Required hooks that must be active for context-mode to function.
+ * OpenCode uses TS plugin paradigm — no scripts, just event hooks.
+ */
+export declare const REQUIRED_HOOKS: HookType[];
+/**
+ * Optional hooks that enhance functionality but aren't critical.
+ * experimental.session.compacting is advisory.
+ */
+export declare const OPTIONAL_HOOKS: HookType[];
+/**
+ * Check if an OpenCode plugin entry is the context-mode plugin.
+ * OpenCode plugins are registered as strings in the plugin array.
+ */
+export declare function isContextModePlugin(pluginEntry: string): boolean;

package/build/adapters/opencode/hooks.js

@@ -0,0 +1,50 @@
+/**
+ * adapters/opencode/hooks — OpenCode hook definitions and validators.
+ *
+ * Defines the hook types and validation helpers specific to OpenCode's
+ * TypeScript plugin paradigm. This module is used by:
+ *   - CLI setup/upgrade commands (to configure plugin in opencode.json)
+ *   - Doctor command (to validate plugin configuration)
+ *
+ * OpenCode hook system reference:
+ *   - I/O: TS plugin functions (not JSON stdin/stdout)
+ *   - Hook names: tool.execute.before, tool.execute.after, experimental.session.compacting
+ *   - Arg modification: output.args mutation
+ *   - Blocking: throw Error in tool.execute.before
+ *   - SessionStart: broken (#14808, no hook #5409)
+ *   - Config: opencode.json plugin array, .opencode/plugins/*.ts
+ */
+// ─────────────────────────────────────────────────────────
+// Hook type constants
+// ─────────────────────────────────────────────────────────
+/** OpenCode hook types (TS plugin event names). */
+export const HOOK_TYPES = {
+    BEFORE: "tool.execute.before",
+    AFTER: "tool.execute.after",
+    COMPACTING: "experimental.session.compacting",
+};
+// ─────────────────────────────────────────────────────────
+// Hook validation
+// ─────────────────────────────────────────────────────────
+/**
+ * Required hooks that must be active for context-mode to function.
+ * OpenCode uses TS plugin paradigm — no scripts, just event hooks.
+ */
+export const REQUIRED_HOOKS = [
+    HOOK_TYPES.BEFORE,
+    HOOK_TYPES.AFTER,
+];
+/**
+ * Optional hooks that enhance functionality but aren't critical.
+ * experimental.session.compacting is advisory.
+ */
+export const OPTIONAL_HOOKS = [
+    HOOK_TYPES.COMPACTING,
+];
+/**
+ * Check if an OpenCode plugin entry is the context-mode plugin.
+ * OpenCode plugins are registered as strings in the plugin array.
+ */
+export function isContextModePlugin(pluginEntry) {
+    return pluginEntry.includes("context-mode");
+}

package/build/adapters/opencode/index.d.ts

@@ -0,0 +1,144 @@
+/**
+ * adapters/opencode — OpenCode platform adapter.
+ *
+ * Implements HookAdapter for OpenCode's TypeScript plugin paradigm.
+ *
+ * OpenCode hook specifics:
+ *   - I/O: TS plugin functions (not JSON stdin/stdout)
+ *   - Hook names: tool.execute.before, tool.execute.after, experimental.session.compacting
+ *   - Arg modification: output.args mutation
+ *   - Blocking: throw Error in tool.execute.before
+ *   - Output modification: output.output mutation (TUI bug for bash #13575)
+ *   - SessionStart: broken (#14808, no hook #5409)
+ *   - Session ID: input.sessionID (camelCase!)
+ *   - Project dir: ctx.directory in plugin init (no env var)
+ *   - Config: opencode.json plugin array, .opencode/plugins/*.ts
+ *   - Session dir: ~/.config/opencode/context-mode/sessions/
+ */
+import { BaseAdapter } from "../base.js";
+import type { HookAdapter, HookParadigm, PlatformCapabilities, DiagnosticResult, PreToolUseEvent, PostToolUseEvent, PreCompactEvent, SessionStartEvent, PreToolUseResponse, PostToolUseResponse, PreCompactResponse, SessionStartResponse, HookRegistration, PlatformId } from "../types.js";
+export type AdapterPlatformType = Extract<PlatformId, "opencode" | "kilo">;
+/**
+ * Runtime degradation options (opencode v2 compat). The plugin path probes
+ * the host at setup time and reports what it ACTUALLY acquired — a degraded
+ * capability is reported as unavailable instead of claimed.
+ */
+export interface OpenCodeAdapterOptions {
+    /**
+     * True when the host does not expose a session-context hook (e.g. opencode
+     * v2 without a confirmed ctx.session.hook equivalent of the v1
+     * experimental.chat.system.transform surrogate). Reports sessionStart /
+     * canInjectSessionContext as unavailable instead of claiming them.
+     */
+    sessionContextDegraded?: boolean;
+    /**
+     * True when the host does not expose a compaction hook equivalent
+     * (experimental.session.compacting is v1-only).
+     */
+    preCompactDegraded?: boolean;
+}
+export type PluginFlavor = "v1" | "v2";
+export type ActivationEntry = {
+    flavor: PluginFlavor;
+    claimedAt: number;
+    /**
+     * Whether the claimant CONFIRMED native ctx_* tool registration at setup
+     * time. v1 server() always registers the native tool map → true. v2
+     * setup() sets this only after a working native tool surface is acquired;
+     * a v2 claimant without confirmed native tools must NOT have the legacy
+     * mcp.context-mode removed (it is the only remaining tool provider).
+     */
+    nativeToolsConfirmed?: boolean;
+};
+export type PluginGlobalState = {
+    /** Hybrid-host activation registry, keyed by plugin id + normalized project dir. */
+    activations: Map<string, ActivationEntry>;
+    /** Keys of one-time (setup/degradation/duplicate) logs already emitted. */
+    loggedOnce: Set<string>;
+    /** Dedupe map for hook error logs, keyed by hook|code|message → last-logged ms. */
+    errorDedupe: Map<string, number>;
+};
+/**
+ * Process-global state bag. Stored on globalThis so the guard survives the
+ * plugin being loaded twice from different module copies (e.g. build/ and
+ * .opencode/plugins/ copies loaded by the same host process). Defined here
+ * (plugin.ts already imports this module) so the plugin runtime and the
+ * adapter share the SAME registry.
+ */
+export declare function getPluginGlobalState(): PluginGlobalState;
+/**
+ * Normalize a project directory for the activation registry key:
+ * symlink-canonicalized (macOS /var ↔ /private/var — chdir reports the
+ * resolved path while hosts may pass the unresolved one) + absolute +
+ * case-folded on case-insensitive filesystems (darwin/win32). Dirs that do
+ * not exist on disk fall back to lexical resolution.
+ */
+export declare function normalizeProjectKey(dir: string): string;
+/**
+ * Non-creating peek at the activation registry for a project. Used by the
+ * adapter's legacy-MCP-removal policy (configureAllHooks / validateHooks):
+ *
+ *   - undefined → no plugin runtime has initialized in THIS process (e.g.
+ *     the CLI runs standalone); callers fall back to the config-shape
+ *     heuristic (v1 `plugin` key → native tools confirmed).
+ *   - true/false → an in-process claimant exists (or the registry is live
+ *     with no claimant for this project); its CONFIRMED native-tool state
+ *     is authoritative — never remove mcp.context-mode on a guess.
+ */
+export declare function peekConfirmedNativeTools(projectDir: string): boolean | undefined;
+export declare class OpenCodeAdapter extends BaseAdapter implements HookAdapter {
+    get name(): string;
+    readonly paradigm: HookParadigm;
+    private settingsPath?;
+    readonly capabilities: PlatformCapabilities;
+    private platform;
+    constructor(platform?: AdapterPlatformType, options?: OpenCodeAdapterOptions);
+    /**
+     * Runtime honesty hook — the plugin path marks a capability unavailable
+     * after probing the host (e.g. a v2 session-context registration call
+     * failed even though the surface existed). Mirrors the constructor options
+     * for state that is only knowable after registration attempts.
+     */
+    markCapabilityDegraded(cap: "sessionStart" | "canInjectSessionContext" | "preCompact"): void;
+    parsePreToolUseInput(raw: unknown): PreToolUseEvent;
+    parsePostToolUseInput(raw: unknown): PostToolUseEvent;
+    parsePreCompactInput(raw: unknown): PreCompactEvent;
+    parseSessionStartInput(raw: unknown): SessionStartEvent;
+    formatPreToolUseResponse(response: PreToolUseResponse): unknown;
+    formatPostToolUseResponse(response: PostToolUseResponse): unknown;
+    formatPreCompactResponse(response: PreCompactResponse): unknown;
+    formatSessionStartResponse(response: SessionStartResponse): unknown;
+    getSettingsPath(): string;
+    private paths;
+    getSessionDir(): string;
+    /**
+     * OpenCode/KiloCode honor XDG_CONFIG_HOME on POSIX and APPDATA on Windows.
+     * Falls back to ~/.config/<platform> (or %APPDATA%\<platform>).
+     * Always absolute. `_projectDir` is accepted for interface symmetry but
+     * unused — config is home/XDG-rooted, never project-scoped.
+     */
+    getConfigDir(_projectDir?: string): string;
+    getInstructionFiles(): string[];
+    generateHookConfig(_pluginRoot: string): HookRegistration;
+    readSettings(): Record<string, unknown> | null;
+    writeSettings(settings: Record<string, unknown>): void;
+    validateHooks(_pluginRoot: string): DiagnosticResult[];
+    checkPluginRegistration(): DiagnosticResult;
+    getInstalledVersion(): string;
+    configureAllHooks(_pluginRoot: string): string[];
+    backupSettings(): string | null;
+    setHookPermissions(_pluginRoot: string): string[];
+    updatePluginRegistry(_pluginRoot: string, _version: string): void;
+    /**
+     * Check whether a settings object has the context-mode plugin registered.
+     * Honors both the v1 `plugin` key and the v2 `plugins` key (opencode v2
+     * renamed the config key).
+     */
+    private hasContextModePlugin;
+    private hasLegacyContextModeMcp;
+    /**
+     * Extract session ID from OpenCode hook input.
+     * OpenCode uses camelCase sessionID.
+     */
+    private extractSessionId;
+}