opencode-matrixx-v2 0.0.0-stage → 1.1.0

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

@@ -0,0 +1,29 @@
+import type { MatrixxConfig } from "../../config";
+import { createContextInjectorMessagesTransformHook } from "../../features/context-injector";
+import { createContextModeSystemTransformHook } from "../../features/context-mode-routing/system-transform";
+import { createRtkSystemTransformHook } from "../../features/rtk-routing/system-transform";
+import { createDesignIntentPreserverHook, createEnvContextInjectorHook, createKeywordDetectorHook, createKnowledgeHubInjectorHook, createThinkingBlockValidatorHook, createToolPairValidatorHook } from "../../hooks";
+import { createDcpNudgeSanitizerHook } from "../../hooks/dcp-nudge-sanitizer/hook";
+import { createDomainKeywordDetectorHook } from "../../hooks/domain-keyword-detector";
+import { createInputSecretGuardHook } from "../../hooks/input-secret-guard/hook";
+import type { NativePluginContext } from "../../shared/session-context-source";
+export type TransformHooks = {
+    inputSecretGuard: ReturnType<typeof createInputSecretGuardHook> | null;
+    keywordDetector: ReturnType<typeof createKeywordDetectorHook> | null;
+    domainKeywordDetector: ReturnType<typeof createDomainKeywordDetectorHook> | null;
+    contextInjectorMessagesTransform: ReturnType<typeof createContextInjectorMessagesTransformHook>;
+    knowledgeHubInjector: ReturnType<typeof createKnowledgeHubInjectorHook> | null;
+    envContextInjector: ReturnType<typeof createEnvContextInjectorHook> | null;
+    thinkingBlockValidator: ReturnType<typeof createThinkingBlockValidatorHook> | null;
+    dcpNudgeSanitizer: ReturnType<typeof createDcpNudgeSanitizerHook> | null;
+    toolPairValidator: ReturnType<typeof createToolPairValidatorHook> | null;
+    designIntentPreserver: ReturnType<typeof createDesignIntentPreserverHook> | null;
+    contextModeRouting: ReturnType<typeof createContextModeSystemTransformHook>;
+    rtkRouting: ReturnType<typeof createRtkSystemTransformHook>;
+};
+export declare function createTransformHooks(args: {
+    ctx: NativePluginContext;
+    pluginConfig: MatrixxConfig;
+    isHookEnabled: (hookName: string) => boolean;
+    safeHookEnabled?: boolean;
+}): TransformHooks;

