opencode-matrixx 2.6.3 → 2.6.4

package/dist/matrixx.schema.json

@@ -167,7 +167,8 @@
               "evolution-compressor",
               "evolution-hitl",
               "context-mode-enforcer",
-              "task-edit-guard"
+              "task-edit-guard",
+              "failure-counter"
             ]
           },
           {}
@@ -4722,6 +4723,31 @@
       ],
       "additionalProperties": false
     },
+    "failure_counter": {
+      "type": "object",
+      "properties": {
+        "enabled": {
+          "default": true,
+          "type": "boolean"
+        },
+        "threshold": {
+          "default": 2,
+          "type": "number",
+          "minimum": 1,
+          "maximum": 10
+        },
+        "resetOnSuccess": {
+          "default": true,
+          "type": "boolean"
+        }
+      },
+      "required": [
+        "enabled",
+        "threshold",
+        "resetOnSuccess"
+      ],
+      "additionalProperties": false
+    },
     "background_task": {
       "type": "object",
       "properties": {
@@ -4915,6 +4941,17 @@
                 "global",
                 "project"
               ]
+            },
+            "stale_after_hours": {
+              "description": "Pending tasks with no file activity for this many hours are considered stale (default: 24). Stale tasks are excluded from task-continuation directives.",
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 9007199254740991
+            },
+            "session_scoped": {
+              "description": "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.",
+              "default": true,
+              "type": "boolean"
             }
           },
           "additionalProperties": false
@@ -5523,6 +5560,196 @@
       "items": {
         "type": "string"
       }
+    },
+    "tiers": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
+      "additionalProperties": {
+        "type": "object",
+        "properties": {
+          "providerPriority": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          },
+          "modelPattern": {
+            "type": "string"
+          },
+          "fallbackTier": {
+            "type": "string"
+          },
+          "fallback": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "properties": {
+                "providers": {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "minLength": 1
+                  }
+                },
+                "model": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "variant": {
+                  "type": "string"
+                }
+              },
+              "required": [
+                "providers",
+                "model"
+              ],
+              "additionalProperties": false
+            }
+          }
+        },
+        "required": [
+          "providerPriority",
+          "modelPattern"
+        ],
+        "additionalProperties": false
+      }
+    },
+    "modelRequirements": {
+      "type": "object",
+      "properties": {
+        "agents": {
+          "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "fallbackChain": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "providers": {
+                      "type": "array",
+                      "items": {
+                        "type": "string",
+                        "minLength": 1
+                      }
+                    },
+                    "model": {
+                      "type": "string",
+                      "minLength": 1
+                    },
+                    "variant": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "providers",
+                    "model"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "requiresModel": {
+                "type": "string"
+              },
+              "requiresAnyModel": {
+                "type": "boolean"
+              },
+              "requiresProvider": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "variant": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "fallbackChain"
+            ],
+            "additionalProperties": false
+          }
+        },
+        "categories": {
+          "type": "object",
+          "propertyNames": {
+            "type": "string"
+          },
+          "additionalProperties": {
+            "type": "object",
+            "properties": {
+              "fallbackChain": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "providers": {
+                      "type": "array",
+                      "items": {
+                        "type": "string",
+                        "minLength": 1
+                      }
+                    },
+                    "model": {
+                      "type": "string",
+                      "minLength": 1
+                    },
+                    "variant": {
+                      "type": "string"
+                    }
+                  },
+                  "required": [
+                    "providers",
+                    "model"
+                  ],
+                  "additionalProperties": false
+                }
+              },
+              "requiresModel": {
+                "type": "string"
+              },
+              "requiresAnyModel": {
+                "type": "boolean"
+              },
+              "requiresProvider": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "variant": {
+                "type": "string"
+              }
+            },
+            "required": [
+              "fallbackChain"
+            ],
+            "additionalProperties": false
+          }
+        }
+      },
+      "additionalProperties": false
+    },
+    "complexityDowngrades": {
+      "type": "object",
+      "propertyNames": {
+        "type": "string"
+      },
+      "additionalProperties": {
+        "type": "object",
+        "propertyNames": {
+          "type": "string"
+        },
+        "additionalProperties": {
+          "type": "string"
+        }
+      }
     }
   },
   "additionalProperties": false

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

