opencode-matrixx-v2 0.0.0-stage → 1.1.0

package/dist/hooks/runtime-fallback/fallback-bootstrap-model.d.ts

@@ -0,0 +1,10 @@
+import type { MatrixxConfig } from "../../config";
+type ResolveFallbackBootstrapModelOptions = {
+    sessionID: string;
+    source: string;
+    eventModel?: string;
+    resolvedAgent?: string;
+    pluginConfig?: MatrixxConfig;
+};
+export declare function resolveFallbackBootstrapModel(options: ResolveFallbackBootstrapModelOptions): string | undefined;
+export {};

package/dist/hooks/runtime-fallback/fallback-models.d.ts

@@ -0,0 +1,2 @@
+import type { MatrixxConfig } from "../../config";
+export declare function getFallbackModelsForSession(sessionID: string, agent: string | undefined, pluginConfig: MatrixxConfig | undefined): string[];

package/dist/hooks/runtime-fallback/fallback-retry-dispatcher.d.ts

@@ -0,0 +1,11 @@
+import type { AutoRetryHelpers } from "./auto-retry";
+import type { FallbackState, HookDeps } from "./types";
+type DispatchFallbackRetryOptions = {
+    sessionID: string;
+    state: FallbackState;
+    fallbackModels: string[];
+    resolvedAgent?: string;
+    source: string;
+};
+export declare function dispatchFallbackRetry(deps: HookDeps, helpers: AutoRetryHelpers, options: DispatchFallbackRetryOptions): Promise<void>;
+export {};

package/dist/hooks/runtime-fallback/fallback-state.d.ts

@@ -0,0 +1,4 @@
+import type { RuntimeFallbackConfig } from "../../config";
+import type { FallbackResult, FallbackState } from "./types";
+export declare function createFallbackState(originalModel: string): FallbackState;
+export declare function prepareFallback(sessionID: string, state: FallbackState, fallbackModels: string[], config: Required<RuntimeFallbackConfig>): FallbackResult;

package/dist/hooks/runtime-fallback/hook.d.ts