package/dist/plugin/legacy-hooks.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Local copy of the V1 host hook map (`Hooks` from the V1 plugin package).
+ *
+ * Task 24 relocation: every `import type { Hooks } from "./legacy-hooks"`
+ * now resolves here instead of the V1 package, so the substrate deletion does
+ * not change behavior. The shape is verbatim (only `MatrixxToolDefinition` points at
+ * `MatrixxToolDefinition`); tasks 25-27 replace these fragments with native
+ * `session.hook(...)` registrations and then this module goes away.
+ */
+export type Auth = Record<string, unknown>;
+export type Event = Record<string, unknown> & {
+    type?: string;
+};
+export type Message = Record<string, unknown>;
+export type Model = Record<string, unknown> & {
+    providerID?: string;
+    modelID?: string;
+};
+export type Part = {
+    type: string;
+    text?: string;
+    [key: string]: unknown;
+};
+export type Permission = Record<string, unknown>;
+export type Provider = Record<string, unknown>;
+export type SDKConfig = Record<string, unknown>;
+export type UserMessage = Record<string, unknown>;
+export type ModelV2 = Record<string, unknown>;
+export type ProviderV2 = Record<string, unknown>;
+import type { MatrixxToolDefinition } from "../tools/shared/define-tool";
+export type ProviderContext = {
+    source: "env" | "config" | "custom" | "api";
+    info: Provider;
+    options: Record<string, unknown>;
+};
+export interface Hooks {
+    event?: (input: {
+        event: Event;
+    }) => Promise<void>;
+    config?: (input: SDKConfig) => Promise<void>;
+    tool?: {
+        [key: string]: MatrixxToolDefinition;
+    };
+    "chat.message"?: (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+        variant?: string;
+    }, output: {
+        message: UserMessage;
+        parts: Part[];
+    }) => Promise<void>;
+    "chat.params"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        temperature: number;
+        topP: number;
+        topK: number;
+        options: Record<string, unknown>;
+    }) => Promise<void>;
+    "chat.headers"?: (input: {
+        sessionID: string;
+        agent: string;
+        model: Model;
+        provider: ProviderContext;
+        message: UserMessage;
+    }, output: {
+        headers: Record<string, string>;
+    }) => Promise<void>;
+    "permission.ask"?: (input: Permission, output: {
+        status: "ask" | "deny" | "allow";
+    }) => Promise<void>;
+    "command.execute.before"?: (input: {
+        command: string;
+        sessionID: string;
+        arguments: string;
+    }, output: {
+        parts: Part[];
+    }) => Promise<void>;
+    "tool.execute.before"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+    "shell.env"?: (input: {
+        cwd: string;
+        sessionID?: string;
+        callID?: string;
+    }, output: {
+        env: Record<string, string>;
+    }) => Promise<void>;
+    "tool.execute.after"?: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args: Record<string, unknown>;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: Record<string, unknown>;
+    }) => Promise<void>;
+    "experimental.chat.messages.transform"?: (input: Record<string, unknown>, output: {
+        messages: {
+            info: Message;
+            parts: Part[];
+        }[];
+    }) => Promise<void>;
+    "experimental.chat.system.transform"?: (input: {
+        sessionID?: string;
+        model: Model;
+    }, output: {
+        system: string[];
+    }) => Promise<void>;
+    "experimental.session.compacting"?: (input: {
+        sessionID: string;
+    }, output: {
+        context: string[];
+        prompt?: string;
+    }) => Promise<void>;
+    "experimental.text.complete"?: (input: {
+        sessionID: string;
+        messageID: string;
+        partID: string;
+    }, output: {
+        text: string;
+    }) => Promise<void>;
+    "tool.definition"?: (input: {
+        toolID: string;
+    }, output: {
+        description: string;
+        parameters: Record<string, unknown>;
+    }) => Promise<void>;
+}

package/dist/plugin/message-hooks/context-injector.d.ts

@@ -0,0 +1,12 @@
+import { type ContextCollector } from "../../features/context-injector";
+import { type SessionMessage } from "../../shared/session-message";
+import type { MatrixxContext, V2Registration } from "../context";
+export interface FlatMessageHookEvent {
+    readonly sessionID: string;
+    messages: SessionMessage[];
+}
+export interface ContextInjectorDeps {
+    collector?: ContextCollector;
+}
+export declare function applyContextInjectorMessagesTransform(event: FlatMessageHookEvent, deps?: ContextInjectorDeps): Promise<void>;
+export declare function registerContextInjectorMessagesTransform(ctx: MatrixxContext, deps?: ContextInjectorDeps): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/dcp-nudge-sanitizer.d.ts

