opencode-matrixx-v2 0.0.0-stage → 1.1.0

package/dist/hooks/comment-checker/downloader.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Get the cache directory for matrixx binaries.
+ * On Windows: Uses %LOCALAPPDATA% or %APPDATA% (Windows conventions)
+ * On Unix: Follows XDG Base Directory Specification
+ */
+export declare function getCacheDir(): string;
+/**
+ * Get the binary name based on platform.
+ */
+export declare function getBinaryName(): string;
+/**
+ * Get the cached binary path if it exists.
+ */
+export declare function getCachedBinaryPath(): string | null;
+/**
+ * Ensure the comment-checker binary is available.
+ * First checks cache, then downloads if needed.
+ * Returns the binary path or null if unavailable.
+ */
+export declare function ensureCommentCheckerBinary(): Promise<string | null>;

package/dist/hooks/comment-checker/hook.d.ts

@@ -0,0 +1,19 @@
+import type { CommentCheckerConfig } from "../../config/schema";
+export declare function createCommentCheckerHooks(config?: CommentCheckerConfig): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/comment-checker/pending-calls.d.ts

@@ -0,0 +1,4 @@
+import type { PendingCall } from "./types";
+export declare function startPendingCallCleanup(): void;
+export declare function registerPendingCall(callID: string, pendingCall: PendingCall): void;
+export declare function takePendingCall(callID: string): PendingCall | undefined;

package/dist/hooks/comment-checker/types.d.ts

@@ -0,0 +1,13 @@
+export interface PendingCall {
+    filePath: string;
+    content?: string;
+    oldString?: string;
+    newString?: string;
+    edits?: Array<{
+        old_string: string;
+        new_string: string;
+    }>;
+    tool: "write" | "edit" | "multiedit";
+    sessionID: string;
+    timestamp: number;
+}

package/dist/hooks/compaction-context-injector/hook.d.ts

@@ -0,0 +1,8 @@
+import type { BackgroundManager } from "../../features/background-agent";
+import { type CompactingSnippetInput } from "../../features/session-memory";
+export declare const MAX_TASK_HISTORY_CHARS = 1500;
+export interface CompactionMemoryOptions {
+    enabled?: boolean;
+    snippet?: CompactingSnippetInput;
+}
+export declare function createCompactionContextInjector(backgroundManager?: BackgroundManager, memoryOptions?: CompactionMemoryOptions): (sessionID?: string, memoryOverride?: CompactionMemoryOptions) => string;

package/dist/hooks/context-mode-enforcer/constants.d.ts

@@ -0,0 +1,9 @@
+import { CONTEXT_MODE_DEFAULT_BLOCKED_TOOLS } from "../../shared/context-mode-enforcement";
+export declare const HOOK_NAME = "context-mode-enforcer";
+export declare const WARN_MESSAGE_READ: string;
+export declare const BLOCK_MESSAGE_GREP_GLOB: string;
+export declare const WARN_MESSAGE_BASH_READ: string;
+export declare const WEBFETCH_BLOCK_MESSAGE: string;
+export declare const BASH_ROUTED_MESSAGE: string;
+export declare const DEFAULT_BLOCKED_TOOLS: typeof CONTEXT_MODE_DEFAULT_BLOCKED_TOOLS;
+export declare const WARN_ONLY_TOOLS: readonly ["read"];

package/dist/hooks/context-mode-enforcer/guidance-throttle.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Returns `true` at most once per (session, type); every later call for the
+ * same pair returns `false`.
+ */
+export declare function shouldShowGuidance(sessionID: string | undefined, type: string): boolean;
+/** Test-only: clear the in-memory layer. File markers are left untouched. */
+export declare function _resetGuidanceThrottleForTesting(): void;

package/dist/hooks/context-mode-enforcer/hook.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxConfig } from "../../config";
+import type { Hooks } from "../../plugin/legacy-hooks";
+export declare function createContextModeEnforcerHook(pluginConfig: MatrixxConfig): Hooks;

package/dist/hooks/context-window-limit-recovery/client.d.ts

@@ -0,0 +1,2 @@
+import type { NativePluginContext } from "../../shared/session-context-source";
+export type Client = NativePluginContext;

package/dist/hooks/context-window-limit-recovery/empty-content-recovery.d.ts

@@ -0,0 +1,8 @@
+import type { Client } from "./client";
+import type { AutoCompactState } from "./types";
+export declare function fixEmptyMessages(params: {
+    sessionID: string;
+    autoCompactState: AutoCompactState;
+    client: Client;
+    messageIndex?: number;
+}): Promise<boolean>;