@@ -0,0 +1,2 @@
+import type { RuntimeFallbackContext, RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";
+export declare function createRuntimeFallbackHook(ctx: RuntimeFallbackContext, options?: RuntimeFallbackOptions): RuntimeFallbackHook;

package/dist/hooks/runtime-fallback/index.d.ts

@@ -0,0 +1,3 @@
+export { createRuntimeFallbackHook } from "./hook";
+export { SessionCategoryRegistry } from "./session-category-registry";
+export type { RuntimeFallbackHook, RuntimeFallbackOptions } from "./types";

package/dist/hooks/runtime-fallback/last-user-retry-parts.d.ts

@@ -0,0 +1,4 @@
+export declare function getLastUserRetryParts(messagesResponse: unknown): Array<{
+    type: "text";
+    text: string;
+}>;

package/dist/hooks/runtime-fallback/message-update-handler.d.ts

@@ -0,0 +1,4 @@
+import type { AutoRetryHelpers } from "./auto-retry";
+import type { HookDeps } from "./types";
+export { hasVisibleAssistantResponse } from "./visible-assistant-response";
+export declare function createMessageUpdateHandler(deps: HookDeps, helpers: AutoRetryHelpers): (props: Record<string, unknown> | undefined) => Promise<void>;

package/dist/hooks/runtime-fallback/model-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function parseModelString(model: string): {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+} | undefined;
+export declare function normalizeFallbackModels(models: string | string[] | undefined): string[] | undefined;
+export declare function flattenToFallbackModelStrings(models: string[] | undefined): string[] | undefined;

package/dist/hooks/runtime-fallback/retry-model-payload.d.ts

@@ -0,0 +1,11 @@
+export declare function buildRetryModelPayload(model: string, agentSettings?: {
+    variant?: string;
+    reasoningEffort?: string;
+}): {
+    model: {
+        providerID: string;
+        modelID: string;
+    };
+    variant?: string;
+    reasoningEffort?: string;
+} | undefined;

package/dist/hooks/runtime-fallback/retry-status-utils.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeRetryStatusMessage(message: string): string;
+export declare function extractRetryAttempt(statusAttempt: unknown, message: string): string;

package/dist/hooks/runtime-fallback/session-category-registry.d.ts

@@ -0,0 +1,6 @@
+export declare const SessionCategoryRegistry: {
+    register(sessionID: string, category: string): void;
+    get(sessionID: string): string | undefined;
+    remove(sessionID: string): void;
+    clear(): void;
+};

package/dist/hooks/runtime-fallback/session-messages.d.ts

@@ -0,0 +1,4 @@
+import type { ContentPart, SessionMessage } from "../../shared/session-message";
+export type { SessionMessage } from "../../shared/session-message";
+export type SessionMessagePart = ContentPart;
+export declare function extractSessionMessages(messagesResponse: unknown): SessionMessage[] | undefined;

package/dist/hooks/runtime-fallback/session-status-handler.d.ts

@@ -0,0 +1,3 @@
+import type { AutoRetryHelpers } from "./auto-retry";
+import type { HookDeps } from "./types";
+export declare function createSessionStatusHandler(deps: HookDeps, helpers: AutoRetryHelpers, sessionStatusRetryKeys: Map<string, string>): (props: Record<string, unknown> | undefined) => Promise<void>;

package/dist/hooks/runtime-fallback/types.d.ts

@@ -0,0 +1,65 @@
+import type { MatrixxConfig, RuntimeFallbackConfig } from "../../config";
+import type { V2Event } from "../../plugin/context";
+import type { SessionDomainLike } from "../../shared/session-context-source";
+export interface RuntimeFallbackInterval {
+    unref: () => void;
+}
+export type RuntimeFallbackTimeout = object | number;
+export interface RuntimeFallbackContext {
+    session: SessionDomainLike;
+    directory: string;
+}
+export interface FallbackState {
+    originalModel: string;
+    currentModel: string;
+    fallbackIndex: number;
+    failedModels: Map<string, number>;
+    attemptCount: number;
+    pendingFallbackModel?: string;
+}
+export interface FallbackResult {
+    success: boolean;
+    newModel?: string;
+    error?: string;
+    maxAttemptsReached?: boolean;
+}
+export interface RuntimeFallbackOptions {
+    config?: RuntimeFallbackConfig;
+    pluginConfig?: MatrixxConfig;
+    session_timeout_ms?: number;
+}
+export interface RuntimeFallbackHook {
+    event: (event: V2Event) => Promise<void>;
+    "chat.message"?: (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output: {
+        message: {
+            model?: {
+                providerID: string;
+                modelID: string;
+            };
+        };
+        parts?: Array<{
+            type: string;
+            text?: string;
+        }>;
+    }) => Promise<void>;
+    dispose?: () => void;
+}
+export interface HookDeps {
+    ctx: RuntimeFallbackContext;
+    config: Required<RuntimeFallbackConfig>;
+    options: RuntimeFallbackOptions | undefined;
+    pluginConfig: MatrixxConfig | undefined;
+    sessionStates: Map<string, FallbackState>;
+    sessionLastAccess: Map<string, number>;
+    sessionRetryInFlight: Set<string>;
+    sessionAwaitingFallbackResult: Set<string>;
+    sessionFallbackTimeouts: Map<string, RuntimeFallbackTimeout>;
+    sessionStatusRetryKeys: Map<string, string>;
+}

package/dist/hooks/runtime-fallback/visible-assistant-response.d.ts

@@ -0,0 +1,3 @@
+import type { extractAutoRetrySignal } from "./error-classifier";
+import type { HookDeps } from "./types";
+export declare function hasVisibleAssistantResponse(extractAutoRetrySignalFn: typeof extractAutoRetrySignal): (ctx: HookDeps["ctx"], sessionID: string, _info: Record<string, unknown> | undefined) => Promise<boolean>;

package/dist/hooks/secret-leak-guard/git-command-detector.d.ts

@@ -0,0 +1,2 @@
+export declare function isGitCommitOrPush(command: string): boolean;
+export declare function isGitPush(command: string): boolean;

package/dist/hooks/secret-leak-guard/gitleaks-runner.d.ts

@@ -0,0 +1,16 @@
+interface GitleaksResult {
+    available: boolean;
+    findings: GitleaksFinding[];
+    error?: string;
+}
+export interface GitleaksFinding {
+    RuleID: string;
+    Match: string;
+    File: string;
+    StartLine: number;
+    EndLine: number;
+    Description: string;
+}
+export declare function runGitleaksStagedScan(cwd: string): Promise<GitleaksResult>;
+export declare function runGitleaksPrePushScan(cwd: string, remoteBranch: string): Promise<GitleaksResult>;
+export {};

package/dist/hooks/secret-leak-guard/hook.d.ts

@@ -0,0 +1,17 @@
+import type { MatrixxContext } from "../../plugin/context";
+interface SecretLeakGuardOptions {
+    enabled?: boolean;
+    tool?: "gitleaks";
+    block_on_detection?: boolean;
+    allowlist_paths?: string[];
+}
+export declare function createSecretLeakGuardHook(ctx: MatrixxContext, config?: SecretLeakGuardOptions): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+    }) => Promise<void>;
+};
+export {};