@@ -0,0 +1,43 @@
+/**
+ * DCP sticky-nudge sanitizer — flat `Message[]` port (Task 26, Group C).
+ *
+ * Behavior parity with `src/hooks/dcp-nudge-sanitizer/hook.ts`: sweep every
+ * message's `content` text blocks for DCP sticky-nudge markers, keep the first
+ * one (sanitized + trimmed + compress-availability guard), drop the rest, cap
+ * accumulation at ~1 per cycle. Non-text blocks are never touched. Operates on
+ * the V2 flat shape (`role` + `content`); messages without an array `content`
+ * are skipped without throwing.
+ *
+ * Ordering: Matrixx runs before DCP (plugin index 0 vs 1), so this sanitizer
+ * cleans prior-cycle sticky nudges and caps accumulation at ~1/cycle. It cannot
+ * suppress the nudge DCP injects later in the same cycle.
+ */
+import type { MatrixxContext, V2Registration, V2SessionContextEvent } from "../context";
+/** Minimal flat content block (text blocks carry `type: "text"` + `text`). */
+export type FlatContentBlock = {
+    readonly type?: unknown;
+    readonly text?: unknown;
+    [key: string]: unknown;
+};
+/** Minimal flat message (`role` + `content`, never `{info, parts}`). */
+export type FlatMessage = {
+    role?: unknown;
+    content?: unknown;
+    [key: string]: unknown;
+};
+/**
+ * Dedupe + cap sticky nudges across the transcript in place: the first nudge
+ * block is kept (sanitized, trimmed, guarded), every later one is removed.
+ * Empty input is a no-op; blocks without an array `content` are skipped.
+ */
+export declare function sanitizeNudgeMessages(messages: FlatMessage[]): void;
+/**
+ * Native session-hook entry point: mutates `event.messages` in place.
+ * A missing or non-array `messages` is a silent no-op (fail-open).
+ */
+export declare function handleDcpNudgeSanitizerEvent(event: V2SessionContextEvent): Promise<void>;
+/**
+ * Register the native entry point on every kind in its mapping-table row
+ * (`dcpNudgeSanitizer` -> `context`).
+ */
+export declare function registerDcpNudgeSanitizer(_ctx: MatrixxContext): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/domain-keyword-detector.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Native `session.hook("context")` port of the `domainKeywordDetector`
+ * `experimental.chat.messages.transform` hook (Task 26, Group A).
+ *
+ * Flat-`Message[]` twin of `src/hooks/domain-keyword-detector/hook.ts`:
+ * same scan (last user message text), same guards (idempotency marker,
+ * system-directive skip, tag sanitization), same splice
+ * (`hint + "\n\n---\n\n" + original`), same notify. The only shape change
+ * is V1 `{ info, parts }[]` -> flat `SessionMessage[]` (role is `.type`,
+ * user text is `.text`), and the session ID comes from the native event
+ * instead of `message.info.sessionID`.
+ */
+import { type SessionMessage } from "../../shared/session-message";
+import type { MatrixxContext, V2Registration } from "../context";
+/** Minimal flat-message view of the native context/compaction event. */
+export interface FlatMessageHookEvent {
+    readonly sessionID: string;
+    messages: SessionMessage[];
+}
+/**
+ * Scan the last user message for finance-domain keywords and prepend the
+ * compact skill hint. Mutates `event.messages` in place; no-op when there
+ * is no user message, no keyword match, or the hint is already present.
+ */
+export declare function applyDomainKeywordDetector(event: FlatMessageHookEvent, ctx?: MatrixxContext): Promise<void>;
+/**
+ * Register the flat port on every native kind in its mapping-table row
+ * (`domainKeywordDetector` -> `context`).
+ */
+export declare function registerDomainKeywordDetector(ctx: MatrixxContext): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/env-context-injector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Native `session.hook("context"|"compaction")` registration for the
+ * `envContextInjector` mapping-table row (Task 27).
+ *
+ * Thin registration wrapper: delegates to the Task 26 flat-`Message[]` port
+ * (`applyEnvContextInjector` in `src/hooks/env-context-injector/flat.ts`).
+ * Same targets (`context`, `compaction`), same call shape, no behavior change.
+ */
+import type { MatrixxContext, V2Registration } from "../context";
+/**
+ * Register the flat port on every native kind in its mapping-table row
+ * (`envContextInjector` -> `context`, `compaction`).
+ */
+export declare function registerEnvContextInjector(ctx: MatrixxContext): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/evolution-hitl.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Native `session.hook("context")` registration for the `evolutionHitl`
+ * mapping-table row (Task 27).
+ *
+ * Thin registration wrapper: delegates to the Task 26 flat-`Message[]` port
+ * (`applyEvolutionHitl` in `src/hooks/evolution-hitl/flat.ts`). Same target
+ * (`context`), same call shape (config + deps passthrough), no behavior change.
+ */
+import { type EvolutionHitlDeps } from "../../hooks/evolution-hitl/flat";
+import type { MatrixxContext, V2Registration } from "../context";
+/**
+ * Register the flat port on every native kind in its mapping-table row
+ * (`evolutionHitl` -> `context`).
+ */
+export declare function registerEvolutionHitl(ctx: MatrixxContext, deps?: EvolutionHitlDeps & {
+    config?: unknown;
+}): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/index.d.ts