package/dist/hooks/context-window-limit-recovery/executor.d.ts

@@ -0,0 +1,5 @@
+import type { ExperimentalConfig } from "../../config";
+import type { Client } from "./client";
+import type { AutoCompactState } from "./types";
+export { getLastAssistant } from "./message-builder";
+export declare function executeCompact(sessionID: string, msg: Record<string, unknown>, autoCompactState: AutoCompactState, client: Client, directory: string, experimental?: ExperimentalConfig): Promise<void>;

package/dist/hooks/context-window-limit-recovery/index.d.ts

@@ -0,0 +1,8 @@
+export { executeCompact, getLastAssistant } from "./executor";
+export * from "./message-builder";
+export { parseAnthropicTokenLimitError, parseTokenLimitError } from "./parser";
+export type { AnthropicContextWindowLimitRecoveryOptions, ContextWindowLimitRecoveryOptions } from "./recovery-hook";
+export { createAnthropicContextWindowLimitRecoveryHook, createContextWindowLimitRecoveryHook } from "./recovery-hook";
+export * from "./state";
+export * from "./summarize-retry-strategy";
+export type { AutoCompactState, ParsedTokenLimitError, TruncateState } from "./types";

package/dist/hooks/context-window-limit-recovery/message-builder.d.ts

@@ -0,0 +1,4 @@
+import type { SessionContextCarrier } from "../../shared/session-context-source";
+export declare const PLACEHOLDER_TEXT = "[user interrupted]";
+export declare function sanitizeEmptyMessagesBeforeSummarize(sessionID: string, client?: SessionContextCarrier): Promise<number>;
+export declare function getLastAssistant(sessionID: string, client: SessionContextCarrier): Promise<Record<string, unknown> | null>;

package/dist/hooks/context-window-limit-recovery/parser-patterns.d.ts

@@ -0,0 +1,11 @@
+export declare const TOKEN_LIMIT_PATTERNS: RegExp[];
+export declare const TOKEN_LIMIT_KEYWORDS: string[];
+export declare const THINKING_BLOCK_ERROR_PATTERNS: RegExp[];
+export declare const MESSAGE_INDEX_PATTERN: RegExp;
+export declare function extractTokensFromMessage(message: string): {
+    current: number;
+    max: number;
+} | null;
+export declare function extractMessageIndex(text: string): number | undefined;
+export declare function isThinkingBlockError(text: string): boolean;
+export declare function isTokenLimitError(text: string): boolean;

package/dist/hooks/context-window-limit-recovery/parser.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedTokenLimitError } from "./types";
+export { extractMessageIndex, extractTokensFromMessage, isThinkingBlockError, isTokenLimitError, MESSAGE_INDEX_PATTERN, THINKING_BLOCK_ERROR_PATTERNS, TOKEN_LIMIT_KEYWORDS, TOKEN_LIMIT_PATTERNS } from "./parser-patterns";
+export interface GenericErrorData {
+    type: "error";
+    error: {
+        type: string;
+        message: string;
+    };
+    request_id?: string;
+}
+/** @deprecated use GenericErrorData */
+export type AnthropicErrorData = GenericErrorData;
+export declare function parseTokenLimitError(err: unknown): ParsedTokenLimitError | null;
+/** @deprecated use parseTokenLimitError */
+export declare const parseAnthropicTokenLimitError: typeof parseTokenLimitError;

package/dist/hooks/context-window-limit-recovery/recovery-hook.d.ts

@@ -0,0 +1,11 @@
+import type { ExperimentalConfig } from "../../config";
+import type { V2Event } from "../../plugin/context";
+import type { NativePluginContext } from "../../shared/session-context-source";
+export interface AnthropicContextWindowLimitRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+export declare function createAnthropicContextWindowLimitRecoveryHook(ctx: NativePluginContext, options?: AnthropicContextWindowLimitRecoveryOptions): {
+    event: (event: V2Event) => Promise<void>;
+};
+export type ContextWindowLimitRecoveryOptions = AnthropicContextWindowLimitRecoveryOptions;
+export declare const createContextWindowLimitRecoveryHook: typeof createAnthropicContextWindowLimitRecoveryHook;

package/dist/hooks/context-window-limit-recovery/state.d.ts

