opencode-matrixx 2.6.2 → 2.6.4

package/dist/config/schema/model-config.d.ts

@@ -0,0 +1,81 @@
+import { z } from "zod";
+export declare const ModelFallbackEntrySchema: z.ZodObject<{
+    providers: z.ZodArray<z.ZodString>;
+    model: z.ZodString;
+    variant: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type ModelFallbackEntry = z.infer<typeof ModelFallbackEntrySchema>;
+export declare const TierSpecSchema: z.ZodObject<{
+    providerPriority: z.ZodArray<z.ZodString>;
+    modelPattern: z.ZodString;
+    fallbackTier: z.ZodOptional<z.ZodString>;
+    fallback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        providers: z.ZodArray<z.ZodString>;
+        model: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type TierSpec = z.infer<typeof TierSpecSchema>;
+export declare const TiersSchema: z.ZodRecord<z.ZodString, z.ZodObject<{
+    providerPriority: z.ZodArray<z.ZodString>;
+    modelPattern: z.ZodString;
+    fallbackTier: z.ZodOptional<z.ZodString>;
+    fallback: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        providers: z.ZodArray<z.ZodString>;
+        model: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+export type Tiers = z.infer<typeof TiersSchema>;
+export declare const ComplexityDowngradesSchema: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>;
+export type ComplexityDowngrades = z.infer<typeof ComplexityDowngradesSchema>;
+export declare const AgentModelRequirementsSchema: z.ZodObject<{
+    fallbackChain: z.ZodArray<z.ZodObject<{
+        providers: z.ZodArray<z.ZodString>;
+        model: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    requiresModel: z.ZodOptional<z.ZodString>;
+    requiresAnyModel: z.ZodOptional<z.ZodBoolean>;
+    requiresProvider: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentModelRequirements = z.infer<typeof AgentModelRequirementsSchema>;
+export declare const CategoryModelRequirementsSchema: z.ZodObject<{
+    fallbackChain: z.ZodArray<z.ZodObject<{
+        providers: z.ZodArray<z.ZodString>;
+        model: z.ZodString;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    requiresModel: z.ZodOptional<z.ZodString>;
+    requiresAnyModel: z.ZodOptional<z.ZodBoolean>;
+    requiresProvider: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    variant: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type CategoryModelRequirements = z.infer<typeof CategoryModelRequirementsSchema>;
+export declare const ModelRequirementsSchema: z.ZodObject<{
+    agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fallbackChain: z.ZodArray<z.ZodObject<{
+            providers: z.ZodArray<z.ZodString>;
+            model: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        requiresModel: z.ZodOptional<z.ZodString>;
+        requiresAnyModel: z.ZodOptional<z.ZodBoolean>;
+        requiresProvider: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    categories: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        fallbackChain: z.ZodArray<z.ZodObject<{
+            providers: z.ZodArray<z.ZodString>;
+            model: z.ZodString;
+            variant: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        requiresModel: z.ZodOptional<z.ZodString>;
+        requiresAnyModel: z.ZodOptional<z.ZodBoolean>;
+        requiresProvider: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        variant: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type ModelRequirements = z.infer<typeof ModelRequirementsSchema>;
+export declare const DEFAULT_MODEL_CONFIG: {};

package/dist/config/schema/morpheus.d.ts

@@ -2,21 +2,23 @@ import { z } from "zod";
 declare const MorpheusTasksConfigSchema: z.ZodObject<{
     storage_path: z.ZodOptional<z.ZodString>;
     task_list_id: z.ZodOptional<z.ZodString>;
-    claude_code_compat: z.ZodDefault<z.ZodBoolean>;
     scope: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         project: "project";
         global: "global";
     }>>>;
+    stale_after_hours: z.ZodOptional<z.ZodNumber>;
+    session_scoped: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
 }, z.core.$strip>;
 export declare const MorpheusConfigSchema: z.ZodObject<{
     tasks: z.ZodOptional<z.ZodObject<{
         storage_path: z.ZodOptional<z.ZodString>;
         task_list_id: z.ZodOptional<z.ZodString>;
-        claude_code_compat: z.ZodDefault<z.ZodBoolean>;
         scope: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
             project: "project";
             global: "global";
         }>>>;
+        stale_after_hours: z.ZodOptional<z.ZodNumber>;
+        session_scoped: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
 export type MorpheusTasksConfig = z.infer<typeof MorpheusTasksConfigSchema>;

package/dist/config/schema/security.d.ts

@@ -12,6 +12,32 @@ declare const EnvFileGuardConfigSchema: z.ZodObject<{
     blocked_patterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
     allowed_paths: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
+declare const InputSecretGuardModeSchema: z.ZodEnum<{
+    prompt: "prompt";
+    off: "off";
+    block: "block";
+}>;
+declare const InputSecretGuardConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        prompt: "prompt";
+        off: "off";
+        block: "block";
+    }>>;
+    blocklist_mode: z.ZodDefault<z.ZodEnum<{
+        prompt: "prompt";
+        block: "block";
+    }>>;
+    warnlist_mode: z.ZodDefault<z.ZodEnum<{
+        prompt: "prompt";
+        off: "off";
+    }>>;
+    allowlist_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    detection: z.ZodOptional<z.ZodObject<{
+        entropy_threshold: z.ZodDefault<z.ZodNumber>;
+        max_scan_bytes: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
 export declare const SecurityConfigSchema: z.ZodObject<{
     secret_scanning: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
@@ -30,8 +56,31 @@ export declare const SecurityConfigSchema: z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         on_package_change: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
+    input_secret_guard: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            prompt: "prompt";
+            off: "off";
+            block: "block";
+        }>>;
+        blocklist_mode: z.ZodDefault<z.ZodEnum<{
+            prompt: "prompt";
+            block: "block";
+        }>>;
+        warnlist_mode: z.ZodDefault<z.ZodEnum<{
+            prompt: "prompt";
+            off: "off";
+        }>>;
+        allowlist_patterns: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        detection: z.ZodOptional<z.ZodObject<{
+            entropy_threshold: z.ZodDefault<z.ZodNumber>;
+            max_scan_bytes: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type SecurityConfig = z.infer<typeof SecurityConfigSchema>;
 export type SecretScanningConfig = z.infer<typeof SecretScanningConfigSchema>;
 export type EnvFileGuardConfig = z.infer<typeof EnvFileGuardConfigSchema>;
+export type InputSecretGuardConfig = z.infer<typeof InputSecretGuardConfigSchema>;
+export type InputSecretGuardMode = z.infer<typeof InputSecretGuardModeSchema>;
 export {};

package/dist/config/schema.d.ts

@@ -13,11 +13,13 @@ export * from "./schema/context-mode";
 export * from "./schema/dcp";
 export * from "./schema/evolution";
 export * from "./schema/experimental";
+export * from "./schema/failure-counter";
 export * from "./schema/headroom";
 export * from "./schema/hooks";
 export * from "./schema/matrix-loop";
 export * from "./schema/matrixx-config";
 export * from "./schema/matrixx-self-config";
+export * from "./schema/model-config";
 export * from "./schema/morpheus";
 export * from "./schema/morpheus-agent";
 export * from "./schema/notification";

package/dist/create-hooks.d.ts

@@ -26,6 +26,7 @@ export declare function createHooks(args: {
     planPersister: ReturnType<typeof import("./hooks").createPlanPersister> | null;
     evolutionCompressor: ReturnType<typeof import("./hooks").createEvolutionCompressorHook> | null;
     evolutionHitl: ReturnType<typeof import("./hooks").createEvolutionHitlHook> | null;
+    inputSecretGuard: ReturnType<typeof import("./hooks").createInputSecretGuardHook> | null;
     keywordDetector: ReturnType<typeof import("./hooks").createKeywordDetectorHook> | null;
     contextInjectorMessagesTransform: ReturnType<typeof import("./features/context-injector").createContextInjectorMessagesTransformHook>;
     envContextInjector: ReturnType<typeof import("./hooks").createEnvContextInjectorHook> | null;
@@ -35,7 +36,6 @@ export declare function createHooks(args: {
     commentChecker: ReturnType<typeof import("./hooks").createCommentCheckerHooks> | null;
     toolOutputTruncator: ReturnType<typeof import("./hooks").createToolOutputTruncatorHook> | null;
     directoryAgentsInjector: ReturnType<typeof import("./hooks").createDirectoryAgentsInjectorHook> | null;
-    directoryReadmeInjector: ReturnType<typeof import("./hooks").createDirectoryReadmeInjectorHook> | null;
     emptyTaskResponseDetector: ReturnType<typeof import("./hooks").createEmptyTaskResponseDetectorHook> | null;
     rulesInjector: ReturnType<typeof import("./hooks").createRulesInjectorHook> | null;
     tasksTodowriteDisabler: ReturnType<typeof import("./hooks").createTasksTodowriteDisablerHook> | null;
@@ -58,7 +58,7 @@ export declare function createHooks(args: {
     sessionRecovery: ReturnType<typeof import("./hooks").createSessionRecoveryHook> | null;
     sessionNotification: ReturnType<typeof import("./hooks").createSessionNotification> | null;
     thinkMode: ReturnType<typeof import("./hooks").createThinkModeHook> | null;
-    anthropicContextWindowLimitRecovery: ReturnType<typeof import("./hooks").createAnthropicContextWindowLimitRecoveryHook> | null;
+    contextWindowLimitRecovery: ReturnType<typeof import("./hooks").createContextWindowLimitRecoveryHook> | null;
     autoUpdateChecker: ReturnType<typeof import("./hooks").createAutoUpdateCheckerHook> | null;
     agentUsageReminder: ReturnType<typeof import("./hooks").createAgentUsageReminderHook> | null;
     nonInteractiveEnv: ReturnType<typeof import("./hooks").createNonInteractiveEnvHook> | null;
@@ -66,13 +66,12 @@ export declare function createHooks(args: {
     matrixLoop: ReturnType<typeof import("./hooks").createMatrixLoopHook> | null;
     editErrorRecovery: ReturnType<typeof import("./hooks").createEditErrorRecoveryHook> | null;
     delegateTaskRetry: ReturnType<typeof import("./hooks").createDelegateTaskRetryHook> | null;
+    failureCounter: ReturnType<typeof import("./hooks").createFailureCounterHook> | null;
     startWork: ReturnType<typeof import("./hooks").createStartWorkHook> | null;
     oracleMdOnly: ReturnType<typeof import("./hooks").createOracleMdOnlyHook> | null;
     mouseNotepad: ReturnType<typeof import("./hooks").createMouseNotepadHook> | null;
-    questionLabelTruncator: ReturnType<typeof import("./hooks").createQuestionLabelTruncatorHook>;
     taskResumeInfo: ReturnType<typeof import("./hooks").createTaskResumeInfoHook>;
     anthropicEffort: ReturnType<typeof import("./hooks/anthropic-effort").createAnthropicEffortHook> | null;
     runtimeFallback: ReturnType<typeof import("./hooks").createRuntimeFallbackHook> | null;
     rtkBashRewriter: ReturnType<typeof import("./hooks").createRtkBashRewriterHook> | null;
-    mcpStartupNotification: ReturnType<typeof import("./hooks").createMcpStartupNotificationHook> | null;
 };

package/dist/features/background-agent/manager.d.ts

@@ -137,6 +137,14 @@ export declare class BackgroundManager {
     private notifyParentSession;
     private hasRunningTasks;
     private pruneStaleTasksAndNotifications;
+    /**
+     * True when the subagent session is awaiting user input (unanswered question).
+     * The reaper must not kill a task that is legitimately waiting for an answer:
+     * its session reports idle and it stops posting progress, but it is not stuck.
+     * Ground truth comes from the session message history (hasPendingQuestionMessage);
+     * on fetch failure we fail open (return false) so reaping behavior is unchanged.
+     */
+    private isSessionAwaitingUser;
     private checkAndInterruptStaleTasks;
     private pollRunningTasks;
     /**

package/dist/features/builtin-commands/templates/start-work.d.ts

@@ -1 +1 @@
-export declare const START_WORK_TEMPLATE = "You are starting a Morpheus work session.\n\n## WHAT TO DO\n\n1. **Find available plans**: Search for Oracle-generated plan files at `.matrixx/plans/`\n\n2. **Check for active mission state**: Read `.matrixx/mission.json` if it exists\n\n3. **Decision logic**:\n   - If `.matrixx/mission.json` exists AND plan is NOT complete (has unchecked boxes):\n     - **APPEND** current session to session_ids\n     - Continue work on existing plan\n   - If no active plan OR plan is complete:\n     - List available plan files\n     - If ONE plan: auto-select it\n     - If MULTIPLE plans: show list with timestamps, ask user to select\n\n4. **Create/Update mission.json**:\n   ```json\n   {\n     \"active_plan\": \"/absolute/path/to/plan.md\",\n     \"started_at\": \"ISO_TIMESTAMP\",\n     \"session_ids\": [\"session_id_1\", \"session_id_2\"],\n     \"plan_name\": \"plan-name\"\n   }\n   ```\n\n5. **Read the plan file** and start executing tasks according to architect workflow\n\n## OUTPUT FORMAT\n\nWhen listing plans for selection:\n```\nAvailable Work Plans\n\nCurrent Time: {ISO timestamp}\nSession ID: {current session id}\n\n1. [plan-name-1.md] - Modified: {date} - Progress: 3/10 tasks\n2. [plan-name-2.md] - Modified: {date} - Progress: 0/5 tasks\n\nWhich plan would you like to work on? (Enter number or plan name)\n```\n\nWhen resuming existing work:\n```\nResuming Work Session\n\nActive Plan: {plan-name}\nProgress: {completed}/{total} tasks\nSessions: {count} (appending current session)\n\nReading plan and continuing from last incomplete task...\n```\n\nWhen auto-selecting single plan:\n```\nStarting Work Session\n\nPlan: {plan-name}\nSession ID: {session_id}\nStarted: {timestamp}\n\nReading plan and beginning execution...\n```\n\n## CRITICAL\n\n- The session_id is injected by the hook - use it directly\n- Always update mission.json BEFORE starting work\n- Read the FULL plan file before delegating any tasks\n- Follow architect delegation protocols (7-section format)";
+export declare const START_WORK_TEMPLATE = "You are starting a Morpheus work session.\n\n## WHAT TO DO\n\n1. **Find available plans**: List Oracle-generated plan files via plan_list at `.matrixx/plans/`\n\n2. **Check for active mission state**: Read `.matrixx/mission.json` if it exists\n\n3. **Decision logic**:\n   - If `.matrixx/mission.json` exists AND plan is NOT complete (has unchecked boxes):\n     - **APPEND** current session to session_ids\n     - Continue work on existing plan\n   - If no active plan OR plan is complete:\n     - List available plan files via plan_list\n     - If ONE plan: auto-select it\n     - If MULTIPLE plans: show list with timestamps, ask user to select\n\n4. **Create/Update mission.json**:\n   ```json\n   {\n     \"active_plan\": \"/absolute/path/to/plan.md\",\n     \"started_at\": \"ISO_TIMESTAMP\",\n     \"session_ids\": [\"session_id_1\", \"session_id_2\"],\n     \"plan_name\": \"plan-name\"\n   }\n   ```\n\n5. **Read the plan file via plan_read** and start executing tasks according to architect workflow\n\n## OUTPUT FORMAT\n\nWhen listing plans for selection:\n```\nAvailable Work Plans\n\nCurrent Time: {ISO timestamp}\nSession ID: {current session id}\n\n1. [plan-name-1.md] - Modified: {date} - Progress: 3/10 tasks\n2. [plan-name-2.md] - Modified: {date} - Progress: 0/5 tasks\n\nWhich plan would you like to work on? (Enter number or plan name)\n```\n\nWhen resuming existing work:\n```\nResuming Work Session\n\nActive Plan: {plan-name}\nProgress: {completed}/{total} tasks\nSessions: {count} (appending current session)\n\nReading plan and continuing from last incomplete task...\n```\n\nWhen auto-selecting single plan:\n```\nStarting Work Session\n\nPlan: {plan-name}\nSession ID: {session_id}\nStarted: {timestamp}\n\nReading plan and beginning execution...\n```\n\n## CRITICAL\n\n- The session_id is injected by the hook - use it directly\n- Always update mission.json BEFORE starting work\n- Read the FULL plan file via plan_read before delegating any tasks\n- Follow architect delegation protocols (7-section format)";

package/dist/features/mission-state/plan-storage.d.ts

@@ -30,6 +30,7 @@ export declare function writePlanFile(directory: string, planPath: string, conte
  * For each `- [ ]` or `- [x]` line, finds the matching todo by content
  * and marks it completed if the todo status is completed/cancelled.
  * Lines without a matching todo keep their current state.
+ * Checked boxes are never unchecked — sync only transitions [ ] → [x].
  */
 export declare function syncCheckboxes(content: string, todos: Array<{
     content: string;

package/dist/features/mission-state/plan-storage.test.d.ts

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

package/dist/features/session-state/state.d.ts

@@ -1,9 +1,35 @@
 export declare const subagentSessions: Set<string>;
+export declare function registerSubagentSession(sessionID: string, parentSessionID: string): void;
+export declare function getParentSessionID(subagentSessionID: string): string | undefined;
+export declare function getSubagentSessionIDs(parentSessionID: string): string[];
 export declare function setMainSession(id: string | undefined): void;
 export declare function getMainSessionID(): string | undefined;
+/**
+ * Whether a session.created payload should be tracked as the plugin's main
+ * session. Top-level sessions (no parentID) qualify UNLESS they are internal
+ * sessions of another plugin (e.g. opencode-mem structured-output capture
+ * sessions are top-level with metadata["opencode-mem"].internal === true).
+ * Foreign top-level sessions must not hijack main-session tracking.
+ */
+export declare function isMainSessionCandidate(sessionInfo: {
+    id?: string;
+    parentID?: string;
+    metadata?: Record<string, unknown>;
+} | undefined): boolean;
 /** @internal For testing only */
 export declare function _resetForTesting(): void;
 export declare function setSessionAgent(sessionID: string, agent: string): void;
 export declare function updateSessionAgent(sessionID: string, agent: string): void;
 export declare function getSessionAgent(sessionID: string): string | undefined;
 export declare function clearSessionAgent(sessionID: string): void;
+export declare function incFailureCounter(sessionID: string): number;
+export declare function resetFailureCounter(sessionID: string): void;
+export declare function getFailureCount(sessionID: string): number;
+export declare function getFailureState(sessionID: string): {
+    count: number;
+    lastFailedAt: number;
+} | undefined;
+export declare function clearFailureCounter(sessionID: string): void;
+/** @internal For testing only */
+export declare function _resetFailureCountersForTesting(): void;
+export declare function isThresholdReached(sessionID: string, threshold: number): boolean;

package/dist/features/session-state/state.test.d.ts

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

package/dist/features/task-storage/types.d.ts

@@ -21,6 +21,7 @@ export declare const TaskSchema: z.ZodObject<{
     blockedBy: z.ZodArray<z.ZodString>;
     owner: z.ZodOptional<z.ZodString>;
     metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    threadID: z.ZodOptional<z.ZodString>;
     projectRoot: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 export type Task = z.infer<typeof TaskSchema>;

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

@@ -1,5 +1,5 @@
 export declare const HOOK_NAME = "context-mode-enforcer";
-export declare const WARN_MESSAGE_READ = "Use ctx_search / ctx_batch_execute / ctx_execute for analysis \u2014 raw read/grep/glob bypasses FTS5 sandbox and pollutes context. Use Read only with hashline IDs for Edit.";
+export declare const WARN_MESSAGE_READ = "Use ctx_search / ctx_batch_execute / ctx_execute for analysis \u2014 raw read/grep/glob bypasses FTS5 sandbox and pollutes context. Use Read only with hashline IDs for Edit (non-plan paths; .matrixx/plans/*.md must use plan_read/plan_update).";
 export declare const BLOCK_MESSAGE_GREP_GLOB = "Blocked: raw grep/glob is forbidden when context-mode is enforced. Use ctx_search (indexed) \u2192 grep/glob fallback only when ctx_* unavailable, or ctx_batch_execute / ctx_execute for multi-file analysis.";
 export declare const WARN_MESSAGE_BASH_READ = "Use ctx_* / Read tool instead of `cat`/`head`/`tail`/`grep` via bash for analysis. Raw bash file reads bypass sandbox.";
 export declare const DEFAULT_BLOCKED_TOOLS: readonly ["grep", "glob"];

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 "./recovery-strategy";
+export * from "./state";
+export type { AutoCompactState, ParsedTokenLimitError, TruncateState } from "./types";

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/{anthropic-context-window-limit-recovery → context-window-limit-recovery}/recovery-hook.d.ts

@@ -11,3 +11,5 @@ export declare function createAnthropicContextWindowLimitRecoveryHook(ctx: Plugi
         };
     }) => Promise<void>;
 };
+export type ContextWindowLimitRecoveryOptions = AnthropicContextWindowLimitRecoveryOptions;
+export declare const createContextWindowLimitRecoveryHook: typeof createAnthropicContextWindowLimitRecoveryHook;

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

@@ -0,0 +1,3 @@
+export { truncateUntilTargetTokens } from "./target-token-truncation";
+export type { AggressiveTruncateResult, ToolResultInfo } from "./tool-part-types";
+export { countTruncatedResults, countTruncatedResultsFromSDK, findLargestToolResult, findToolResultsBySize, findToolResultsBySizeFromSDK, getTotalToolOutputSize, getTotalToolOutputSizeFromSDK, TRUNCATION_MESSAGE, truncateToolResult, truncateToolResultAsync, } from "./tool-result-store";

package/dist/hooks/{anthropic-context-window-limit-recovery/tool-result-storage-sdk.d.ts → context-window-limit-recovery/tool-result-store.d.ts}

@@ -1,5 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { ToolResultInfo } from "./tool-part-types";
+export declare const TRUNCATION_MESSAGE = "[TOOL RESULT TRUNCATED - Context limit exceeded. Original output was too large and has been truncated to recover the session. Please re-run this tool if you need the full output.]";
 type OpencodeClient = PluginInput["client"];
 interface SDKToolPart {
     id: string;
@@ -18,6 +19,15 @@ interface SDKToolPart {
         };
     };
 }
+export declare function findToolResultsBySize(sessionID: string): ToolResultInfo[];
+export declare function findLargestToolResult(sessionID: string): ToolResultInfo | null;
+export declare function truncateToolResult(partPath: string): {
+    success: boolean;
+    toolName?: string;
+    originalSize?: number;
+};
+export declare function getTotalToolOutputSize(sessionID: string): number;
+export declare function countTruncatedResults(sessionID: string): number;
 export declare function findToolResultsBySizeFromSDK(client: OpencodeClient, sessionID: string): Promise<ToolResultInfo[]>;
 export declare function truncateToolResultAsync(client: OpencodeClient, sessionID: string, messageID: string, partId: string, part: SDKToolPart): Promise<{
     success: boolean;

package/dist/hooks/{anthropic-context-window-limit-recovery → context-window-limit-recovery}/types.d.ts

@@ -30,7 +30,7 @@ export declare const RETRY_CONFIG: {
     readonly maxDelayMs: 30000;
 };
 export declare const TRUNCATE_CONFIG: {
-    readonly maxTruncateAttempts: 20;
+    readonly maxTruncateAttempts: 5;
     readonly minOutputSizeToTruncate: 500;
     readonly targetTokenRatio: 0.5;
     readonly charsPerToken: 4;

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

@@ -1,5 +1,9 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-export declare function createContextWindowMonitorHook(_ctx: PluginInput): {
+import type { MatrixxConfig } from "../config";
+import type { ExperimentalConfig } from "../config/schema/experimental";
+export declare function createContextWindowMonitorHook(_ctx: PluginInput, pluginConfig?: MatrixxConfig | {
+    experimental?: ExperimentalConfig;
+}): {
     "tool.execute.after": (input: {
         tool: string;
         sessionID: string;

package/dist/hooks/failure-counter/counter.d.ts

@@ -0,0 +1,7 @@
+import { clearFailureCounter, getFailureCount, resetFailureCounter } from "../../features/session-state/state";
+export declare const CONTINUATION_COOLDOWN_MS = 30000;
+export interface HandleToolAfterOptions {
+    parentSessionID?: string;
+}
+export declare function handleToolAfter(sessionID: string, output: string, isSuccess: boolean, options?: HandleToolAfterOptions): void;
+export { clearFailureCounter, getFailureCount, resetFailureCounter };

package/dist/hooks/failure-counter/counter.test.d.ts

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

package/dist/hooks/failure-counter/hook.d.ts

@@ -0,0 +1,18 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+export declare function createFailureCounterHook(_ctx: PluginInput): {
+    "tool.execute.after": (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+    event: (input: {
+        event: {
+            type: string;
+            properties: Record<string, unknown>;
+        };
+    }) => Promise<void>;
+};

package/dist/hooks/failure-counter/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./counter";
+export { createFailureCounterHook } from "./hook";
+export * from "./patterns";

package/dist/hooks/failure-counter/patterns.d.ts

@@ -0,0 +1,6 @@
+export interface FailureSignature {
+    pattern: string | RegExp;
+    kind: "task_error" | "timeout" | "abort_excluded";
+}
+export declare const FAILURE_COUNTER_PATTERNS: FailureSignature[];
+export declare function isCountableFailure(output: string): boolean;

package/dist/hooks/failure-counter/patterns.test.d.ts

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

package/dist/hooks/index.d.ts

@@ -1,5 +1,4 @@
 export { createAgentUsageReminderHook } from "./agent-usage-reminder";
-export { type AnthropicContextWindowLimitRecoveryOptions, createAnthropicContextWindowLimitRecoveryHook } from "./anthropic-context-window-limit-recovery";
 export { createArchitectHook } from "./architect";
 export { createAutoSlashCommandHook } from "./auto-slash-command";
 export { createAutoUpdateCheckerHook } from "./auto-update-checker";
@@ -10,11 +9,11 @@ export { createCommentCheckerHooks } from "./comment-checker";
 export { createCompactionContextInjector } from "./compaction-context-injector";
 export { createCompactionTodoPreserverHook } from "./compaction-todo-preserver";
 export { createContextModeEnforcerHook } from "./context-mode-enforcer";
+export { type ContextWindowLimitRecoveryOptions, type ContextWindowLimitRecoveryOptions as AnthropicContextWindowLimitRecoveryOptions, createContextWindowLimitRecoveryHook, createContextWindowLimitRecoveryHook as createAnthropicContextWindowLimitRecoveryHook } from "./context-window-limit-recovery";
 export { createContextWindowMonitorHook } from "./context-window-monitor";
 export { createDelegateTaskRetryHook } from "./delegate-task-retry";
 export { createDesignIntentPreserverHook } from "./design-intent-preserver";
 export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
-export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
 export { createEditErrorRecoveryHook } from "./edit-error-recovery";
 export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
 export { createEnvContextInjectorHook } from "./env-context-injector";
@@ -23,20 +22,20 @@ export { createEvolutionCompressorHook } from "./evolution-compressor";
 export { createEvolutionHitlHook } from "./evolution-hitl";
 export { passesQualityGate } from "./evolution-quality-gate";
 export { createEvolutionWatcherHook } from "./evolution-watcher";
+export { createFailureCounterHook } from "./failure-counter";
 export { createHashlineEditDiffEnhancerHook } from "./hashline-edit-diff-enhancer";
 export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
+export { createInputSecretGuardHook } from "./input-secret-guard";
 export { createInteractiveBashSessionHook } from "./interactive-bash-session";
 export { createJsonErrorRecoveryHook } from "./json-error-recovery";
 export { createKeywordDetectorHook } from "./keyword-detector";
 export { createMatrixLoopHook, type MatrixLoopHook } from "./matrix-loop";
-export { createMcpStartupNotificationHook } from "./mcp-startup-notification";
 export { createMouseNotepadHook } from "./mouse-notepad";
 export { createNonInteractiveEnvHook } from "./non-interactive-env";
 export { createOracleMdOnlyHook } from "./oracle-md-only";
 export { createPlanPersister } from "./plan-persister";
 export { createPreemptiveCompactionHook } from "./preemptive-compaction";
 export { createQualityGateHook } from "./quality-gate/hook";
-export { createQuestionLabelTruncatorHook } from "./question-label-truncator";
 export { createReadImageResizerHook } from "./read-image-resizer";
 export { createRtkBashRewriterHook } from "./rtk-bash-rewriter";
 export { createRulesInjectorHook } from "./rules-injector";

package/dist/hooks/input-secret-guard/detection-rules.d.ts

@@ -0,0 +1,10 @@
+export interface Rule {
+    id: string;
+    pattern: string;
+    description: string;
+    severity: "block" | "warn";
+}
+export type RuleSeverity = "block" | "warn";
+export type DetectionRule = Rule;
+export declare const BLOCKLIST_RULES: Rule[];
+export declare const WARNLIST_HEURISTICS: Rule[];

package/dist/hooks/input-secret-guard/detector.d.ts

@@ -0,0 +1,22 @@
+import { hashFinding, redactMatch } from "./redactor";
+export type Finding = {
+    ruleId: string;
+    match: string;
+    redacted: string;
+    severity: "block" | "warn";
+    start: number;
+    end: number;
+};
+export type CompiledRule = {
+    id: string;
+    severity: "block" | "warn";
+    regex: RegExp;
+};
+export declare function shannonEntropy(token: string): number;
+export declare function compileRules(): CompiledRule[];
+export declare function detectSecrets(text: string, opts?: {
+    maxScanBytes?: number;
+    allowlist?: string[];
+    entropyThreshold?: number;
+}): Finding[];
+export { hashFinding, redactMatch };

package/dist/hooks/input-secret-guard/detector.test.d.ts

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

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

@@ -0,0 +1,19 @@
+import type { PluginInput } from "@opencode-ai/plugin";
+import type { InputSecretGuardConfig } from "../../config/schema/security";
+export declare function createInputSecretGuardHook(ctx: PluginInput, cfg?: InputSecretGuardConfig): {
+    "chat.message": (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+    }, output: {
+        message: Record<string, unknown>;
+        parts: Array<{
+            type: string;
+            text?: string;
+            [key: string]: unknown;
+        }>;
+    }) => Promise<void>;
+};

package/dist/hooks/input-secret-guard/hook.test.d.ts

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

package/dist/hooks/input-secret-guard/index.d.ts

@@ -0,0 +1 @@
+export { createInputSecretGuardHook } from "./hook";

package/dist/hooks/input-secret-guard/redactor.d.ts

@@ -0,0 +1,2 @@
+export declare function redactMatch(raw: string): string;
+export declare function hashFinding(ruleId: string, redacted: string): string;

package/dist/hooks/input-secret-guard/redactor.test.d.ts

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

package/dist/hooks/input-secret-guard/session-allow-cache.d.ts

@@ -0,0 +1,6 @@
+export declare function isSessionAllowed(sessionID: string, hash: string): boolean;
+export declare function allowOnce(sessionID: string, hash: string): void;
+export declare function allowSession(sessionID: string, hash: string): void;
+export declare function consumeOneShot(sessionID: string, hash: string): boolean;
+export declare function clearSession(sessionID: string): void;
+export declare function clearAll(): void;

package/dist/hooks/input-secret-guard/session-allow-cache.test.d.ts

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

package/dist/hooks/interactive-bash-session/hook.test.d.ts

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

package/dist/hooks/keyword-detector/analyze/default.d.ts

@@ -9,4 +9,4 @@
  * - Vietnamese: phân tích, điều tra, nghiên cứu, kiểm tra, xem xét, chẩn đoán, giải thích, tìm hiểu, gỡ lỗi, tại sao
  */
 export declare const ANALYZE_PATTERN: RegExp;
-export declare const ANALYZE_MESSAGE = "[analyze-mode]\nANALYSIS MODE. Gather context before diving deep:\n\nCONTEXT GATHERING (parallel):\n- 1-2 trinity agents (codebase patterns, implementations)\n- 1-2 operator agents (if external library involved)\n- Direct tools: Grep, AST-grep, LSP for targeted searches\n\nIF COMPLEX - DO NOT STRUGGLE ALONE. Consult specialists:\n- **Oracle**: Conventional problems (architecture, debugging, complex logic)\n- **Matrix-bend**: Non-conventional problems (different approach needed)\n\nSYNTHESIZE findings before proceeding.";
+export declare const ANALYZE_MESSAGE = "[analyze-mode]\nANALYSIS MODE. Gather context before diving deep:\n\nCONTEXT GATHERING (parallel):\n- 1-2 trinity agents (codebase patterns, implementations)\n- 1-2 operator agents (if external library involved)\n- Direct tools: Grep (if available), AST-grep, LSP for targeted searches\n\nIF COMPLEX - DO NOT STRUGGLE ALONE. Consult specialists:\n- **Oracle**: Conventional problems (architecture, debugging, complex logic)\n- **Matrix-bend**: Non-conventional problems (different approach needed)\n\nSYNTHESIZE findings before proceeding.";

package/dist/hooks/keyword-detector/search/default.d.ts

@@ -9,4 +9,4 @@
  * - Vietnamese: tìm kiếm, tra cứu, định vị, quét, phát hiện, truy tìm, tìm ra, ở đâu, liệt kê
  */
 export declare const SEARCH_PATTERN: RegExp;
-export declare const SEARCH_MESSAGE = "[search-mode]\nMAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:\n- trinity agents (codebase patterns, file structures, ast-grep)\n- operator agents (remote repos, official docs, GitHub examples)\nPlus direct tools: Grep, ripgrep (rg), ast-grep (sg)\nNEVER stop at first result - be exhaustive.";
+export declare const SEARCH_MESSAGE = "[search-mode]\nMAXIMIZE SEARCH EFFORT. Launch multiple background agents IN PARALLEL:\n- trinity agents (codebase patterns, file structures, ast-grep)\n- operator agents (remote repos, official docs, GitHub examples)\nPlus direct tools: Grep (if available), ripgrep (rg), ast-grep (sg)\nNEVER stop at first result - be exhaustive.";