@@ -0,0 +1,54 @@
+import type { EvolutionHitlDeps } from "../../hooks/evolution-hitl/flat";
+import type { SessionMessage } from "../../shared/session-message";
+import type { MatrixxContext, V2Registration } from "../context";
+import { type ContextInjectorDeps } from "./context-injector";
+import { type KnowledgeHubInjectorDeps } from "./knowledge-hub-injector";
+/** Native session hook kinds that carry messages. */
+export type NativeMessageHookKind = "context" | "compaction" | "generate";
+/**
+ * The 8 transform hooks, keyed exactly as in `DomainHooks`
+ * (`TransformHooks` for the first seven, `ContinuationHooks` for `evolutionHitl`).
+ */
+export type MessageHookName = "domainKeywordDetector" | "knowledgeHubInjector" | "contextInjectorMessagesTransform" | "envContextInjector" | "thinkingBlockValidator" | "evolutionHitl" | "dcpNudgeSanitizer" | "toolPairValidator";
+export interface MessageHookRow {
+    /** What the hook reads in the V1 `experimental.chat.messages.transform` payload. */
+    readonly hook: MessageHookName;
+    /** What the hook reads in the V1 `experimental.chat.messages.transform` payload. */
+    readonly v1Reads: string;
+    /** What the hook reads in the V2 flat-`Message[]` session event. */
+    readonly v2Reads: string;
+    /** Native session-hook kinds this hook registers on (never empty). */
+    readonly targetHooks: readonly NativeMessageHookKind[];
+}
+/**
+ * The 8-row mapping table, in legacy fan-out call order.
+ * Task 26 ports one flat-`Message[]` body per row.
+ */
+export declare const MESSAGE_HOOK_TABLE: readonly MessageHookRow[];
+/**
+ * Fail-closed shape gate for the mapping table (Task 25 negative controls):
+ * - exactly 8 rows,
+ * - no row with an empty `targetHooks` (a hook registered nowhere runs nowhere),
+ * - `toolPairValidator` includes `generate` (auxiliary requests bypass `context`).
+ */
+export declare function validateMessageHookTable(table: readonly MessageHookRow[]): void;
+/** Optional per-hook dependency overrides for the Task 26 flat ports. */
+export interface MessageHookDeps {
+    readonly knowledgeHub?: KnowledgeHubInjectorDeps;
+    readonly contextInjector?: ContextInjectorDeps;
+    readonly evolutionHitl?: EvolutionHitlDeps & {
+        readonly config?: unknown;
+    };
+}
+/**
+ * Register every mapping row through its per-hook module in
+ * `MESSAGE_HOOK_TABLE` order (the legacy fan-out call order). Each module
+ * registers one native hook per target kind in its row and dispatches to
+ * the Task 26 flat-`Message[]` port, so every row is live.
+ * Design intent (layout, rhythm, affordances) is untouched.
+ *
+ * Each registered callback is fail-open on malformed input: an event without
+ * a `messages` array is a no-op that never throws.
+ */
+export declare function registerMessageHooks(ctx: MatrixxContext, deps?: MessageHookDeps): Promise<V2Registration[]>;
+export type { SessionMessage };

package/dist/plugin/message-hooks/knowledge-hub-injector.d.ts

@@ -0,0 +1,18 @@
+import type { KnowledgeHub } from "../../config/schema/knowledge";
+import { type ContextCollector } from "../../features/context-injector";
+import { type SessionMessage } from "../../shared/session-message";
+import type { MatrixxContext, V2Registration } from "../context";
+export interface FlatMessageHookEvent {
+    readonly sessionID: string;
+    messages: SessionMessage[];
+}
+export interface KnowledgeHubInjectorDeps {
+    getHubs?: () => KnowledgeHub[];
+    collector?: ContextCollector;
+    pinnedFiles?: string[];
+    workspaceDir?: string;
+}
+export declare function _resetKnowledgeHubInjectorForTesting(): void;
+export declare function clearKnowledgeHubSession(sessionID: string, collector?: ContextCollector): void;
+export declare function applyKnowledgeHubInjector(event: FlatMessageHookEvent, ctx: MatrixxContext, deps?: KnowledgeHubInjectorDeps): Promise<void>;
+export declare function registerKnowledgeHubInjector(ctx: MatrixxContext, deps?: KnowledgeHubInjectorDeps): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/thinking-block-validator.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Native `session.hook("context"|"generate")` registration for the
+ * `thinkingBlockValidator` mapping-table row (Task 27).
+ *
+ * Thin registration wrapper: delegates to the Task 26 flat-`Message[]` port
+ * (`applyThinkingBlockValidator` in `src/hooks/thinking-block-validator/flat.ts`).
+ * Same targets (`context`, `generate`), same call shape, no behavior change.
+ * `generate` coverage matters because auxiliary requests bypass `context`.
+ */
+import type { MatrixxContext, V2Registration } from "../context";
+/**
+ * Register the flat port on every native kind in its mapping-table row
+ * (`thinkingBlockValidator` -> `context`, `generate`).
+ */
+export declare function registerThinkingBlockValidator(ctx: MatrixxContext): Promise<V2Registration[]>;