@@ -0,0 +1,6 @@
+import type { AutoCompactState, RetryState, TruncateState } from "./types";
+export declare function getOrCreateRetryState(autoCompactState: AutoCompactState, sessionID: string): RetryState;
+export declare function getOrCreateTruncateState(autoCompactState: AutoCompactState, sessionID: string): TruncateState;
+export declare function clearSessionState(autoCompactState: AutoCompactState, sessionID: string): void;
+export declare function getEmptyContentAttempt(autoCompactState: AutoCompactState, sessionID: string): number;
+export declare function incrementEmptyContentAttempt(autoCompactState: AutoCompactState, sessionID: string): number;

package/dist/hooks/context-window-limit-recovery/summarize-retry-strategy.d.ts

@@ -0,0 +1,11 @@
+import type { Client } from "./client";
+import type { AutoCompactState } from "./types";
+export declare function runSummarizeRetryStrategy(params: {
+    sessionID: string;
+    msg: Record<string, unknown>;
+    autoCompactState: AutoCompactState;
+    client: Client;
+    directory: string;
+    errorType?: string;
+    messageIndex?: number;
+}): Promise<void>;

package/dist/hooks/context-window-limit-recovery/types.d.ts

@@ -0,0 +1,31 @@
+export interface ParsedTokenLimitError {
+    currentTokens: number;
+    maxTokens: number;
+    requestId?: string;
+    errorType: string;
+    providerID?: string;
+    modelID?: string;
+    messageIndex?: number;
+}
+export interface RetryState {
+    attempt: number;
+    lastAttemptTime: number;
+}
+export interface TruncateState {
+    truncateAttempt: number;
+    lastTruncatedPartId?: string;
+}
+export interface AutoCompactState {
+    pendingCompact: Set<string>;
+    errorDataBySession: Map<string, ParsedTokenLimitError>;
+    retryStateBySession: Map<string, RetryState>;
+    truncateStateBySession: Map<string, TruncateState>;
+    emptyContentAttemptBySession: Map<string, number>;
+    compactionInProgress: Set<string>;
+}
+export declare const RETRY_CONFIG: {
+    readonly maxAttempts: 2;
+    readonly initialDelayMs: 2000;
+    readonly backoffFactor: 2;
+    readonly maxDelayMs: 30000;
+};

package/dist/hooks/context-window-monitor.d.ts

@@ -0,0 +1,18 @@
+import type { MatrixxConfig } from "../config";
+import type { ExperimentalConfig } from "../config/schema/experimental";
+import type { MatrixxContext } from "../plugin/context";
+import type { V2Event } from "../plugin/context";
+export declare function createContextWindowMonitorHook(_ctx: MatrixxContext, pluginConfig?: MatrixxConfig | {
+    experimental?: ExperimentalConfig;
+}): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (event: V2Event) => Promise<void>;
+};

package/dist/hooks/dcp-nudge-sanitizer/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const NUDGE_MARKERS: RegExp[];
+export declare function normalizeNudgeText(text: string): string;
+export declare const COMPRESS_TOOL_REFERENCE: RegExp;
+export declare const COMPRESS_AVAILABILITY_GUARD: string;
+export declare function guardCompressDirective(text: string): string;

package/dist/hooks/dcp-nudge-sanitizer/hook.d.ts

@@ -0,0 +1,34 @@
+/**
+ * DCP Sticky-Nudge Sanitizer Hook
+ *
+ * Ordering constraint (do not "fix" by assuming otherwise):
+ * Matrixx registers `experimental.chat.messages.transform` BEFORE DCP (plugin
+ * index 0 vs 1), so this sanitizer runs before DCP injects this cycle's nudge.
+ * It therefore cleans PRIOR-cycle sticky nudge parts and caps accumulation at
+ * ~1 per cycle. It CANNOT suppress the nudge DCP injects later in the SAME
+ * cycle. Full same-cycle suppression requires the optional deploy step that
+ * reorders the `plugin` array so Matrixx runs after DCP.
+ */
+/**
+ * Local legacy part shape (Task 27: the V1 `experimental.chat.messages.transform`
+ * fan-out is deleted, so `legacy V1 SDK` part types are no longer imported).
+ * The live native port operates on flat `Message[]` in `src/plugin/message-hooks/`.
+ */
+type Part = {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+};
+import type { MatrixxContext } from "../../plugin/context";
+interface MessageWithParts {
+    info: unknown;
+    parts: Part[];
+}
+type MessagesTransformHook = {
+    "experimental.chat.messages.transform"?: (input: Record<string, never>, output: {
+        messages: MessageWithParts[];
+    }) => Promise<void>;
+};
+export declare function sanitizeNudgeParts(messages: MessageWithParts[]): void;
+export declare function createDcpNudgeSanitizerHook(_ctx: MatrixxContext): MessagesTransformHook;
+export {};