package/dist/hooks/secret-leak-guard/result-formatter.d.ts

@@ -0,0 +1,3 @@
+import type { GitleaksFinding } from "./gitleaks-runner";
+export declare function formatFindings(findings: GitleaksFinding[]): string;
+export declare function extractRemoteBranch(command: string): string;

package/dist/hooks/session-memory/hook.d.ts

@@ -0,0 +1,23 @@
+import type { NativeMemoryConfig } from "../../config/schema/memory";
+import type { MatrixxContext, V2Event } from "../../plugin/context";
+export declare const MAX_PENDING_ENTRIES = 50;
+export declare const MAX_CAPTURE_CHARS = 2000;
+export interface SessionMemoryHookOptions {
+    memory?: NativeMemoryConfig;
+    directory?: string;
+}
+export interface SessionMemoryHook {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (event: V2Event) => Promise<void>;
+    flush: (sessionID: string) => void;
+    pendingCount: () => number;
+}
+export declare function createSessionMemoryHook(ctx: MatrixxContext, options?: SessionMemoryHookOptions): SessionMemoryHook;

package/dist/hooks/session-memory/index.d.ts

@@ -0,0 +1 @@
+export { createSessionMemoryHook, MAX_CAPTURE_CHARS, MAX_PENDING_ENTRIES, type SessionMemoryHook, type SessionMemoryHookOptions, } from "./hook";

package/dist/hooks/session-notification-formatting.d.ts

@@ -0,0 +1,3 @@
+export declare function escapeAppleScriptText(input: string): string;
+export declare function escapePowerShellSingleQuotedText(input: string): string;
+export declare function buildWindowsToastScript(title: string, message: string): string;

package/dist/hooks/session-notification-scheduler.d.ts

@@ -0,0 +1,24 @@
+import type { MatrixxContext } from "../plugin/context";
+import type { Platform } from "./session-notification-sender";
+type SessionNotificationConfig = {
+    title: string;
+    message: string;
+    playSound: boolean;
+    soundPath: string;
+    idleConfirmationDelay: number;
+    skipIfIncompleteTodos: boolean;
+    maxTrackedSessions: number;
+};
+export declare function createIdleNotificationScheduler(options: {
+    ctx: MatrixxContext;
+    platform: Platform;
+    config: SessionNotificationConfig;
+    hasIncompleteTaskWork: (ctx: MatrixxContext, sessionID: string) => Promise<boolean>;
+    send: (ctx: MatrixxContext, platform: Platform, title: string, message: string) => Promise<void>;
+    playSound: (ctx: MatrixxContext, platform: Platform, soundPath: string) => Promise<void>;
+}): {
+    markSessionActivity: (sessionID: string) => void;
+    scheduleIdleNotification: (sessionID: string) => void;
+    deleteSession: (sessionID: string) => void;
+};
+export {};

package/dist/hooks/session-notification-sender.d.ts