package/dist/plugin/message-hooks/tool-pair-validator.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Tool call/result pair validator — flat `Message[]` port (Task 26, Group C).
+ *
+ * Behavior parity with `src/hooks/tool-pair-validator/hook.ts`: every assistant
+ * message's tool calls (`tool_use` by `id`, AssistantTool `tool` blocks by
+ * `callID`) must have a matching `tool_result` in the next user message. A
+ * missing result is inserted there; when the next message is not a user message
+ * a synthetic `{ role: "user" }` message is spliced in. Operates on the V2 flat
+ * shape (`role` + `content`); messages without an array `content` never throw.
+ */
+import type { MatrixxContext, V2Registration, V2SessionContextEvent } from "../context";
+/** Minimal flat content block (tool calls, results, and text). */
+export type FlatContentBlock = {
+    readonly type?: unknown;
+    readonly id?: unknown;
+    readonly callID?: unknown;
+    readonly tool_use_id?: unknown;
+    readonly content?: unknown;
+    [key: string]: unknown;
+};
+/** Minimal flat message (`role` + `content`, never `{info, parts}`). */
+export type FlatMessage = {
+    id?: unknown;
+    role?: unknown;
+    content?: unknown;
+    sessionID?: unknown;
+    [key: string]: unknown;
+};
+/**
+ * Repair every assistant message's unmatched tool calls in place, in order.
+ * Empty input is a no-op; messages without an array `content` never throw.
+ */
+export declare function repairToolPairMessages(messages: FlatMessage[]): void;
+/**
+ * Native session-hook entry point: mutates `event.messages` in place.
+ * A missing or non-array `messages` is a silent no-op (fail-open). The same
+ * entry point serves both `context` and `generate` registrations — auxiliary
+ * requests bypass `context`, so `generate` coverage is what keeps them paired.
+ */
+export declare function handleToolPairValidatorEvent(event: V2SessionContextEvent): Promise<void>;
+/**
+ * Register the native entry point on every kind in its mapping-table row
+ * (`toolPairValidator` -> `context`, `generate`). The same entry point serves
+ * both registrations — auxiliary requests bypass `context`, so `generate`
+ * coverage is what keeps them paired.
+ */
+export declare function registerToolPairValidator(_ctx: MatrixxContext): Promise<V2Registration[]>;

package/dist/plugin/native-context.d.ts

@@ -0,0 +1,12 @@
+import type { NativePluginContext } from "../shared/session-context-source";
+import type { MatrixxContext } from "./context";
+/**
+ * Builds the native plugin context the matrixx core runs against.
+ *
+ * The V2 plugin runs in-process, so there is no HTTP client to inject:
+ * `session`/`agent`/`model` are the live V2 domains and every consumer
+ * reads them through `SessionContextCarrier` / `NativeDomains`. The token
+ * no longer travels over HTTP, which is why the old client-auth injection
+ * has no native twin.
+ */
+export declare function createNativePluginContext(ctx: MatrixxContext): NativePluginContext;

package/dist/plugin/recent-synthetic-idles.d.ts

@@ -0,0 +1,6 @@
+export declare function pruneRecentSyntheticIdles(args: {
+    recentSyntheticIdles: Map<string, number>;
+    recentRealIdles: Map<string, number>;
+    now: number;
+    dedupWindowMs: number;
+}): void;

package/dist/plugin/session-agent-resolver.d.ts

@@ -0,0 +1,2 @@
+import type { SessionContextCarrier } from "../shared/session-context-source";
+export declare function resolveSessionAgent(client: SessionContextCarrier, sessionId: string, timeoutMs?: number): Promise<string | undefined>;

package/dist/plugin/session-status-normalizer.d.ts

@@ -0,0 +1,2 @@
+import type { V2Event } from "./context";
+export declare function normalizeSessionStatusToIdle(input: V2Event): V2Event | null;

package/dist/plugin/setup-domains.d.ts