package/dist/hooks/delegate-task-retry/guidance.d.ts

@@ -0,0 +1,2 @@
+import { type DetectedError } from "./patterns";
+export declare function buildRetryGuidance(errorInfo: DetectedError): string;

package/dist/hooks/delegate-task-retry/hook.d.ts

@@ -0,0 +1,12 @@
+import type { MatrixxContext } from "../../plugin/context";
+export declare function createDelegateTaskRetryHook(_ctx: MatrixxContext): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/delegate-task-retry/patterns.d.ts

@@ -0,0 +1,11 @@
+export interface DelegateTaskErrorPattern {
+    pattern: string;
+    errorType: string;
+    fixHint: string;
+}
+export declare const DELEGATE_TASK_ERROR_PATTERNS: DelegateTaskErrorPattern[];
+export interface DetectedError {
+    errorType: string;
+    originalOutput: string;
+}
+export declare function detectDelegateTaskError(output: string): DetectedError | null;

package/dist/hooks/design-intent-preserver/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const HOOK_NAME = "design-intent-preserver";
+export declare const PLANS_DIR = ".matrixx/plans";
+export declare const PHASE_TRANSITION_PATTERN: RegExp;
+export declare const CONSTRUCT_INDICATORS: RegExp;
+export declare const IDEMPOTENCY_MARKER = "<design-intent-preservation>";
+export declare const INTENT_PRESERVATION_BLOCK = "<design-intent-preservation>\nThe previous phase included @construct / @web-designer / @frontend-ui-ux work. Visual decisions are FROZEN:\n- Layout, rhythm, hierarchy, motion, spacing, color\n- Affordances, responsiveness, component feel\nRoute ANY visual / responsive / motion / polish changes back to @construct or @web-designer.\nUse @source only for bounded mechanical follow-up that preserves design exactly\n(wiring, tests, type fixes, non-visual behavior).\nIf design intent must change, record why in .matrixx/drafts/design-changes.md first.\n</design-intent-preservation>";

package/dist/hooks/design-intent-preserver/hook.d.ts

@@ -0,0 +1,19 @@
+import type { MatrixxContext } from "../../plugin/context";
+import { type MessagePart } from "./phase-detector";
+type ChatMessageInput = {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+    messageID?: string;
+};
+type ChatMessageOutput = {
+    message: Record<string, unknown>;
+    parts: MessagePart[];
+};
+export declare function createDesignIntentPreserverHook(_ctx: MatrixxContext): {
+    "chat.message": (input: ChatMessageInput, output: ChatMessageOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/design-intent-preserver/phase-detector.d.ts

@@ -0,0 +1,8 @@
+export type MessagePart = {
+    type: string;
+    text?: string;
+};
+export declare function extractPromptText(parts: MessagePart[]): string;
+export declare function hasPhaseTransition(text: string): boolean;
+export declare function findMostRecentPlanFile(plansDir: string): string | null;
+export declare function planHasConstruct(filePath: string): boolean;

package/dist/hooks/directory-agents-injector/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const AGENTS_INJECTOR_STORAGE: string;
+export declare const AGENTS_FILENAME = "AGENTS.md";

package/dist/hooks/directory-agents-injector/finder.d.ts

@@ -0,0 +1,5 @@
+export declare function resolveFilePath(rootDirectory: string, path: string): string | null;
+export declare function findAgentsMdUp(input: {
+    startDir: string;
+    rootDir: string;
+}): Promise<string[]>;

package/dist/hooks/directory-agents-injector/hook.d.ts

@@ -0,0 +1,20 @@
+import type { MatrixxContext } from "../../plugin/context";
+export declare function createDirectoryAgentsInjectorHook(ctx: MatrixxContext): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: unknown;
+    }) => Promise<void>;
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (event: import("../../plugin/context").V2Event) => Promise<void>;
+};

package/dist/hooks/directory-agents-injector/injector.d.ts

@@ -0,0 +1,16 @@
+import type { MatrixxContext } from "../../plugin/context";
+import type { createDynamicTruncator } from "../../shared/dynamic-truncator";
+type DynamicTruncator = ReturnType<typeof createDynamicTruncator>;
+export declare function processFilePathForAgentsInjection(input: {
+    ctx: MatrixxContext;
+    truncator: DynamicTruncator;
+    sessionCaches: Map<string, Set<string>>;
+    filePath: string;
+    sessionID: string;
+    output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    };
+}): Promise<void>;
+export {};