@@ -0,0 +1,6 @@
+import type { MatrixxContext } from "../plugin/context";
+export type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare function detectPlatform(): Platform;
+export declare function getDefaultSoundPath(platform: Platform): string;
+export declare function sendSessionNotification(ctx: MatrixxContext, platform: Platform, title: string, message: string): Promise<void>;
+export declare function playSessionNotificationSound(ctx: MatrixxContext, platform: Platform, soundPath: string): Promise<void>;

package/dist/hooks/session-notification-utils.d.ts

@@ -0,0 +1,9 @@
+type Platform = "darwin" | "linux" | "win32" | "unsupported";
+export declare const getNotifySendPath: () => Promise<string | null>;
+export declare const getOsascriptPath: () => Promise<string | null>;
+export declare const getPowershellPath: () => Promise<string | null>;
+export declare const getAfplayPath: () => Promise<string | null>;
+export declare const getPaplayPath: () => Promise<string | null>;
+export declare const getAplayPath: () => Promise<string | null>;
+export declare function startBackgroundCheck(platform: Platform): void;
+export {};

package/dist/hooks/session-notification.d.ts

@@ -0,0 +1,23 @@
+import type { MatrixxConfig } from "../config/schema";
+import type { MatrixxContext } from "../plugin/context";
+interface SessionNotificationConfig {
+    title?: string;
+    message?: string;
+    playSound?: boolean;
+    soundPath?: string;
+    /** Delay in ms before sending notification to confirm session is still idle (default: 1500) */
+    idleConfirmationDelay?: number;
+    /** Skip notification if the session (or one of its subagents) still has pending work in the file-backed task store (default: true) */
+    skipIfIncompleteTodos?: boolean;
+    /** Maximum number of sessions to track before cleanup (default: 100) */
+    maxTrackedSessions?: number;
+}
+import type { V2Event } from "../plugin/context";
+export declare function createSessionNotification(ctx: MatrixxContext, config?: SessionNotificationConfig, 
+/**
+ * The plugin config is a separate parameter, not part of `SessionNotificationConfig`:
+ * only `tasks.*` is read here, and widening the hook-local config would blur a
+ * presentation-only shape into a carrier for task-storage settings.
+ */
+pluginConfig?: Partial<MatrixxConfig>): (event: V2Event) => Promise<void>;
+export {};

package/dist/hooks/session-recovery/constants.d.ts

@@ -0,0 +1,3 @@
+export { MESSAGE_STORAGE, OPENCODE_STORAGE, PART_STORAGE } from "../../shared";
+export declare const THINKING_TYPES: Set<string>;
+export declare const META_TYPES: Set<string>;

package/dist/hooks/session-recovery/detect-error-type.d.ts

@@ -0,0 +1,3 @@
+export type RecoveryErrorType = "tool_result_missing" | "thinking_block_order" | "thinking_disabled_violation" | "assistant_prefill_unsupported" | null;
+export declare function extractMessageIndex(error: unknown): number | null;
+export declare function detectErrorType(error: unknown): RecoveryErrorType;

package/dist/hooks/session-recovery/hook.d.ts

@@ -0,0 +1,20 @@
+import type { ExperimentalConfig } from "../../config";
+import type { NativePluginContext } from "../../shared/session-context-source";
+interface MessageInfo {
+    id?: string;
+    role?: string;
+    sessionID?: string;
+    parentID?: string;
+    error?: unknown;
+}
+export interface SessionRecoveryOptions {
+    experimental?: ExperimentalConfig;
+}
+export interface SessionRecoveryHook {
+    handleSessionRecovery: (info: MessageInfo) => Promise<boolean>;
+    isRecoverableError: (error: unknown) => boolean;
+    setOnAbortCallback: (callback: (sessionID: string) => void) => void;
+    setOnRecoveryCompleteCallback: (callback: (sessionID: string) => void) => void;
+}
+export declare function createSessionRecoveryHook(ctx: NativePluginContext, options?: SessionRecoveryOptions): SessionRecoveryHook;
+export {};

package/dist/hooks/session-recovery/index.d.ts

@@ -0,0 +1,5 @@
+export type { RecoveryErrorType } from "./detect-error-type";
+export { detectErrorType } from "./detect-error-type";
+export type { SessionRecoveryHook, SessionRecoveryOptions } from "./hook";
+export { createSessionRecoveryHook } from "./hook";
+export type { MessageData, ResumeConfig } from "./types";

