opencode-matrixx-v2 0.0.0-stage → 1.0.0

package/dist/mcps/context7.d.ts

@@ -0,0 +1,9 @@
+export declare const context7: {
+    type: "remote";
+    url: string;
+    enabled: boolean;
+    headers: {
+        Authorization: string;
+    } | undefined;
+    oauth: false;
+};

package/dist/mcps/document-reader.d.ts

@@ -0,0 +1,5 @@
+export declare const document_reader: {
+    type: "local";
+    command: string[];
+    enabled: boolean;
+};

package/dist/mcps/index.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP domain entrypoint — thin composer over the pure `./mcp.transform` core.
+ *
+ * `createBuiltinMcps` keeps the injectable availability check and delegates
+ * every entry to `buildBuiltinMcpEntries`. New code should prefer the
+ * pure builder plus `registerMcpTransform` directly.
+ */
+import type { MatrixxConfig } from "../config/schema";
+import { type BuiltinMcpEntry } from "./mcp.transform";
+import { type McpCreationFailure } from "./mcp-validator";
+export type { McpTransformDomain, McpTransformEditor, RegisterMcpTransformResult, } from "./mcp.transform";
+export { type BuiltinMcpEntry, buildBuiltinMcpEntries, registerMcpTransform, toV2McpEntry } from "./mcp.transform";
+export type { McpCreationFailure } from "./mcp-validator";
+export { type McpName, McpNameSchema } from "./types";
+export interface CreateBuiltinMcpsOptions {
+    isCommandAvailable?: (command: string) => boolean;
+}
+export interface CreateBuiltinMcpsResult {
+    mcps: Record<string, BuiltinMcpEntry>;
+    failures: McpCreationFailure[];
+}
+export declare function createBuiltinMcps(disabledMcps?: string[], _config?: MatrixxConfig, options?: CreateBuiltinMcpsOptions): CreateBuiltinMcpsResult;

package/dist/mcps/mcp-startup-state.d.ts

@@ -0,0 +1,4 @@
+import type { McpCreationFailure } from "./mcp-validator";
+export declare function setMcpStartupFailures(failures: McpCreationFailure[]): void;
+export declare function getMcpStartupFailures(): McpCreationFailure[];
+export declare function _resetMcpStartupFailuresForTesting(): void;

package/dist/mcps/mcp-validator.d.ts