package/dist/hooks/directory-agents-injector/storage.d.ts

@@ -0,0 +1 @@
+export declare const loadInjectedPaths: (sessionID: string) => Set<string>, saveInjectedPaths: (sessionID: string, paths: Set<string>) => void, clearInjectedPaths: (sessionID: string) => void;

package/dist/hooks/directory-injector/factory.d.ts

@@ -0,0 +1,34 @@
+import type { MatrixxContext, V2Event } from "../../plugin/context";
+import { createDynamicTruncator } from "../../shared/dynamic-truncator";
+export interface ToolExecuteInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+export interface ToolExecuteOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+export interface ToolExecuteBeforeOutput {
+    args: unknown;
+}
+type DynamicTruncator = ReturnType<typeof createDynamicTruncator>;
+type ProcessFileFunction = (input: {
+    ctx: MatrixxContext;
+    truncator: DynamicTruncator;
+    sessionCaches: Map<string, Set<string>>;
+    filePath: string;
+    sessionID: string;
+    output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    };
+}) => Promise<void>;
+export declare function createDirectoryInjectorHook(ctx: MatrixxContext, processFile: ProcessFileFunction, clearInjectedPaths: (sessionID: string) => void): {
+    "tool.execute.before": (input: ToolExecuteInput, output: ToolExecuteBeforeOutput) => Promise<void>;
+    "tool.execute.after": (input: ToolExecuteInput, output: ToolExecuteOutput) => Promise<void>;
+    event: (event: V2Event) => Promise<void>;
+};
+export {};

package/dist/hooks/directory-injector/index.d.ts

@@ -0,0 +1 @@
+export { createDirectoryInjectorHook } from "./factory";

package/dist/hooks/docs-lookup-guard/constants.d.ts

@@ -0,0 +1,6 @@
+export declare const HOOK_NAME = "docs-lookup-guard";
+export declare const OPERATOR_AGENT = "operator";
+export declare const GUARDED_TOOLS: Set<string>;
+export declare const DOC_INTENT_TRIGGERS: readonly ["library docs lookup", "framework API reference", "official documentation query", "versioned docs search"];
+export declare const NUDGE_MESSAGE: string;
+export declare const FALLBACK_MESSAGE: string;

package/dist/hooks/docs-lookup-guard/hook.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxContext } from "../../plugin/context";
+import type { Hooks } from "../../plugin/legacy-hooks";
+export declare function createDocsLookupGuardHook(ctx: MatrixxContext): Hooks;

package/dist/hooks/document-reader-guard/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HOOK_NAME = "document-reader-guard";
+export declare const BINARY_EXTENSIONS: readonly [".pdf", ".docx", ".doc", ".xlsx", ".xls", ".pptx", ".ppt", ".jpg", ".jpeg", ".png", ".gif", ".webp", ".mp3", ".wav"];
+export declare const BLOCKED_PATTERNS: RegExp[];
+export declare const READ_BLOCK_MESSAGE: string;
+export declare const BASH_BLOCK_MESSAGE: string;

package/dist/hooks/document-reader-guard/hook.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxContext } from "../../plugin/context";
+import type { Hooks } from "../../plugin/legacy-hooks";
+export declare function createDocumentReaderGuardHook(ctx: MatrixxContext): Hooks;

package/dist/hooks/domain-keyword-detector/constants.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Finance-domain keyword routing table.
+ *
+ * Each route maps a keyword pattern to the finance-domain skill(s) that should
+ * be surfaced to the model when that keyword appears in a user message. The
+ * detector is pure routing — it never touches the filesystem or the network.
+ */
+export interface DomainSkillRoute {
+    /** Keyword pattern (no `g` flag — the same RegExp is reused across calls). */
+    pattern: RegExp;
+    /** Skill names surfaced when the pattern matches. */
+    skills: string[];
+}
+/** Marker used to make injection idempotent across repeated transform passes. */
+export declare const DOMAIN_HINT_MARKER = "[domain-skills]";
+/** Hard cap on the injected hint so a detection can never bloat context. */
+export declare const MAX_DOMAIN_HINT_CHARS = 400;
+export declare const DOMAIN_SKILL_ROUTES: DomainSkillRoute[];

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