package/dist/hooks/session-recovery/recover-thinking-block-order.d.ts

@@ -0,0 +1,7 @@
+import type { SessionDomainLike } from "../../shared/session-context-source";
+import type { MessageData } from "./types";
+type Client = {
+    session: SessionDomainLike;
+};
+export declare function recoverThinkingBlockOrder(client: Client, sessionID: string, _failedAssistantMsg: MessageData, _directory: string, error: unknown): Promise<boolean>;
+export {};

package/dist/hooks/session-recovery/recover-thinking-disabled-violation.d.ts

@@ -0,0 +1,7 @@
+import type { SessionDomainLike } from "../../shared/session-context-source";
+import type { MessageData } from "./types";
+type Client = {
+    session: SessionDomainLike;
+};
+export declare function recoverThinkingDisabledViolation(client: Client, sessionID: string, _failedAssistantMsg: MessageData): Promise<boolean>;
+export {};

package/dist/hooks/session-recovery/recover-tool-result-missing.d.ts

@@ -0,0 +1,7 @@
+import type { SessionDomainLike } from "../../shared/session-context-source";
+import type { MessageData } from "./types";
+type Client = {
+    session: SessionDomainLike;
+};
+export declare function recoverToolResultMissing(client: Client, sessionID: string, failedAssistantMsg: MessageData): Promise<boolean>;
+export {};

package/dist/hooks/session-recovery/resume.d.ts

@@ -0,0 +1,9 @@
+import type { SessionDomainLike } from "../../shared/session-context-source";
+import type { MessageData, ResumeConfig } from "./types";
+type Client = {
+    session: SessionDomainLike;
+};
+export declare function findLastUserMessage(messages: MessageData[]): MessageData | undefined;
+export declare function extractResumeConfig(userMessage: MessageData | undefined, sessionID: string): ResumeConfig;
+export declare function resumeSession(client: Client, config: ResumeConfig): Promise<boolean>;
+export {};

package/dist/hooks/session-recovery/storage/empty-messages.d.ts

@@ -0,0 +1,3 @@
+export declare function findEmptyMessages(sessionID: string): string[];
+export declare function findEmptyMessageByIndex(sessionID: string, targetIndex: number): string | null;
+export declare function findFirstEmptyMessage(sessionID: string): string | null;

package/dist/hooks/session-recovery/storage/empty-text.d.ts

@@ -0,0 +1,5 @@
+import type { SessionContextCarrier } from "../../../shared/session-context-source";
+export declare function replaceEmptyTextParts(messageID: string, replacementText: string): boolean;
+export declare function replaceEmptyTextPartsAsync(client: SessionContextCarrier, sessionID: string, messageID: string, replacementText: string): Promise<boolean>;
+export declare function findMessagesWithEmptyTextParts(sessionID: string): string[];
+export declare function findMessagesWithEmptyTextPartsFromSDK(client: SessionContextCarrier, sessionID: string): Promise<string[]>;

package/dist/hooks/session-recovery/storage/messages-reader.d.ts

@@ -0,0 +1,4 @@
+import type { SessionContextCarrier } from "../../../shared/session-context-source";
+import type { StoredMessageMeta } from "../types";
+export declare function readMessages(sessionID: string): StoredMessageMeta[];
+export declare function readMessagesFromSDK(client: SessionContextCarrier, sessionID: string): Promise<StoredMessageMeta[]>;

package/dist/hooks/session-recovery/storage/orphan-thinking-search.d.ts

@@ -0,0 +1,2 @@
+export declare function findMessagesWithOrphanThinking(sessionID: string): string[];
+export declare function findMessageByIndexNeedingThinking(sessionID: string, targetIndex: number): string | null;

package/dist/hooks/session-recovery/storage/part-content.d.ts

@@ -0,0 +1,3 @@
+import type { StoredPart } from "../types";
+export declare function hasContent(part: StoredPart): boolean;
+export declare function messageHasContent(messageID: string): boolean;

package/dist/hooks/session-recovery/storage/part-id.d.ts

@@ -0,0 +1 @@
+export declare function generatePartId(): string;