@@ -0,0 +1,112 @@
+/**
+ * V2 composition root for the matrixx plugin (TODO 9 / D1).
+ *
+ * Replaces the 10-step plugin factory, the manager/hook/tool wrapper
+ * modules, the plugin-interface assembly, the 3-tier hook grouping, and
+ * the generic V1 hook fan-out bridge.
+ *
+ * Domain setup functions build `Hooks` fragments directly; `registerDomains`
+ * applies them onto the V2 context with the same adapters the bridge used
+ * (`emitToolInfo` plus per-domain `transform` registrars).
+ *
+ * Still load-bearing below this module (owned by later TODOs):
+ * - the V1 `MatrixxContext` substrate (`./types`) every hook/tool is written against
+ * - the 6-phase config pipeline (`../plugin-handlers/config-handler`) that feeds the config draft
+ * - the unified compaction hook (Task 8)
+ *
+ * Native background/session lifecycle landed in Task 7 (D5): the slim
+ * `BackgroundManager` talks to `session.create`/`promptAsync` directly and
+ * the tmux pane mirror is gone.
+ */
+import type { AvailableCategory, AvailableSkill } from "../agents/dynamic-agent-prompt-builder";
+import type { MatrixxConfig } from "../config";
+import type { BrowserAutomationProvider } from "../config/schema/browser-automation";
+import type { BackgroundManager } from "../features/background-agent";
+import { createConfigHandler } from "../plugin-handlers";
+import { createFirstMessageVariantGate } from "../shared/first-message-variant";
+import type { NativePluginContext, SessionContextCarrier } from "../shared/session-context-source";
+import type { BuiltinSkill } from "../skills";
+import type { MatrixxContext, ToolsRecord, V2Registration } from "./context";
+import type { ContinuationHooks } from "./hooks/create-continuation-hooks";
+import type { SessionHooks } from "./hooks/create-session-hooks";
+import type { SkillHooks } from "./hooks/create-skill-hooks";
+import type { ToolGuardHooks } from "./hooks/create-tool-guard-hooks";
+import type { TransformHooks } from "./hooks/create-transform-hooks";
+import type { Hooks } from "./legacy-hooks";
+/** Managers owned by the composition root (moved from `create-managers.ts`). */
+export type DomainManagers = {
+    backgroundManager: BackgroundManager;
+    configHandler: ReturnType<typeof createConfigHandler>;
+};
+/**
+ * Every hook the plugin owns, keyed by domain. Same shape the 3-tier
+ * grouping produced — the tiers are gone, the leaf domains remain.
+ */
+export type DomainHooks = SessionHooks & ToolGuardHooks & TransformHooks & ContinuationHooks & SkillHooks;
+type FirstMessageVariantGate = ReturnType<typeof createFirstMessageVariantGate>;
+export type SetupToolsDomainResult = {
+    filteredTools: ToolsRecord;
+    builtinSkills: BuiltinSkill[];
+    availableSkills: AvailableSkill[];
+    availableCategories: AvailableCategory[];
+    browserProvider: BrowserAutomationProvider;
+    disabledSkills: Set<string>;
+    taskSystemEnabled: boolean;
+};
+/** Tool domain: skill context, categories, and the filtered tool registry. */
+export declare function setupToolsDomain(args: {
+    ctx: NativePluginContext;
+    pluginConfig: MatrixxConfig;
+    managers: Pick<DomainManagers, "backgroundManager">;
+    systemDefaultModel?: () => Promise<string | undefined>;
+}): Promise<SetupToolsDomainResult>;
+/** Chat domain: message, params, and message/system transforms. */
+export declare function setupChatHooks(args: {
+    ctx: MatrixxContext;
+    pluginConfig: MatrixxConfig;
+    firstMessageVariantGate: FirstMessageVariantGate;
+    hooks: DomainHooks;
+}): Pick<Hooks, "chat.message" | "chat.params" | "experimental.chat.system.transform">;
+/** Tool domain: execute guards and tool definition passthrough. */
+export declare function setupToolHooks(args: {
+    ctx: MatrixxContext & SessionContextCarrier;
+    hooks: DomainHooks;
+}): Pick<Hooks, "tool.execute.before" | "tool.execute.after" | "tool.definition">;
+/** Compaction domain: the single session-compacting contributor. */
+export declare function setupCompactionHooks(args: {
+    hooks: DomainHooks;
+}): Pick<Hooks, "experimental.session.compacting">;
+/**
+ * Full init sequence (moved from the 10-step `plugin-factory`).
+ * Builds managers, tools, hooks, and the `Hooks` fragments the V2
+ * registration below consumes.
+ */
+export declare function setupDomains(ctx: MatrixxContext): Promise<{
+    directory: string;
+    worktree: string;
+    hooks: Hooks;
+}>;
+export interface RegisterDomainsInput {
+    ctx: MatrixxContext;
+    hooks: Hooks;
+    directory: string;
+    worktree: string;
+}
+export interface DomainRegistration {
+    registrations: V2Registration[];
+    controller: AbortController;
+    dispose(): Promise<void>;
+}
+/** Extract hook-visible text from a completed tool result.
+ *
+ * The host normalizes string content to a [{type: "text", text}] array before
+ * hooks run, so a string-only check drops every tool result (observed live as
+ * the empty task response). Join text parts; non-text parts contribute nothing.
+ */
+export declare function hookOutputText(content: unknown): string | undefined;
+/**
+ * Applies the assembled `Hooks` onto the V2 context.
+ * Returns the registration set whose `dispose` tears everything down.
+ */
+export declare function registerDomains(input: RegisterDomainsInput): Promise<DomainRegistration>;
+export {};