@@ -0,0 +1,11 @@
+export interface McpCreationFailure {
+    name: string;
+    error: string;
+}
+export type McpValidationResult = {
+    ok: true;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function isCommandAvailable(command: string): boolean;

package/dist/mcps/mcp.transform.d.ts

@@ -0,0 +1,61 @@
+/**
+ * V2-native MCP domain transform (D4).
+ *
+ * Owned by `src/mcps/`: pure entry builder + single `ctx.mcp.transform` registration.
+ * The builder performs no filesystem access, no process spawn and no network —
+ * environment capability (`uvxAvailable`) is resolved by the caller at the edge
+ * and passed in as data, so repeated runs over the same input replay identically.
+ */
+import type { McpCreationFailure } from "./mcp-validator";
+export type { McpCreationFailure } from "./mcp-validator";
+export type BuiltinMcpEntry = {
+    type: "remote";
+    url: string;
+    enabled: boolean;
+    headers?: Record<string, string>;
+    oauth?: false;
+} | {
+    type: "local";
+    command: string[];
+    enabled: boolean;
+};
+export interface BuildBuiltinMcpEntriesInput {
+    disabledMcps?: string[];
+    /** Resolved by the caller (e.g. `isCommandAvailable("uvx")`); never spawned here. */
+    uvxAvailable: boolean;
+}
+export interface BuildBuiltinMcpEntriesResult {
+    entries: Record<string, BuiltinMcpEntry>;
+    failures: McpCreationFailure[];
+}
+/** Pure: builtin MCP entries + non-fatal failures for a given input. */
+export declare function buildBuiltinMcpEntries(input: BuildBuiltinMcpEntriesInput): BuildBuiltinMcpEntriesResult;
+export type V2McpEntry = {
+    type: "local" | "remote";
+    disabled?: boolean;
+    [key: string]: unknown;
+};
+/**
+ * Pure sanitizer: V1 draft entry (`enabled`, no discriminator) → V2 tagged entry.
+ * Fields that would fail the V2 schema (explicit `undefined`, non-object
+ * `headers`) are dropped, because a schema defect here disables the whole plugin.
+ */
+export declare function toV2McpEntry(entry: unknown): V2McpEntry | undefined;
+/** Minimal structural editor: the real V2 `MCPEditor` satisfies this. */
+export interface McpTransformEditor {
+    set(name: string, config: unknown): void;
+}
+export interface McpTransformDomain {
+    transform(callback: (editor: McpTransformEditor) => void): Promise<unknown>;
+}
+export interface RegisterMcpTransformResult {
+    registration: unknown;
+    /** Entries skipped because they failed V2 sanitization. */
+    skipped: string[];
+}
+/**
+ * Pure replay: V1-shaped draft entries → `ctx.mcp.transform`.
+ * The only effect is the single `transform` call; the callback itself only
+ * calls `editor.set`, so re-running over the same draft replays identically.
+ */
+export declare function registerMcpTransform(mcp: McpTransformDomain, entries: Record<string, unknown> | undefined): Promise<RegisterMcpTransformResult>;

package/dist/mcps/types.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const McpNameSchema: z.ZodEnum<{
+    context7: "context7";
+    document_reader: "document_reader";
+}>;
+export type McpName = z.infer<typeof McpNameSchema>;
+export declare const AnyMcpNameSchema: z.ZodString;
+export type AnyMcpName = z.infer<typeof AnyMcpNameSchema>;

package/dist/plugin/available-categories.d.ts

@@ -0,0 +1,3 @@
+import type { AvailableCategory } from "../agents/dynamic-agent-prompt-builder";
+import type { MatrixxConfig } from "../config";
+export declare function createAvailableCategories(pluginConfig: MatrixxConfig): AvailableCategory[];

package/dist/plugin/chat-message.d.ts

@@ -0,0 +1,30 @@
+import type { MatrixxConfig } from "../config";
+import type { MatrixxContext } from "./context";
+import type { DomainHooks } from "./setup-domains";
+type FirstMessageVariantGate = {
+    shouldOverride: (sessionID: string) => boolean;
+    markApplied: (sessionID: string) => void;
+};
+type ChatMessagePart = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+type ChatMessageHandlerOutput = {
+    message: Record<string, unknown>;
+    parts: ChatMessagePart[];
+};
+export declare function createChatMessageHandler(args: {
+    ctx: MatrixxContext;
+    pluginConfig: MatrixxConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    hooks: DomainHooks;
+}): (input: {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}, output: ChatMessageHandlerOutput) => Promise<void>;
+export {};

package/dist/plugin/chat-params.d.ts

@@ -0,0 +1,28 @@
+type ChatParamsInput = {
+    sessionID: string;
+    agent: {
+        name?: string;
+    };
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    provider: {
+        id: string;
+    };
+    message: {
+        variant?: string;
+    };
+};
+type ChatParamsOutput = {
+    temperature?: number;
+    topP?: number;
+    topK?: number;
+    options: Record<string, unknown>;
+};
+export declare function createChatParamsHandler(args: {
+    anthropicEffort: {
+        "chat.params"?: (input: ChatParamsInput, output: ChatParamsOutput) => Promise<void>;
+    } | null;
+}): (input: unknown, output: unknown) => Promise<void>;
+export {};

package/dist/plugin/context.d.ts

@@ -0,0 +1,298 @@
+/**
+ * Canonical plugin context for the matrixx V2 adapter (`MatrixxContext`)
+ * plus the promise-flavor domain shapes every consumer is written against.
+ *
+ * Renamed from `context.ts` (task 23): the file now carries the
+ * canonical `MatrixxContext` name instead of the `V2*` prefix, and the
+ * context includes the platform fields the core reads (`directory`,
+ * `worktree`, `project`, `$`) plus the host `notify` sink.
+ *
+ * Every domain member is the promise-flavor shape verified against runtime
+ * v2.1.4 by the Phase 0 probes (P1/P1b/P2/P4/P4b/P5):
+ * - P1/P1b: `agent.list()` answers a `{location, data}` envelope while
+ *   `agent.transform((e) => e.list())` re-registers and returns the
+ *   `Registration` — hence the tolerant `list(input?)` plus the
+ *   `transform(...) => Promise<V2Registration>` pair.
+ * - P2: `session.context()` requires a real sessionID and answers flat V2
+ *   messages — no `{data}` envelope, no `info`/`parts` wrapper.
+ * - P3/P4: `session.messages` and `config` are absent on the host context,
+ *   so neither appears here (a `config` member must FAIL typecheck).
+ * - P4b: the default model resolves via `model.transform(...)`, not
+ *   `config.get` — the model domain keeps the same transform shape.
+ * - P5: the tool list carries per-tool `options` (`codemode: false` for
+ *   the direct-only entry) — hence `options?` on `V2ToolInfo`.
+ *
+ * Type-only module: no runtime code. The old `definePlugin` identity helper
+ * lived here only to mirror `@opencode/plugin`; the host validates the
+ * default export structurally (`{ id, setup }`), so `src/index.ts` exports
+ * that literal directly.
+ */
+import type { NotifySink } from "../shared/notify";
+import type { MatrixxToolDefinition } from "../tools/shared/define-tool";
+export type Cleanup = () => unknown;
+export interface V2App {
+    readonly name: string;
+    readonly version: string;
+    readonly channel: string;
+}
+export interface V2Project {
+    readonly id: string;
+    readonly directory: string;
+    readonly canonical: string;
+}
+export interface V2Location {
+    readonly directory: string;
+    readonly workspaceID?: string;
+    readonly project: V2Project;
+}
+export interface V2Event {
+    readonly type: string;
+    readonly [key: string]: unknown;
+}
+export interface V2Registration {
+    dispose(): Promise<void>;
+}
+export type V2HookCallback<Event> = (event: Event) => Promise<void> | void;
+export interface V2SessionPromptEvent {
+    readonly sessionID: string;
+    readonly messageID: string;
+    prompt: {
+        text: string;
+        [key: string]: unknown;
+    };
+    metadata?: Record<string, unknown>;
+    delivery: string;
+}
+export interface V2SystemPart {
+    type: string;
+    text: string;
+}
+export interface V2SessionContextEvent {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly model: unknown;
+    system: V2SystemPart[];
+    messages: unknown[];
+    options: Record<string, unknown>;
+    tools: Record<string, {
+        description: string;
+        input: unknown;
+    }>;
+}
+export interface V2SessionCompactionEvent extends V2SessionContextEvent {
+    result?: unknown;
+}
+export interface V2ToolContext {
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly id: string;
+    readonly signal: AbortSignal;
+    progress(update: Record<string, unknown>): Promise<void>;
+}
+export interface V2ToolResult {
+    content?: string | ReadonlyArray<unknown>;
+    output?: unknown;
+    metadata?: Record<string, unknown>;
+}
+export interface V2ToolInfo {
+    name: string;
+    description: string;
+    input: unknown;
+    output?: unknown;
+    options?: Record<string, unknown>;
+    execute(input: unknown, context: V2ToolContext): Promise<V2ToolResult>;
+}
+export interface V2ToolEditor {
+    list(): ReadonlyArray<V2ToolInfo & {
+        readonly id: string;
+    }>;
+    get(id: string): (V2ToolInfo & {
+        readonly id: string;
+    }) | undefined;
+    namespace(namespace: {
+        name: string;
+        description: string;
+    }): void;
+    add(tool: V2ToolInfo): void;
+    update(id: string, update: (tool: V2ToolInfo) => void): void;
+    remove(id: string): void;
+}
+export interface V2ExecuteBeforeEvent {
+    tool: string;
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly id: string;
+    input: unknown;
+}
+export type V2ExecuteAfterEvent = {
+    readonly tool: string;
+    readonly sessionID: string;
+    readonly agent: string;
+    readonly messageID: string;
+    readonly id: string;
+    readonly input: unknown;
+} & ({
+    readonly status: "completed";
+    result: V2ToolResult;
+} | {
+    readonly status: "error";
+    error: {
+        message: string;
+        [key: string]: unknown;
+    };
+});
+export interface V2PermissionApi {
+    assert(input: Record<string, unknown>): Promise<void>;
+    list(input: Record<string, unknown>): Promise<unknown>;
+    get(input: Record<string, unknown>): Promise<unknown>;
+    reply(input: Record<string, unknown>): Promise<void>;
+}
+export interface V2ToolDomain {
+    transform(callback: (editor: V2ToolEditor) => void): Promise<V2Registration>;
+    list(): Promise<ReadonlyArray<V2ToolInfo & {
+        readonly id: string;
+    }>>;
+    reload(): Promise<void>;
+    hook(name: "execute.before", callback: V2HookCallback<V2ExecuteBeforeEvent>): Promise<V2Registration>;
+    hook(name: "execute.after", callback: V2HookCallback<V2ExecuteAfterEvent>): Promise<V2Registration>;
+}
+export interface V2SessionDomain {
+    hook(name: "prompt", callback: V2HookCallback<V2SessionPromptEvent>): Promise<V2Registration>;
+    hook(name: "context" | "compaction" | "generate" | "title", callback: V2HookCallback<V2SessionContextEvent>): Promise<V2Registration>;
+    hook(name: "model.request", callback: V2HookCallback<{
+        headers: Record<string, string>;
+        [key: string]: unknown;
+    }>): Promise<V2Registration>;
+    list(input?: Record<string, unknown>): Promise<unknown>;
+    get(input: Record<string, unknown>): Promise<unknown>;
+    create(input?: Record<string, unknown>): Promise<unknown>;
+    update(input: Record<string, unknown>): Promise<unknown>;
+    move(input: Record<string, unknown>): Promise<unknown>;
+    remove(input: Record<string, unknown>): Promise<unknown>;
+    switchAgent(input: Record<string, unknown>): Promise<unknown>;
+    switchModel(input: Record<string, unknown>): Promise<unknown>;
+    prompt(input: Record<string, unknown>): Promise<unknown>;
+    generate(input: Record<string, unknown>): Promise<unknown>;
+    command(input: Record<string, unknown>): Promise<unknown>;
+    compact(input: Record<string, unknown>): Promise<unknown>;
+    synthetic(input: Record<string, unknown>): Promise<unknown>;
+    interrupt(input: Record<string, unknown>): Promise<unknown>;
+    wait(input: Record<string, unknown>): Promise<unknown>;
+    context(input: Record<string, unknown>): Promise<unknown>;
+}
+export interface V2TransformDomain {
+    list(input?: Record<string, unknown>): Promise<unknown>;
+    transform(callback: (editor: V2DomainEditor) => void): Promise<V2Registration>;
+    reload(): Promise<void>;
+}
+/** Shared shape of the command/skill/provider/model/reference editors. */
+export interface V2DomainEditor {
+    list(...args: unknown[]): ReadonlyArray<unknown>;
+    get(...args: unknown[]): unknown;
+    add(...args: unknown[]): void;
+    update(...args: unknown[]): void;
+    remove(...args: unknown[]): void;
+    [key: string]: unknown;
+}
+/** `MCPEditor` registers a server by name via `set`; it has no `add`. */
+export interface V2McpEditor {
+    list(): ReadonlyArray<[string, unknown]>;
+    get(name: string): unknown;
+    set(name: string, config: unknown): void;
+    update(name: string, update: (config: Record<string, unknown>) => void): void;
+    remove(name: string): void;
+}
+export interface V2McpTransformDomain {
+    list(input?: Record<string, unknown>): Promise<unknown>;
+    transform(callback: (editor: V2McpEditor) => void): Promise<V2Registration>;
+    reload(): Promise<void>;
+}
+export interface V2AgentInfo {
+    id: string;
+    name: string;
+    model?: {
+        providerID: string;
+        id: string;
+        variant?: string;
+    };
+    request: {
+        settings?: Record<string, unknown>;
+        headers?: Record<string, string>;
+        body?: Record<string, unknown>;
+    };
+    system?: string;
+    description?: string;
+    mode: "primary" | "subagent" | "all";
+    hidden: boolean;
+    color?: string;
+    steps?: number;
+    disabled?: boolean;
+    permissions: unknown[];
+    [key: string]: unknown;
+}
+/** `AgentEditor` has no `add`; `update` seeds a missing agent from `Info.default`. */
+export interface V2AgentEditor {
+    list(): readonly V2AgentInfo[];
+    get(id: string): V2AgentInfo | undefined;
+    default(id: string | undefined): void;
+    update(id: string, update: (agent: V2AgentInfo) => void): void;
+    remove(id: string): void;
+}
+export interface V2AgentTransformDomain {
+    list(input?: Record<string, unknown>): Promise<unknown>;
+    transform(callback: (editor: V2AgentEditor) => void): Promise<V2Registration>;
+    reload(): Promise<void>;
+}
+export interface MatrixxContext {
+    readonly app: V2App;
+    readonly location: V2Location;
+    readonly options: Record<string, unknown>;
+    /**
+     * Platform fields the core needs. `createNativePluginContext` derives
+     * them from `location` today; they are first-class here so consumers can
+     * read them off the context directly.
+     */
+    readonly directory: string;
+    readonly worktree: string;
+    readonly project: V2Project;
+    /** Bun shell API (`import { $ } from "bun"`), threaded for tool/exec use. */
+    readonly $: typeof import("bun").$;
+    /** Host notification sink (authoritative type lives in shared/notify). */
+    readonly notify: NotifySink;
+    readonly session: V2SessionDomain;
+    readonly tool: V2ToolDomain;
+    readonly event: {
+        subscribe(options?: {
+            signal?: AbortSignal;
+        }): AsyncIterable<V2Event>;
+    };
+    readonly agent: V2AgentTransformDomain;
+    readonly command: V2TransformDomain;
+    readonly mcp: V2McpTransformDomain;
+    readonly skill: V2TransformDomain;
+    readonly model: V2TransformDomain;
+    readonly provider: V2TransformDomain;
+    readonly reference: V2TransformDomain;
+    readonly integration: V2TransformDomain;
+    readonly permission: V2PermissionApi;
+    readonly storage: {
+        get(key: string): Promise<unknown>;
+        set(key: string, value: unknown): Promise<void>;
+        remove(key: string): Promise<void>;
+    };
+    readonly shell: {
+        hook(name: "create.before", callback: V2HookCallback<{
+            env: Record<string, string>;
+            [key: string]: unknown;
+        }>): Promise<V2Registration>;
+    };
+}
+/**
+ * Registry of tool definitions keyed by tool name.
+ *
+ * Relocated from the deleted V1 substrate module (`./types`, task 24);
+ * the definition shape is the task 23 `MatrixxToolDefinition`.
+ */
+export type ToolsRecord = Record<string, MatrixxToolDefinition>;

package/dist/plugin/event-dispatch.d.ts

@@ -0,0 +1,29 @@
+import type { V2Event } from "./context";
+export declare const DISPATCH_BACKOFF_BASE_MS = 250;
+export declare const DISPATCH_BACKOFF_MAX_MS = 30000;
+export declare const DEDUPLICATE_WINDOW_MS = 500;
+export declare function dispatchBackoffMs(consecutiveFailures: number): number;
+export declare function defaultSleep(ms: number, signal?: AbortSignal): Promise<void>;
+export type EventSubscriber = (options: {
+    signal: AbortSignal;
+}) => AsyncIterable<V2Event>;
+export type DispatchGuard = <T>(label: string, fn: () => Promise<T>) => Promise<T | undefined>;
+export type EventDispatcherDeps = {
+    handler: (event: V2Event) => Promise<void>;
+    guard: DispatchGuard;
+    log?: (message: string, data?: unknown) => void;
+    sleep?: (ms: number, signal?: AbortSignal) => Promise<void>;
+    now?: () => number;
+};
+export type EventDispatcherStats = {
+    attempts: number;
+    delivered: number;
+    consecutiveFailures: number;
+};
+export type EventDispatcher = {
+    dispatchMatrixxEvent: (event: V2Event) => Promise<void>;
+    start: (subscribe: EventSubscriber, signal: AbortSignal) => void;
+    stop: () => void;
+    stats: () => EventDispatcherStats;
+};
+export declare function createEventDispatcher(deps: EventDispatcherDeps): EventDispatcher;

package/dist/plugin/event.d.ts

@@ -0,0 +1,20 @@
+import type { MatrixxConfig } from "../config";
+import type { NativePluginContext } from "../shared/session-context-source";
+import type { MatrixxContext, V2Event } from "./context";
+import type { DomainHooks, DomainManagers } from "./setup-domains";
+type FirstMessageVariantGate = {
+    markSessionCreated: (sessionInfo: {
+        id?: string;
+        title?: string;
+        parentID?: string;
+    } | undefined) => void;
+    clear: (sessionID: string) => void;
+};
+export declare function createEventHandler(args: {
+    ctx: MatrixxContext & NativePluginContext;
+    pluginConfig: MatrixxConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    managers: DomainManagers;
+    hooks: DomainHooks;
+}): (event: V2Event) => Promise<void>;
+export {};

package/dist/plugin/hooks/create-continuation-hooks.d.ts

@@ -0,0 +1,29 @@
+import type { HookName, MatrixxConfig } from "../../config";
+import type { BackgroundManager } from "../../features/background-agent";
+import { createBackgroundNotificationHook, createCompactionContextInjector, createEvolutionHitlHook, createNiobeHook, createNudgeLoopBreakerHook, createPlanPersister, createStopContinuationGuardHook, createTaskContinuationEnforcer } from "../../hooks";
+import type { NativePluginContext } from "../../shared/session-context-source";
+import { createUnstableAgentBabysitter } from "../unstable-agent-babysitter";
+export type ContinuationHooks = {
+    stopContinuationGuard: ReturnType<typeof createStopContinuationGuardHook> | null;
+    compactionContextInjector: ReturnType<typeof createCompactionContextInjector> | null;
+    taskContinuationEnforcer: ReturnType<typeof createTaskContinuationEnforcer> | null;
+    unstableAgentBabysitter: ReturnType<typeof createUnstableAgentBabysitter> | null;
+    nudgeLoopBreaker: ReturnType<typeof createNudgeLoopBreakerHook> | null;
+    backgroundNotificationHook: ReturnType<typeof createBackgroundNotificationHook> | null;
+    niobeHook: ReturnType<typeof createNiobeHook> | null;
+    planPersister: ReturnType<typeof createPlanPersister> | null;
+    evolutionHitl: ReturnType<typeof createEvolutionHitlHook> | null;
+};
+type SessionRecovery = {
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+} | null;
+export declare function createContinuationHooks(args: {
+    ctx: NativePluginContext;
+    pluginConfig: MatrixxConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+    backgroundManager: BackgroundManager;
+    sessionRecovery: SessionRecovery;
+}): ContinuationHooks;
+export {};

package/dist/plugin/hooks/create-session-hooks.d.ts

@@ -0,0 +1,32 @@
+import type { HookName, MatrixxConfig } from "../../config";
+import { createAgentUsageReminderHook, createAutoUpdateCheckerHook, createContextWindowLimitRecoveryHook, createContextWindowMonitorHook, createDelegateTaskRetryHook, createEditErrorRecoveryHook, createInteractiveBashSessionHook, createMatrixLoopHook, createMouseNotepadHook, createNonInteractiveEnvHook, createOracleMdOnlyHook, createRtkBashRewriterHook, createRuntimeFallbackHook, createSessionMemoryHook, createSessionNotification, createSessionRecoveryHook, createStartWorkHook, createTaskResumeInfoHook, createThinkModeHook } from "../../hooks";
+import { createAnthropicEffortHook } from "../../hooks/anthropic-effort/hook";
+import type { NativePluginContext } from "../../shared/session-context-source";
+export type SessionHooks = {
+    contextWindowMonitor: ReturnType<typeof createContextWindowMonitorHook> | null;
+    sessionRecovery: ReturnType<typeof createSessionRecoveryHook> | null;
+    sessionNotification: ReturnType<typeof createSessionNotification> | null;
+    thinkMode: ReturnType<typeof createThinkModeHook> | null;
+    contextWindowLimitRecovery: ReturnType<typeof createContextWindowLimitRecoveryHook> | null;
+    autoUpdateChecker: ReturnType<typeof createAutoUpdateCheckerHook> | null;
+    agentUsageReminder: ReturnType<typeof createAgentUsageReminderHook> | null;
+    nonInteractiveEnv: ReturnType<typeof createNonInteractiveEnvHook> | null;
+    interactiveBashSession: ReturnType<typeof createInteractiveBashSessionHook> | null;
+    matrixLoop: ReturnType<typeof createMatrixLoopHook> | null;
+    editErrorRecovery: ReturnType<typeof createEditErrorRecoveryHook> | null;
+    delegateTaskRetry: ReturnType<typeof createDelegateTaskRetryHook> | null;
+    startWork: ReturnType<typeof createStartWorkHook> | null;
+    oracleMdOnly: ReturnType<typeof createOracleMdOnlyHook> | null;
+    mouseNotepad: ReturnType<typeof createMouseNotepadHook> | null;
+    taskResumeInfo: ReturnType<typeof createTaskResumeInfoHook>;
+    anthropicEffort: ReturnType<typeof createAnthropicEffortHook> | null;
+    runtimeFallback: ReturnType<typeof createRuntimeFallbackHook> | null;
+    rtkBashRewriter: ReturnType<typeof createRtkBashRewriterHook> | null;
+    sessionMemory: ReturnType<typeof createSessionMemoryHook> | null;
+};
+export declare function createSessionHooks(args: {
+    ctx: NativePluginContext;
+    pluginConfig: MatrixxConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): SessionHooks;

package/dist/plugin/hooks/create-skill-hooks.d.ts

@@ -0,0 +1,16 @@
+import type { AvailableSkill } from "../../agents/dynamic-agent-prompt-builder";
+import type { HookName } from "../../config";
+import { createAutoSlashCommandHook, createCategorySkillReminderHook } from "../../hooks";
+import type { BuiltinSkill } from "../../skills";
+import type { MatrixxContext } from "../context";
+export type SkillHooks = {
+    categorySkillReminder: ReturnType<typeof createCategorySkillReminderHook> | null;
+    autoSlashCommand: ReturnType<typeof createAutoSlashCommandHook> | null;
+};
+export declare function createSkillHooks(args: {
+    ctx: MatrixxContext;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+    builtinSkills: BuiltinSkill[];
+    availableSkills: AvailableSkill[];
+}): SkillHooks;

package/dist/plugin/hooks/create-tool-guard-hooks.d.ts

@@ -0,0 +1,38 @@
+import type { HookName, MatrixxConfig } from "../../config";
+import { createBackgroundTaskBlockerHook, createBashFileReadGuardHook, createCommentCheckerHooks, createContextModeEnforcerHook, createDirectoryAgentsInjectorHook, createDocsLookupGuardHook, createDocumentReaderGuardHook, createEmptyTaskResponseDetectorHook, createEnvFileWriteGuardHook, createEvolutionWatcherHook, createHashlineReadEnhancerHook, createJsonErrorRecoveryHook, createKnowledgeHubGuardHook, createKnowledgeHubSearchNudgeHook, createQualityGateHook, createReadImageResizerHook, createRulesInjectorHook, createSecretLeakGuardHook, createSoftwareDevEnforcementHook, createSubagentBlockHook, createTaskEditGuardHook, createTaskNotepadWriterHook, createToolOutputTruncatorHook, createWebFetchRedirectGuardHook, createWriteExistingFileGuardHook } from "../../hooks";
+import { createSilentFailureGuardHook } from "../../hooks/silent-failure-guard";
+import type { MatrixxContext } from "../context";
+export type ToolGuardHooks = {
+    backgroundTaskBlocker: ReturnType<typeof createBackgroundTaskBlockerHook> | null;
+    commentChecker: ReturnType<typeof createCommentCheckerHooks> | null;
+    toolOutputTruncator: ReturnType<typeof createToolOutputTruncatorHook> | null;
+    directoryAgentsInjector: ReturnType<typeof createDirectoryAgentsInjectorHook> | null;
+    emptyTaskResponseDetector: ReturnType<typeof createEmptyTaskResponseDetectorHook> | null;
+    rulesInjector: ReturnType<typeof createRulesInjectorHook> | null;
+    writeExistingFileGuard: ReturnType<typeof createWriteExistingFileGuardHook> | null;
+    silentFailureGuard: ReturnType<typeof createSilentFailureGuardHook> | null;
+    hashlineReadEnhancer: ReturnType<typeof createHashlineReadEnhancerHook> | null;
+    secretLeakGuard: ReturnType<typeof createSecretLeakGuardHook> | null;
+    envFileWriteGuard: ReturnType<typeof createEnvFileWriteGuardHook> | null;
+    jsonErrorRecovery: ReturnType<typeof createJsonErrorRecoveryHook> | null;
+    bashFileReadGuard: ReturnType<typeof createBashFileReadGuardHook> | null;
+    contextModeEnforcer: ReturnType<typeof createContextModeEnforcerHook> | null;
+    readImageResizer: ReturnType<typeof createReadImageResizerHook> | null;
+    webfetchRedirectGuard: ReturnType<typeof createWebFetchRedirectGuardHook> | null;
+    qualityGate: ReturnType<typeof createQualityGateHook> | null;
+    taskEditGuard: ReturnType<typeof createTaskEditGuardHook> | null;
+    subagentBlock: ReturnType<typeof createSubagentBlockHook> | null;
+    softwareDevEnforcement: ReturnType<typeof createSoftwareDevEnforcementHook> | null;
+    taskNotepadWriter: ReturnType<typeof createTaskNotepadWriterHook> | null;
+    documentReaderGuard: ReturnType<typeof createDocumentReaderGuardHook> | null;
+    docsLookupGuard: ReturnType<typeof createDocsLookupGuardHook> | null;
+    knowledgeHubGuard: ReturnType<typeof createKnowledgeHubGuardHook> | null;
+    knowledgeHubSearchNudge: ReturnType<typeof createKnowledgeHubSearchNudgeHook> | null;
+    evolutionWatcher: ReturnType<typeof createEvolutionWatcherHook> | null;
+};
+export declare function createToolGuardHooks(args: {
+    ctx: MatrixxContext;
+    pluginConfig: MatrixxConfig;
+    isHookEnabled: (hookName: HookName) => boolean;
+    safeHookEnabled: boolean;
+}): ToolGuardHooks;