package/dist/hooks/session-recovery/storage/parts-reader.d.ts

@@ -0,0 +1,4 @@
+import type { SessionContextCarrier } from "../../../shared/session-context-source";
+import type { StoredPart } from "../types";
+export declare function readParts(messageID: string): StoredPart[];
+export declare function readPartsFromSDK(_client: SessionContextCarrier, _sessionID: string, _messageID: string): Promise<StoredPart[]>;

package/dist/hooks/session-recovery/storage/text-part-injector.d.ts

@@ -0,0 +1,3 @@
+import type { SessionContextCarrier } from "../../../shared/session-context-source";
+export declare function injectTextPart(sessionID: string, messageID: string, text: string): boolean;
+export declare function injectTextPartAsync(client: SessionContextCarrier, sessionID: string, messageID: string, text: string): Promise<boolean>;

package/dist/hooks/session-recovery/storage/thinking-block-search.d.ts

@@ -0,0 +1,2 @@
+export declare function findMessagesWithThinkingBlocks(sessionID: string): string[];
+export declare function findMessagesWithThinkingOnly(sessionID: string): string[];

package/dist/hooks/session-recovery/storage/thinking-prepend.d.ts

@@ -0,0 +1,3 @@
+import type { SessionContextCarrier } from "../../../shared/session-context-source";
+export declare function prependThinkingPart(sessionID: string, messageID: string): boolean;
+export declare function prependThinkingPartAsync(client: SessionContextCarrier, sessionID: string, messageID: string): Promise<boolean>;

package/dist/hooks/session-recovery/storage/thinking-strip.d.ts

@@ -0,0 +1,3 @@
+import type { SessionContextCarrier } from "../../../shared/session-context-source";
+export declare function stripThinkingParts(messageID: string): boolean;
+export declare function stripThinkingPartsAsync(client: SessionContextCarrier, sessionID: string, messageID: string): Promise<boolean>;

package/dist/hooks/session-recovery/storage.d.ts

@@ -0,0 +1,12 @@
+export { getMessageDir } from "../../shared/opencode-message-dir";
+export { findEmptyMessageByIndex, findEmptyMessages, findFirstEmptyMessage, } from "./storage/empty-messages";
+export { findMessagesWithEmptyTextParts, findMessagesWithEmptyTextPartsFromSDK, replaceEmptyTextParts, replaceEmptyTextPartsAsync } from "./storage/empty-text";
+export { readMessages, readMessagesFromSDK } from "./storage/messages-reader";
+export { findMessageByIndexNeedingThinking, findMessagesWithOrphanThinking, } from "./storage/orphan-thinking-search";
+export { hasContent, messageHasContent } from "./storage/part-content";
+export { generatePartId } from "./storage/part-id";
+export { readParts, readPartsFromSDK } from "./storage/parts-reader";
+export { injectTextPart, injectTextPartAsync } from "./storage/text-part-injector";
+export { findMessagesWithThinkingBlocks, findMessagesWithThinkingOnly, } from "./storage/thinking-block-search";
+export { prependThinkingPart, prependThinkingPartAsync } from "./storage/thinking-prepend";
+export { stripThinkingParts, stripThinkingPartsAsync } from "./storage/thinking-strip";

package/dist/hooks/session-recovery/types.d.ts

@@ -0,0 +1,66 @@
+import type { SessionMessage } from "../../shared/session-message";
+import type { TaskStatus } from "../../shared/status-types";
+export interface StoredMessageMeta {
+    id: string;
+    sessionID: string;
+    role: "user" | "assistant";
+    parentID?: string;
+    time?: {
+        created: number;
+        completed?: number;
+    };
+    error?: unknown;
+}
+export interface StoredTextPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "text";
+    text: string;
+    synthetic?: boolean;
+    ignored?: boolean;
+}
+export interface StoredToolPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "tool";
+    callID: string;
+    tool: string;
+    state: {
+        status: TaskStatus;
+        input: Record<string, unknown>;
+        output?: string;
+        error?: string;
+    };
+}
+interface StoredReasoningPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "reasoning";
+    text: string;
+}
+interface StoredStepPart {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: "step-start" | "step-finish";
+}
+export type StoredPart = StoredTextPart | StoredToolPart | StoredReasoningPart | StoredStepPart | {
+    id: string;
+    sessionID: string;
+    messageID: string;
+    type: string;
+    [key: string]: unknown;
+};
+export type MessageData = SessionMessage;
+export interface ResumeConfig {
+    sessionID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+    };
+}
+export {};