package/dist/plugin/skill-context.d.ts

@@ -0,0 +1,14 @@
+import type { AvailableSkill } from "../agents/dynamic-agent-prompt-builder";
+import type { MatrixxConfig } from "../config";
+import type { BrowserAutomationProvider } from "../config/schema/browser-automation";
+import { type BuiltinSkill } from "../skills";
+export type SkillContext = {
+    builtinSkills: BuiltinSkill[];
+    availableSkills: AvailableSkill[];
+    browserProvider: BrowserAutomationProvider;
+    disabledSkills: Set<string>;
+};
+export declare function createSkillContext(args: {
+    directory: string;
+    pluginConfig: MatrixxConfig;
+}): Promise<SkillContext>;

package/dist/plugin/tool-catalog.d.ts

@@ -0,0 +1,18 @@
+import type { AvailableCategory } from "../agents/dynamic-agent-prompt-builder";
+import type { MatrixxConfig } from "../config";
+import type { NativePluginContext } from "../shared/session-context-source";
+import type { ToolsRecord } from "./context";
+import type { DomainManagers } from "./setup-domains";
+import type { SkillContext } from "./skill-context";
+export type ToolCatalogResult = {
+    filteredTools: ToolsRecord;
+    taskSystemEnabled: boolean;
+};
+export declare function createToolCatalog(args: {
+    ctx: NativePluginContext;
+    pluginConfig: MatrixxConfig;
+    managers: Pick<DomainManagers, "backgroundManager">;
+    skillContext: SkillContext;
+    availableCategories: AvailableCategory[];
+    systemDefaultModel?: () => Promise<string | undefined>;
+}): ToolCatalogResult;

package/dist/plugin/tool-definition.d.ts

@@ -0,0 +1,11 @@
+import { defineTool } from "../tools/shared/define-tool";
+import type { DomainHooks } from "./setup-domains";
+export declare const toolAuthoringEntry: typeof defineTool;
+export declare function createToolDefinitionHandler(args: {
+    hooks: DomainHooks;
+}): (input: {
+    toolID: string;
+}, output: {
+    description: string;
+    parameters: unknown;
+}) => Promise<void>;

package/dist/plugin/tool-execute-after.d.ts

@@ -0,0 +1,12 @@
+import type { DomainHooks } from "./setup-domains";
+export declare function createToolExecuteAfterHandler(args: {
+    hooks: DomainHooks;
+}): (input: {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}, output: {
+    title: string;
+    output: string;
+    metadata: Record<string, unknown>;
+} | undefined) => Promise<void>;

package/dist/plugin/tool-execute-before.bench.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/plugin/tool-execute-before.d.ts

@@ -0,0 +1,14 @@
+import type { SessionContextCarrier } from "../shared/session-context-source";
+import type { MatrixxContext } from "./context";
+import type { DomainHooks } from "./setup-domains";
+export declare function createToolExecuteBeforeHandler(args: {
+    ctx: MatrixxContext & SessionContextCarrier;
+    hooks: DomainHooks;
+}): (input: {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}, output: {
+    args: Record<string, unknown>;
+    message?: string;
+}) => Promise<void>;