@@ -46,6 +46,7 @@ export declare function createCoreHooks(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/plugin/hooks/create-session-hooks.d.ts

@@ -1,5 +1,5 @@
 import type { HookName, MatrixxConfig } from "../../config";
-import { createAgentUsageReminderHook, createAutoUpdateCheckerHook, createContextWindowLimitRecoveryHook, createContextWindowMonitorHook, createDelegateTaskRetryHook, createEditErrorRecoveryHook, createInteractiveBashSessionHook, createMatrixLoopHook, createMouseNotepadHook, createNonInteractiveEnvHook, createOracleMdOnlyHook, createPreemptiveCompactionHook, createRtkBashRewriterHook, createRuntimeFallbackHook, createSessionNotification, createSessionRecoveryHook, createStartWorkHook, createTaskResumeInfoHook, createThinkModeHook } from "../../hooks";
+import { createAgentUsageReminderHook, createAutoUpdateCheckerHook, createContextWindowLimitRecoveryHook, createContextWindowMonitorHook, createDelegateTaskRetryHook, createEditErrorRecoveryHook, createFailureCounterHook, createInteractiveBashSessionHook, createMatrixLoopHook, createMouseNotepadHook, createNonInteractiveEnvHook, createOracleMdOnlyHook, createPreemptiveCompactionHook, createRtkBashRewriterHook, createRuntimeFallbackHook, createSessionNotification, createSessionRecoveryHook, createStartWorkHook, createTaskResumeInfoHook, createThinkModeHook } from "../../hooks";
 import { createAnthropicEffortHook } from "../../hooks/anthropic-effort";
 import type { PluginContext } from "../types";
 export type SessionHooks = {
@@ -16,6 +16,7 @@ export type SessionHooks = {
     matrixLoop: ReturnType<typeof createMatrixLoopHook> | null;
     editErrorRecovery: ReturnType<typeof createEditErrorRecoveryHook> | null;
     delegateTaskRetry: ReturnType<typeof createDelegateTaskRetryHook> | null;
+    failureCounter: ReturnType<typeof createFailureCounterHook> | null;
     startWork: ReturnType<typeof createStartWorkHook> | null;
     oracleMdOnly: ReturnType<typeof createOracleMdOnlyHook> | null;
     mouseNotepad: ReturnType<typeof createMouseNotepadHook> | null;

package/dist/plugin-handlers/oracle-agent-config-builder.d.ts

@@ -1,4 +1,4 @@
-import type { CategoryConfig } from "../config/schema";
+import type { CategoryConfig, ModelRequirements } from "../config/schema";
 type OracleOverride = Record<string, unknown> & {
     category?: string;
     model?: string;
@@ -20,5 +20,6 @@ export declare function buildOracleAgentConfig(params: {
     userCategories: Record<string, CategoryConfig> | undefined;
     currentModel: string | undefined;
     globalOverrideModel?: string;
+    modelRequirements?: ModelRequirements;
 }): Promise<Record<string, unknown>>;
 export {};

package/dist/shared/awaiting-user.d.ts

@@ -0,0 +1,12 @@
+export declare const AWAITING_USER_SUPPRESS_MS: number;
+export interface AwaitingUserState {
+    awaitingUser?: boolean;
+    awaitingUserSince?: number;
+}
+export declare function isAwaitingUserState(state: unknown): boolean;
+export declare function markAwaitingUser(state: unknown, now?: number): void;
+export declare function clearAwaitingUser(state: unknown): void;
+export declare function hasPendingQuestionMessage(messages: Array<unknown>): boolean;
+export declare function isAwaitingUser(state: unknown, messages?: Array<unknown>): boolean;
+export declare function getToolName(properties: Record<string, unknown> | undefined): string | undefined;
+export declare function isQuestionTool(properties: Record<string, unknown> | undefined): boolean;

package/dist/shared/merge-categories.d.ts

@@ -7,4 +7,15 @@ import type { CategoriesConfig, CategoryConfig } from "../config/schema";
  * returning, the tier fields are resolved against the live provider cache
  * (or the static fallback) so callers always see concrete `model:` strings.
  */
-export declare function mergeCategories(userCategories?: CategoriesConfig): Record<string, CategoryConfig>;
+export declare function mergeCategories(userCategories?: CategoriesConfig, config?: {
+    tiers?: Record<string, {
+        providerPriority: string[];
+        modelPattern: string;
+        fallbackTier?: string;
+        fallback?: {
+            providers: string[];
+            model: string;
+            variant?: string;
+        }[];
+    }>;
+} | null): Record<string, CategoryConfig>;

package/dist/shared/model-requirements.d.ts

@@ -1,3 +1,4 @@
+import { type ModelRequirements } from "../config/schema/model-config";
 export type FallbackEntry = {
     providers: string[];
     model: string;
@@ -10,5 +11,13 @@ export type ModelRequirement = {
     requiresAnyModel?: boolean;
     requiresProvider?: string[];
 };
+export declare const DEFAULT_AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare const DEFAULT_CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
 export declare const AGENT_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
 export declare const CATEGORY_MODEL_REQUIREMENTS: Record<string, ModelRequirement>;
+export declare function getAgentModelRequirements(config?: {
+    modelRequirements?: ModelRequirements;
+} | null): Record<string, ModelRequirement>;
+export declare function getCategoryModelRequirements(config?: {
+    modelRequirements?: ModelRequirements;
+} | null): Record<string, ModelRequirement>;

package/dist/shared/model-tiers.d.ts

@@ -2,30 +2,43 @@
  * Tier registry — abstract model classifications resolved against the live provider list.
  *
  * Tiers are matched by regex against "provider/model" strings, with a `providerPriority`
- * list to choose between providers when multiple match. A `staticFallback` is used at
- * first run when the live provider list is not yet available.
- *
- * Adding a new model does NOT require code changes — the regex patterns intentionally
- * match model families (e.g. `claude-opus`) so a new opus-4-7 model is picked up
- * automatically.
+ * list to choose between providers when multiple match. Patterns are stored as
+ * strings in `config.tiers[].modelPattern` and compiled at runtime via
+ * `new RegExp` with try/catch (invalid -> never matches). No hardcoded
+ * `provider` or model literals — all specs are config-driven via
+ * `MatrixxConfig.tiers`. When config is empty, factories return empty/undefined
+ * gracefully.
  */
-export type TierName = "free" | "fast" | "standard" | "premium" | "frontier";
+export type TierName = string;
 export interface TierSpec {
-    name: TierName;
+    name: string;
     /** Provider priority — first provider with a matching model wins. */
     providerPriority: string[];
     /** Regex tested against each "provider/model" string in the live provider list. */
     modelPattern: RegExp;
     /** Tier to recurse into if this tier cannot be satisfied. */
-    fallbackTier?: TierName;
-    /** Static fallbacks used at first run when the live provider list is empty
-     *  but the connected providers cache already lists which providers are reachable. */
-    staticFallback: {
+    fallbackTier?: string;
+    /** Fallbacks used when the live provider list is empty but config provides them. */
+    fallback?: {
         providers: string[];
         model: string;
         variant?: string;
     }[];
 }
-export declare const TIER_SPECS: Record<TierName, TierSpec>;
-export declare const TIER_NAMES: TierName[];
-export declare function parseTierReference(value: string | undefined | null): TierName | null;
+export type TiersConfig = Record<string, {
+    providerPriority: string[];
+    modelPattern: string;
+    fallbackTier?: string;
+    fallback?: {
+        providers: string[];
+        model: string;
+        variant?: string;
+    }[];
+}>;
+export type TierConfigHolder = {
+    tiers?: TiersConfig;
+} | null | undefined;
+export declare function buildTierSpecs(config: TierConfigHolder): Record<string, TierSpec>;
+export declare function getTierSpec(tierName: string, config: TierConfigHolder): TierSpec | undefined;
+export declare function getTierNames(config: TierConfigHolder): string[];
+export declare function parseTierReference(value: string | undefined | null, config?: TierConfigHolder): string | null;

package/dist/shared/tier-resolver.d.ts

@@ -1,4 +1,4 @@
-import { parseTierReference, type TierName } from "./model-tiers";
+import { type TierConfigHolder } from "./model-tiers";
 export interface TierResolverContext {
     availableModels: Set<string>;
     connectedProviders: string[] | null;
@@ -7,20 +7,20 @@ export type TierProvenance = "tier-resolved" | "tier-static-fallback";
 export interface TierResolutionResult {
     model: string;
     provenance: TierProvenance;
-    tier: TierName;
+    tier: string;
 }
 /**
  * Resolve a tier alias to a concrete "provider/model" string.
  *
  * Strategy:
  *   1. Live resolution: walk `providerPriority`, test `modelPattern` against
- *      each `provider/model` in the available set.
- *   2. Static fallback: pick the first static fallback whose provider is
- *      connected (used at first run when the live cache is cold).
+ *      each `provider/model` in the available set (config-driven, compiled at runtime).
+ *   2. Config fallback: pick the first `fallback` whose provider is
+ *      connected (used at first run when the live cache is cold, user-provided).
  *   3. Recurse into `fallbackTier` if defined.
  *
- * Returns null when no match is possible (no live models, no static fallback
- * available, no fallback tier).
+ * Returns null when no match is possible (no live models, no fallback
+ * available, no fallback tier). When config is empty, returns null gracefully.
  */
-export declare function resolveTier(tier: TierName, ctx: TierResolverContext): TierResolutionResult | null;
-export { parseTierReference };
+export declare function resolveTier(tier: string, ctx: TierResolverContext, config?: TierConfigHolder): TierResolutionResult | null;
+export declare function parseTierReference(value: string | undefined | null, config?: TierConfigHolder): string | null;

package/dist/tools/delegate-task/categories.d.ts

@@ -1,4 +1,4 @@
-import type { CategoriesConfig, CategoryConfig } from "../../config/schema";
+import type { CategoriesConfig, CategoryConfig, ModelRequirements } from "../../config/schema";
 import type { TierResolverContext } from "../../shared/tier-resolver";
 interface ResolveCategoryConfigOptions {
     userCategories?: CategoriesConfig;
@@ -6,6 +6,17 @@ interface ResolveCategoryConfigOptions {
     systemDefaultModel?: string;
     availableModels?: Set<string>;
     tierContext?: TierResolverContext;
+    modelRequirements?: ModelRequirements;
+    tiers?: Record<string, {
+        providerPriority: string[];
+        modelPattern: string;
+        fallbackTier?: string;
+        fallback?: {
+            providers: string[];
+            model: string;
+            variant?: string;
+        }[];
+    }>;
 }
 interface ResolveCategoryConfigResult {
     config: CategoryConfig;

package/dist/tools/delegate-task/complexity-constants.d.ts

@@ -1,24 +1,28 @@
+import type { Tiers } from "../../config/schema";
+import { type TierResolverContext } from "../../shared/tier-resolver";
 import type { ComplexityLevel } from "./complexity-types";
-/**
- * Built-in complexity-to-model downgrade targets per category.
- * Key: category name, Value: map of complexity level → model string.
- * Only levels 1-2 are downgradable; levels 3+ use the category's resolved model.
- */
-export declare const BUILTIN_COMPLEXITY_DOWNGRADES: Record<string, Partial<Record<ComplexityLevel, string>>>;
+export type ComplexityDowngradesConfig = Record<string, Record<string, string>>;
+export type ComplexityConfigHolder = {
+    complexityDowngrades?: ComplexityDowngradesConfig;
+    tiers?: Tiers;
+};
 /**
  * Resolve the model for a given category and complexity level.
  *
- * Returns the original model unchanged if:
- * - Complexity is 3+ (not eligible for downgrade)
- * - No downgrade target exists for this category/level combination
+ * Config-driven: no built-in literals. Downgrade map is resolved as:
+ *   userDowngrades ?? config.complexityDowngrades?.[category] ?? {}
+ * If no entry for this complexity, returns original (no downgrade).
+ * If value starts with "tier:", resolves via live tier resolver.
  *
  * @param category - The task category name
  * @param complexity - The complexity level (1-5)
  * @param originalModel - The currently resolved model string
- * @param userDowngrades - Optional per-category user override from CategoryConfig
+ * @param userDowngrades - Optional per-category user override from CategoryConfig.complexity_downgrades
+ * @param config - Optional holder with global complexityDowngrades and tiers
+ * @param tierContext - Optional live provider context for tier: resolution
  * @returns The model to use and whether a downgrade was applied
  */
-export declare function resolveComplexityModel(category: string, complexity: ComplexityLevel, originalModel: string, userDowngrades?: Record<string, string>): {
+export declare function resolveComplexityModel(category: string, complexity: ComplexityLevel, originalModel: string, userDowngrades?: Record<string, string>, config?: ComplexityConfigHolder | ComplexityDowngradesConfig, tierContext?: TierResolverContext): {
     model: string;
     downgraded: boolean;
 };

package/dist/tools/delegate-task/executor-types.d.ts

@@ -1,4 +1,4 @@
-import type { AgentOverrides, BrowserAutomationProvider, CategoriesConfig } from "../../config/schema";
+import type { AgentOverrides, BrowserAutomationProvider, CategoriesConfig, ComplexityDowngrades, ModelRequirements, Tiers } from "../../config/schema";
 import type { BackgroundManager } from "../../features/background-agent";
 import type { OpencodeClient } from "./types";
 export interface ExecutorContext {
@@ -10,6 +10,9 @@ export interface ExecutorContext {
     globalModel?: string;
     browserProvider?: BrowserAutomationProvider;
     agentOverrides?: AgentOverrides;
+    modelRequirements?: ModelRequirements;
+    complexityDowngrades?: ComplexityDowngrades;
+    tiers?: Tiers;
     onSyncSessionCreated?: (event: {
         sessionID: string;
         parentID: string;

package/dist/tools/delegate-task/index.d.ts

@@ -1,4 +1,4 @@
-export { BUILTIN_COMPLEXITY_DOWNGRADES, resolveComplexityModel } from "./complexity-constants";
+export { resolveComplexityModel } from "./complexity-constants";
 export { autoScoreComplexity } from "./complexity-scorer";
 export type { ComplexityInput, ComplexityLevel } from "./complexity-types";
 export * from "./constants";

package/dist/tools/delegate-task/types.d.ts

@@ -1,6 +1,6 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import type { AvailableCategory, AvailableSkill } from "../../agents/dynamic-agent-prompt-builder";
-import type { AgentOverrides, BrowserAutomationProvider, CategoriesConfig } from "../../config/schema";
+import type { AgentOverrides, BrowserAutomationProvider, CategoriesConfig, ComplexityDowngrades, ModelRequirements, Tiers } from "../../config/schema";
 import type { BackgroundManager } from "../../features/background-agent";
 export type OpencodeClient = PluginInput["client"];
 export interface DelegateTaskArgs {
@@ -69,6 +69,9 @@ export interface DelegateTaskToolOptions {
     availableCategories?: AvailableCategory[];
     availableSkills?: AvailableSkill[];
     agentOverrides?: AgentOverrides;
+    modelRequirements?: ModelRequirements;
+    complexityDowngrades?: ComplexityDowngrades;
+    tiers?: Tiers;
     onSyncSessionCreated?: (event: SyncSessionCreatedEvent) => Promise<void>;
 }
 export interface BuildSystemContentInput {

package/dist/tools/index.d.ts

@@ -9,6 +9,11 @@ export { createGrepTools } from "./grep";
 export { createHandoffTools } from "./handoff";
 export { interactive_bash, startBackgroundCheck as startTmuxCheck } from "./interactive-bash";
 export { createPdfExtractFiguresTool } from "./pdf-extract-figures";
+export { createPlanCreateTool } from "./plan/plan-create";
+export { createPlanDeleteTool } from "./plan/plan-delete";
+export { createPlanListTool } from "./plan/plan-list";
+export { createPlanReadTool } from "./plan/plan-read";
+export { createPlanUpdateTool } from "./plan/plan-update";
 export { createSessionManagerTools } from "./session-manager";
 export { sessionExists } from "./session-manager/storage";
 export { createSkillTool } from "./skill";

package/dist/tools/plan/constants.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Plan Tool Constants
+ * Reuses mission-state storage caps with strict scoping for .matrixx/plans/*.md
+ */
+export declare const PLANS_DIR = ".matrixx/plans";
+export declare const MAX_PLAN_FILE_BYTES = 102400;
+export declare const PLAN_FILENAME_KEBAB_REGEX: RegExp;
+export declare const PLAN_BASENAME_KEBAB_REGEX: RegExp;
+export declare const META_TAG_PREFIX = "<!-- plan-persister:";
+export declare const META_TAG_SUFFIX = "-->";

package/dist/tools/plan/index.d.ts

@@ -0,0 +1,6 @@
+export { MAX_PLAN_FILE_BYTES, PLAN_FILENAME_KEBAB_REGEX, PLANS_DIR } from "./constants";
+export { createPlanCreateTool } from "./plan-create";
+export { createPlanDeleteTool } from "./plan-delete";
+export { createPlanListTool } from "./plan-list";
+export { createPlanReadTool } from "./plan-read";
+export { createPlanUpdateTool } from "./plan-update";

package/dist/tools/plan/plan-create.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { PluginContext } from "../../plugin/types";
+export declare function createPlanCreateTool(ctx?: PluginContext): ToolDefinition;

package/dist/tools/plan/plan-delete.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { PluginContext } from "../../plugin/types";
+export declare function createPlanDeleteTool(ctx?: PluginContext): ToolDefinition;

package/dist/tools/plan/plan-list.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { PluginContext } from "../../plugin/types";
+export declare function createPlanListTool(ctx?: PluginContext): ToolDefinition;

package/dist/tools/plan/plan-read.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { PluginContext } from "../../plugin/types";
+export declare function createPlanReadTool(ctx?: PluginContext): ToolDefinition;

package/dist/tools/plan/plan-update.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { PluginContext } from "../../plugin/types";
+export declare function createPlanUpdateTool(ctx?: PluginContext): ToolDefinition;

package/dist/tools/plan/types.d.ts

@@ -0,0 +1,28 @@
+import type { RawHashlineEdit } from "../hashline-edit/normalize-edits";
+export declare function resolveDirectory(contextDirectory: unknown, ctxDirectory: unknown): string;
+export declare function validatePlanFilePath(filePath: string, directory: string): {
+    resolved: string;
+} | {
+    error: string;
+};
+export interface PlanCreateArgs {
+    filePath: string;
+    content: string;
+}
+export interface PlanReadArgs {
+    filePath: string;
+}
+export interface PlanUpdateArgs {
+    filePath: string;
+    edits: RawHashlineEdit[];
+}
+export interface PlanDeleteArgs {
+    filePath: string;
+}
+export interface PlanInfo {
+    fileName: string;
+    filePath: string;
+    mtime: string;
+    mtimeMs: number;
+    size: number;
+}

package/dist/tools/task/constants.d.ts

@@ -1 +1,6 @@
+/**
+ * Task ID format: `T-` followed by dash-separated alphanumeric segments.
+ * Rejects truncated/empty IDs ("T-"), trailing dashes ("T-abc-"), and
+ * double dashes ("T-a--b"). Matches generateTaskId() output (T-{uuid}).
+ */
 export declare const TASK_ID_PATTERN: RegExp;

package/dist/tools/task/types.d.ts

@@ -6,6 +6,8 @@ export declare const TaskStatusSchema: z.ZodEnum<{
     in_progress: "in_progress";
 }>;
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
+/** Task ID must match T-{uuid}-style format (rejects truncated IDs like "T-"). */
+export declare const TaskIdSchema: z.ZodString;
 export declare const TaskObjectSchema: z.ZodObject<{
     id: z.ZodString;
     subject: z.ZodString;