package/dist/hooks/shared/compaction-model-resolver.d.ts

@@ -0,0 +1,5 @@
+import type { MatrixxConfig } from "../../config";
+export declare function resolveCompactionModel(pluginConfig: MatrixxConfig, sessionID: string, originalProviderID: string, originalModelID: string): {
+    providerID: string;
+    modelID: string;
+};

package/dist/hooks/silent-failure-guard/constants.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Silent-failure guard scope.
+ *
+ * The guard fires only for writes/edits to Python files whose path matches one
+ * of the finance-path globs below. Kept as a named constant so the scope can be
+ * made configurable later without touching the hook logic.
+ */
+export declare const FINANCE_PATH_GLOBS: string[];
+/** Tools whose completion can introduce a silent failure. */
+export declare const SILENT_FAILURE_GUARD_TOOLS: string[];
+/** Max findings surfaced per write (strict budget — never floods context). */
+export declare const SILENT_FAILURE_GUARD_MAX_FINDINGS = 5;
+/** Skip files larger than this (bytes) to keep the guard light. */
+export declare const SILENT_FAILURE_GUARD_MAX_CONTENT_BYTES = 512000;

package/dist/hooks/silent-failure-guard/hook.d.ts

@@ -0,0 +1,24 @@
+import type { MatrixxContext } from "../../plugin/context";
+interface ToolExecuteAfterInput {
+    tool: string;
+    sessionID: string;
+    callID: string;
+}
+interface ToolExecuteAfterOutput {
+    title: string;
+    output: string;
+    metadata: unknown;
+}
+/**
+ * Warn-first, non-blocking silent-failure guard.
+ *
+ * Runs on `tool.execute.after` and only for `edit`/`write` completions whose
+ * target is a `*.py` file matching a finance-path glob. It reuses the scanner
+ * rule engine (`scanPath`) on the changed file and appends a warning to the
+ * tool output. It never blocks and never swallows its own errors — a failure in
+ * the guard is logged explicitly so the guard is not itself a silent failure.
+ */
+export declare function createSilentFailureGuardHook(ctx: MatrixxContext): {
+    "tool.execute.after": (input: ToolExecuteAfterInput, output: ToolExecuteAfterOutput) => Promise<void>;
+};
+export {};

package/dist/hooks/silent-failure-guard/index.d.ts

@@ -0,0 +1,2 @@
+export { FINANCE_PATH_GLOBS, SILENT_FAILURE_GUARD_MAX_CONTENT_BYTES, SILENT_FAILURE_GUARD_MAX_FINDINGS, SILENT_FAILURE_GUARD_TOOLS, } from "./constants";
+export { createSilentFailureGuardHook } from "./hook";

package/dist/hooks/software-dev-enforcement/constants.d.ts

@@ -0,0 +1,5 @@
+export declare const HOOK_NAME = "software-dev-enforcement";
+export declare const SOFTWARE_DEV_ENFORCEMENT_MARKER = "[SYSTEM DIRECTIVE: MATRIXX - SOFTWARE DEV ENFORCEMENT]";
+export declare const READ_ONLY_SUBAGENT_TARGETS: readonly ["trinity", "explore", "operator"];
+export declare const CODE_WRITING_SUBAGENT_TARGETS: readonly ["mouse", "sati"];
+export declare function isCodeWritingPrompt(prompt: string): boolean;

package/dist/hooks/software-dev-enforcement/hook.d.ts

@@ -0,0 +1,11 @@
+import type { MatrixxConfig } from "../../config";
+export declare function createSoftwareDevEnforcementHook(pluginConfig?: MatrixxConfig): {
+    "tool.execute.before": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        args: Record<string, unknown>;
+        message?: string;
+    }) => Promise<void>;
+};