@@ -0,0 +1,16 @@
+/**
+ * Detects finance-domain keywords in `text` and returns the matching skill
+ * names (deduplicated, insertion order preserved).
+ */
+export declare function detectDomainSkills(text: string): string[];
+/**
+ * Builds the compact, capped context hint injected into the user message.
+ */
+export declare function buildDomainHint(skills: string[]): string;
+/**
+ * Extracts the concatenated text of all text parts of a message.
+ */
+export declare function extractMessageText(parts: Array<{
+    type?: string;
+    text?: string;
+}>): string;

package/dist/hooks/domain-keyword-detector/hook.d.ts

@@ -0,0 +1,26 @@
+import type { MatrixxContext } from "../../plugin/context";
+interface TransformMessage {
+    info: {
+        role?: string;
+    };
+    parts: Array<{
+        type?: string;
+        text?: string;
+    }>;
+}
+type MessagesTransformOutput = {
+    messages: TransformMessage[];
+};
+/**
+ * Routes the last user message to finance-domain skills.
+ *
+ * Runs on `experimental.chat.messages.transform`: it detects domain keywords
+ * (ccxt, zeromq, influxdb, grafana, telegram, websocket, perpetual/basis,
+ * unified symbols, asyncio, market data, silent failures) and prepends a
+ * compact, capped hint naming the matching skills. Pure routing — no file IO,
+ * never blocks, and idempotent via the `[domain-skills]` marker.
+ */
+export declare function createDomainKeywordDetectorHook(ctx?: MatrixxContext): {
+    "experimental.chat.messages.transform": (_input: Record<string, never>, output: MessagesTransformOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/domain-keyword-detector/index.d.ts

@@ -0,0 +1,3 @@
+export { DOMAIN_HINT_MARKER, DOMAIN_SKILL_ROUTES, type DomainSkillRoute, MAX_DOMAIN_HINT_CHARS, } from "./constants";
+export { buildDomainHint, detectDomainSkills, extractMessageText } from "./detector";
+export { createDomainKeywordDetectorHook } from "./hook";

package/dist/hooks/edit-error-recovery/hook.d.ts

@@ -0,0 +1,31 @@
+import type { MatrixxContext } from "../../plugin/context";
+/**
+ * Known Edit tool error patterns that indicate the AI made a mistake
+ */
+export declare const EDIT_ERROR_PATTERNS: readonly ["oldString and newString must be different", "oldString not found", "oldString found multiple times"];
+/**
+ * System reminder injected when Edit tool fails due to AI mistake
+ * Short, direct, and commanding - forces immediate corrective action
+ */
+export declare const EDIT_ERROR_REMINDER = "\n[EDIT ERROR - IMMEDIATE ACTION REQUIRED]\n\nYou made an Edit mistake. STOP and do this NOW:\n\n1. READ the file immediately to see its ACTUAL current state\n2. VERIFY what the content really looks like (your assumption was wrong)\n3. APOLOGIZE briefly to the user for the error\n4. CONTINUE with corrected action based on the real file content\n\nDO NOT attempt another edit until you've read and verified the file state.\n";
+/**
+ * Detects Edit tool errors caused by AI mistakes and injects a recovery reminder
+ *
+ * This hook catches common Edit tool failures:
+ * - oldString and newString must be different (trying to "edit" to same content)
+ * - oldString not found (wrong assumption about file content)
+ * - oldString found multiple times (ambiguous match, need more context)
+ *
+ * @see https://github.com/sst/opencode/issues/4718
+ */
+export declare function createEditErrorRecoveryHook(_ctx: MatrixxContext): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/empty-task-response-detector.d.ts

@@ -0,0 +1,12 @@
+import type { MatrixxContext } from "../plugin/context";
+export declare function createEmptyTaskResponseDetectorHook(_ctx: MatrixxContext): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};

package/dist/hooks/env-context-injector/flat.d.ts

@@ -0,0 +1,22 @@
+import type { MatrixxContext } from "../../plugin/context";
+export interface FlatContentPart {
+    type?: string;
+    text?: string;
+    [key: string]: unknown;
+}
+export interface FlatMessage {
+    id?: string;
+    role?: string;
+    type?: string;
+    text?: string;
+    content?: FlatContentPart[];
+    [key: string]: unknown;
+}
+export interface FlatSessionEvent {
+    readonly sessionID?: string;
+    readonly kind?: string;
+    readonly messages?: FlatMessage[] | unknown;
+    readonly system?: unknown;
+    readonly [key: string]: unknown;
+}
+export declare function applyEnvContextInjector(event: FlatSessionEvent, ctx?: MatrixxContext): Promise<void>;