opencode-matrixx 2.6.3 → 2.6.4

package/dist/agents/types.d.ts

@@ -55,7 +55,7 @@ export interface AgentPromptMetadata {
 export declare function isGptModel(model: string): boolean;
 /**
  * Detect Anthropic/Claude models by provider or model name.
- * Matches: "anthropic/claude-*", "google-vertex-anthropic/claude-*", etc.
+ * Matches: "<provider>/<model>" e.g., provider/model strings containing relevant indicators — replace with live model from provider.list
  */
 export declare function isAnthropicModel(model: string): boolean;
 export declare function isQwenModel(model: string): boolean;

package/dist/cli.js

@@ -46,6 +46,7 @@ var __export = (target, all) => {
       set: __exportSetter.bind(all, name)
     });
 };
+var __require = import.meta.require;
 
 // node_modules/sisteransi/src/index.js
 var require_src = __commonJS(function(exports, module) {
@@ -128,6 +129,9 @@ function getCacheDir() {
 function getOmoOpenCodeCacheDir() {
   return path.join(getCacheDir(), "matrixx");
 }
+function getOpenCodeCacheDir() {
+  return path.join(getCacheDir(), "opencode");
+}
 
 // src/shared/logger.ts
 import * as fs from "fs";
@@ -16127,6 +16131,13 @@ var ExperimentalConfigSchema = exports_external.object({
   hashline_edit: exports_external.boolean().optional()
 });
 
+// src/config/schema/failure-counter.ts
+var FailureCounterConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  threshold: exports_external.number().min(1).max(10).default(2),
+  resetOnSuccess: exports_external.boolean().default(true)
+});
+
 // src/config/schema/headroom.ts
 var HeadroomConfigSchema = exports_external.object({
   enabled: exports_external.boolean().default(false),
@@ -16196,7 +16207,9 @@ var HookNameEnum = exports_external.enum([
   "evolution-compressor",
   "evolution-hitl",
   "context-mode-enforcer",
-  "task-edit-guard"
+  "context-mode-enforcer",
+  "task-edit-guard",
+  "failure-counter"
 ]);
 var HookNameSchema = exports_external.union([
   HookNameEnum,
@@ -16216,11 +16229,64 @@ var MatrixxSelfConfigSkillConfigSchema = exports_external.object({
   proactive: exports_external.boolean().default(false)
 });
 
+// src/config/schema/model-config.ts
+var ModelFallbackEntrySchema = exports_external.object({
+  providers: exports_external.array(exports_external.string().min(1)),
+  model: exports_external.string().min(1),
+  variant: exports_external.string().optional()
+});
+var TierSpecSchema = exports_external.object({
+  providerPriority: exports_external.array(exports_external.string()),
+  modelPattern: exports_external.string().refine((s) => {
+    try {
+      new RegExp(s);
+      return true;
+    } catch {
+      return false;
+    }
+  }, { message: "Invalid regex pattern" }),
+  fallbackTier: exports_external.string().optional(),
+  fallback: exports_external.array(ModelFallbackEntrySchema).optional()
+});
+var TiersSchema = exports_external.record(exports_external.string(), TierSpecSchema);
+var complexityDowngradeValueSchema = exports_external.string().refine((s) => {
+  if (s.startsWith("tier:")) {
+    const name = s.slice(5);
+    return name.length > 0;
+  }
+  if (s.includes("/")) {
+    const parts = s.split("/");
+    return parts.length === 2 && parts[0].length > 0 && parts[1].length > 0;
+  }
+  return false;
+}, { message: "Must be tier:<name> or <provider>/<model>" });
+var ComplexityDowngradesSchema = exports_external.record(exports_external.string(), exports_external.record(exports_external.string(), complexityDowngradeValueSchema));
+var AgentModelRequirementsSchema = exports_external.object({
+  fallbackChain: exports_external.array(ModelFallbackEntrySchema),
+  requiresModel: exports_external.string().optional(),
+  requiresAnyModel: exports_external.boolean().optional(),
+  requiresProvider: exports_external.array(exports_external.string()).optional(),
+  variant: exports_external.string().optional()
+});
+var CategoryModelRequirementsSchema = exports_external.object({
+  fallbackChain: exports_external.array(ModelFallbackEntrySchema),
+  requiresModel: exports_external.string().optional(),
+  requiresAnyModel: exports_external.boolean().optional(),
+  requiresProvider: exports_external.array(exports_external.string()).optional(),
+  variant: exports_external.string().optional()
+});
+var ModelRequirementsSchema = exports_external.object({
+  agents: exports_external.record(exports_external.string(), AgentModelRequirementsSchema).optional(),
+  categories: exports_external.record(exports_external.string(), CategoryModelRequirementsSchema).optional()
+});
+
 // src/config/schema/morpheus.ts
 var MorpheusTasksConfigSchema = exports_external.object({
   storage_path: exports_external.string().optional(),
   task_list_id: exports_external.string().optional(),
-  scope: exports_external.enum(["global", "project"]).default("project").optional().describe("Task storage scope: project \u2192 .matrixx/tasks per project (default), global \u2192 ~/.config/opencode/tasks/{listId}")
+  scope: exports_external.enum(["global", "project"]).default("project").optional().describe("Task storage scope: project \u2192 .matrixx/tasks per project (default), global \u2192 ~/.config/opencode/tasks/{listId}"),
+  stale_after_hours: exports_external.number().int().min(1).optional().describe("Pending tasks with no file activity for this many hours are considered stale (default: 24). Stale tasks are excluded from task-continuation directives."),
+  session_scoped: exports_external.boolean().default(true).optional().describe("When true, the task-continuation-enforcer only considers tasks created by the current session (or its subagent sessions). When false, all project tasks are considered regardless of session origin.")
 });
 var MorpheusConfigSchema = exports_external.object({
   tasks: MorpheusTasksConfigSchema.optional()
@@ -16389,6 +16455,7 @@ var MatrixxConfigSchema = exports_external.object({
   auto_update: exports_external.boolean().optional(),
   skills: SkillsConfigSchema.optional(),
   matrix_loop: MatrixLoopConfigSchema.optional(),
+  failure_counter: FailureCounterConfigSchema.optional(),
   background_task: BackgroundTaskConfigSchema.optional(),
   notification: NotificationConfigSchema.optional(),
   babysitting: BabysittingConfigSchema.optional(),
@@ -16406,7 +16473,10 @@ var MatrixxConfigSchema = exports_external.object({
   context_mode: ContextModeConfigSchema.optional(),
   rtk: RtkConfigSchema.optional(),
   evolution: EvolutionConfigSchema.optional(),
-  _migrations: exports_external.array(exports_external.string()).optional()
+  _migrations: exports_external.array(exports_external.string()).optional(),
+  tiers: TiersSchema.optional(),
+  modelRequirements: ModelRequirementsSchema.optional(),
+  complexityDowngrades: ComplexityDowngradesSchema.optional()
 });
 
 // src/cli/doctor/checks/config.ts
@@ -16483,7 +16553,38 @@ var configValidationCheck = {
 
 // src/cli/doctor/checks/context-mode.ts
 import { existsSync as existsSync6, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir4 } from "os";
 import { join as join7 } from "path";
+function resolveDisciplineInfo() {
+  const candidates = [];
+  try {
+    const resolved = __require.resolve("context-mode/configs/opencode/AGENTS.md");
+    candidates.push(resolved);
+  } catch {}
+  try {
+    candidates.push(join7(getOpenCodeCacheDir(), "packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md"));
+  } catch {}
+  try {
+    const base = process.env.XDG_CACHE_HOME ?? join7(homedir4(), ".cache");
+    candidates.push(join7(base, "opencode/packages/context-mode@latest/node_modules/context-mode/configs/opencode/AGENTS.md"));
+  } catch {}
+  for (const p of candidates) {
+    try {
+      if (existsSync6(p)) {
+        let version2 = null;
+        try {
+          const pkgPath = join7(p.replace(/configs\/opencode\/AGENTS\.md$/, ""), "package.json");
+          const pkgRaw = readFileSync5(pkgPath, "utf-8");
+          const pkg = JSON.parse(pkgRaw);
+          if (typeof pkg.version === "string")
+            version2 = pkg.version;
+        } catch {}
+        return { path: p, version: version2 };
+      }
+    } catch {}
+  }
+  return { path: null, version: null };
+}
 function loadContextModeConfig() {
   const dir = getOpenCodeConfigDir({ binary: "opencode" });
   const bases = [join7(dir, "matrixx"), join7(process.cwd(), ".opencode", "matrixx"), join7(process.cwd(), "matrixx")];
@@ -16554,11 +16655,15 @@ var contextModeCheck = {
 Cache dir: ${cacheDir} ${hasCache ? "(exists)" : "(not found \u2014 will be created on first use)"}`
       };
     }
+    const discipline = resolveDisciplineInfo();
+    const disciplineLine = discipline.path ? `Discipline: ${discipline.path}${discipline.version ? ` (v${discipline.version})` : ""}` : "Discipline: not found \u2014 fallback table in use";
     return {
       name: "context-mode-integration",
       status: "pass",
-      message: `context-mode plugin registered${hasCache ? ", cache present" : " (cache not yet created)"}`,
-      detail: `Cache: ${cacheDir}`
+      message: `context-mode plugin registered${hasCache ? ", cache present" : " (cache not yet created)"}${discipline.version ? `, discipline v${discipline.version}` : ""}`,
+      detail: `Cache: ${cacheDir}
+${disciplineLine}
+Plan tools: plan_create/read/update/list/delete (unconditional)`
     };
   }
 };
@@ -16810,7 +16915,7 @@ Then warm cache: uvx --from markitdown-mcp markitdown-mcp --help` };
 
 // src/cli/doctor/checks/optional.ts
 import { existsSync as existsSync9 } from "fs";
-import { homedir as homedir4 } from "os";
+import { homedir as homedir5 } from "os";
 import { join as join10 } from "path";
 function spawnVersion(cmd, args) {
   try {
@@ -16823,7 +16928,7 @@ function spawnVersion(cmd, args) {
 }
 function cachedCommentChecker() {
   try {
-    const cacheDir = process.env.XDG_CACHE_HOME ? join10(process.env.XDG_CACHE_HOME, "matrixx", "bin") : join10(homedir4(), ".cache", "matrixx", "bin");
+    const cacheDir = process.env.XDG_CACHE_HOME ? join10(process.env.XDG_CACHE_HOME, "matrixx", "bin") : join10(homedir5(), ".cache", "matrixx", "bin");
     const bin = process.platform === "win32" ? "comment-checker.exe" : "comment-checker";
     const p = join10(cacheDir, bin);
     if (existsSync9(p)) {
@@ -17333,10 +17438,10 @@ async function executeDoctor(options = {}) {
 
 // src/cli/install/index.ts
 import { existsSync as existsSync13, mkdirSync as mkdirSync2, readFileSync as readFileSync11, writeFileSync as writeFileSync2 } from "fs";
-import { homedir as homedir5 } from "os";
+import { homedir as homedir6 } from "os";
 import { join as join14 } from "path";
 function getOpenCodeConfigPath() {
-  const configDir = join14(homedir5(), ".config", "opencode");
+  const configDir = join14(homedir6(), ".config", "opencode");
   const jsonPath = join14(configDir, "opencode.json");
   const jsoncPath = join14(configDir, "opencode.jsonc");
   if (existsSync13(jsoncPath))
@@ -17379,7 +17484,7 @@ function generatePluginEntry(absolutePath, forceLocal) {
   return "opencode-matrixx";
 }
 async function executeInstall(options) {
-  const configDir = join14(homedir5(), ".config", "opencode");
+  const configDir = join14(homedir6(), ".config", "opencode");
   const configPath = getOpenCodeConfigPath();
   if (!existsSync13(configDir)) {
     mkdirSync2(configDir, { recursive: true });

package/dist/config/migrations/index.d.ts

@@ -0,0 +1 @@
+export { migrateMatrixxConfig, normalizeModelInput } from "./model-migration";

package/dist/config/migrations/model-migration.d.ts

@@ -0,0 +1,18 @@
+import type { MatrixxConfig } from "../schema/matrixx-config";
+/**
+ * Normalize a single model string input.
+ * - tier:<name> → unchanged, no warning
+ * - contains "/" (prefixed provider/model) → emit deprecation warning, keep value
+ * - bare model → unchanged, no warning
+ *
+ * Provider names are opaque strings — no hardcoded allow-list.
+ */
+export declare function normalizeModelInput(value: string): string;
+/**
+ * In-memory migration for MatrixxConfig model fields.
+ * Iterates global_model, tiers fallback models, modelRequirements fallbackChain models,
+ * and complexityDowngrades values. Normalizes each via normalizeModelInput.
+ * Only mutates in memory — never rewrites the user's config file on disk.
+ * Idempotent via _migrations guard.
+ */
+export declare function migrateMatrixxConfig(raw: MatrixxConfig): MatrixxConfig;

package/dist/config/resolve-tiers.d.ts

@@ -28,5 +28,5 @@ export declare function resolveTiersInConfig(config: MatrixxConfig, ctx: TierRes
  * downstream code (createBuiltinAgents, buildAgent) only ever sees model
  * strings.
  */
-export declare function resolveTiersInCategoryRegistry(registry: Record<string, WithTier | undefined>, ctx: TierResolverContext): Record<string, WithTier>;
+export declare function resolveTiersInCategoryRegistry(registry: Record<string, WithTier | undefined>, ctx: TierResolverContext, config?: MatrixxConfig): Record<string, WithTier>;
 export {};

package/dist/config/schema/failure-counter.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+export declare const FailureCounterConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    threshold: z.ZodDefault<z.ZodNumber>;
+    resetOnSuccess: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type FailureCounterConfig = z.infer<typeof FailureCounterConfigSchema>;

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

@@ -60,5 +60,6 @@ export declare const HookNameSchema: z.ZodUnion<readonly [z.ZodEnum<{
     "evolution-hitl": "evolution-hitl";
     "context-mode-enforcer": "context-mode-enforcer";
     "task-edit-guard": "task-edit-guard";
+    "failure-counter": "failure-counter";
 }>, z.ZodPipe<z.ZodLiteral<"anthropic-context-window-limit-recovery">, z.ZodTransform<"context-window-limit-recovery", "anthropic-context-window-limit-recovery">>]>;
 export type HookName = z.infer<typeof HookNameSchema>;

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

@@ -128,6 +128,7 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         "evolution-hitl": "evolution-hitl";
         "context-mode-enforcer": "context-mode-enforcer";
         "task-edit-guard": "task-edit-guard";
+        "failure-counter": "failure-counter";
     }>, z.ZodPipe<z.ZodLiteral<"anthropic-context-window-limit-recovery">, z.ZodTransform<"context-window-limit-recovery", "anthropic-context-window-limit-recovery">>]>>>;
     disabled_commands: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         "bdd-contract": "bdd-contract";
@@ -1803,6 +1804,11 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         default_max_iterations: z.ZodDefault<z.ZodNumber>;
         state_dir: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>>;
+    failure_counter: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        threshold: z.ZodDefault<z.ZodNumber>;
+        resetOnSuccess: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>;
     background_task: z.ZodOptional<z.ZodObject<{
         defaultConcurrency: z.ZodOptional<z.ZodNumber>;
         providerConcurrency: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
@@ -1860,6 +1866,8 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
                 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>>;
     assembly: z.ZodOptional<z.ZodObject<{
@@ -1984,5 +1992,40 @@ export declare const MatrixxConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     _migrations: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    tiers: z.ZodOptional<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>>>;
+    modelRequirements: z.ZodOptional<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>>;
+    complexityDowngrades: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
 }, z.core.$strip>;
 export type MatrixxConfig = z.infer<typeof MatrixxConfigSchema>;

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

@@ -6,6 +6,8 @@ declare const MorpheusTasksConfigSchema: z.ZodObject<{
         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<{
@@ -15,6 +17,8 @@ export declare const MorpheusConfigSchema: z.ZodObject<{
             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.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

@@ -66,6 +66,7 @@ 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;

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/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

@@ -22,6 +22,7 @@ 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";

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

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