opencode-matrixx 2.6.3 → 2.6.5

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/config-errors.d.ts

@@ -2,6 +2,9 @@ export type ConfigLoadError = {
     path: string;
     error: string;
 };
+export declare class ConfigError extends Error {
+    constructor(message: string);
+}
 export declare function getConfigLoadErrors(): ConfigLoadError[];
 export declare function clearConfigLoadErrors(): void;
 export declare function addConfigLoadError(error: ConfigLoadError): void;

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

@@ -2,9 +2,5 @@ import type { CategoriesConfig, CategoryConfig } from "../config/schema";
 /**
  * Merge default and user categories, filtering out disabled ones.
  * Single source of truth for category merging across the codebase.
- *
- * The built-in `DEFAULT_CATEGORIES` registry is now tier-based. Before
- * 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>;

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/task-system-gating.d.ts

@@ -1,3 +1,13 @@
 import type { MatrixxConfig } from "../config/schema";
+import type { TasksConfig } from "../config/schema/tasks";
 export declare const TASK_SYSTEM_DEFAULT: true;
+export type ResolvedTasksConfig = Required<Pick<TasksConfig, "enabled" | "scope" | "session_scoped">> & Pick<TasksConfig, "storage_path" | "task_list_id" | "stale_after_hours" | "pollTimeoutMs">;
+/**
+ * Merge the canonical `tasks` section with legacy locations.
+ * Explicit `tasks.*` always wins; legacy keys fill the gaps:
+ * `experimental.task_system` / `new_task_system_enabled` → enabled,
+ * `morpheus.tasks.*` → same-named key, `task.pollTimeoutMs` → pollTimeoutMs.
+ * Pure derivation, no mutation — safe to call on every read.
+ */
+export declare function resolveTasksConfig(config: Partial<MatrixxConfig> | undefined | null): ResolvedTasksConfig;
 export declare function isTaskSystemEnabled(config: Partial<MatrixxConfig> | undefined | null): boolean;

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

@@ -1,11 +1,12 @@
-import type { CategoriesConfig, CategoryConfig } from "../../config/schema";
-import type { TierResolverContext } from "../../shared/tier-resolver";
+import type { CategoriesConfig, CategoryConfig, ModelPresetEntry, ModelRequirements } from "../../config/schema";
 interface ResolveCategoryConfigOptions {
     userCategories?: CategoriesConfig;
     inheritedModel?: string;
     systemDefaultModel?: string;
     availableModels?: Set<string>;
-    tierContext?: TierResolverContext;
+    modelRequirements?: ModelRequirements;
+    /** Preset entry resolved at call time (session overlay > config active_preset). */
+    presetEntry?: ModelPresetEntry;
 }
 interface ResolveCategoryConfigResult {
     config: CategoryConfig;
@@ -16,11 +17,6 @@ interface ResolveCategoryConfigResult {
 /**
  * Resolve the configuration for a given category name.
  * Merges default and user configurations, handles model resolution.
- *
- * Tier resolution: both `userConfig.tier` and `defaultConfig.tier` are
- * resolved against the live provider list (`tierContext`). An explicit
- * `userConfig.model` always wins; an explicit `userConfig.tier` wins
- * over the default tier; otherwise the default tier is used.
  */
 export declare function resolveCategoryConfig(categoryName: string, options: ResolveCategoryConfigOptions): ResolveCategoryConfigResult | null;
 export {};

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

@@ -1,24 +1,23 @@
 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;
+};
 /**
  * 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).
  *
  * @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
  * @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): {
     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, ModelPresets, ModelRequirements } from "../../config/schema";
 import type { BackgroundManager } from "../../features/background-agent";
 import type { OpencodeClient } from "./types";
 export interface ExecutorContext {
@@ -10,6 +10,14 @@ export interface ExecutorContext {
     globalModel?: string;
     browserProvider?: BrowserAutomationProvider;
     agentOverrides?: AgentOverrides;
+    modelRequirements?: ModelRequirements;
+    complexityDowngrades?: ComplexityDowngrades;
+    /** Named model presets from plugin config (`model_presets`). */
+    modelPresets?: ModelPresets;
+    /** Active preset name from plugin config (`active_preset`). */
+    activePreset?: string;
+    /** Invoking (parent) session ID — its preset overlay propagates to delegated tasks. */
+    sessionID?: string;
     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/timing.d.ts

@@ -8,4 +8,9 @@ export declare function getTimingConfig(): {
     SESSION_CONTINUATION_STABILITY_MS: number;
 };
 export declare function __resetTimingConfig(): void;
+/**
+ * Set poll timeout from plugin config. Called during plugin initialization.
+ * Accepts a value in milliseconds; falls back to 10 min default.
+ */
+export declare function setPollTimeoutMs(ms: number): void;
 export declare function __setTimingConfig(overrides: Partial<ReturnType<typeof getTimingConfig>>): void;

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, ModelPresets, ModelRequirements } from "../../config/schema";
 import type { BackgroundManager } from "../../features/background-agent";
 export type OpencodeClient = PluginInput["client"];
 export interface DelegateTaskArgs {
@@ -69,6 +69,12 @@ export interface DelegateTaskToolOptions {
     availableCategories?: AvailableCategory[];
     availableSkills?: AvailableSkill[];
     agentOverrides?: AgentOverrides;
+    modelRequirements?: ModelRequirements;
+    complexityDowngrades?: ComplexityDowngrades;
+    /** Named model presets from plugin config (`model_presets`). */
+    modelPresets?: ModelPresets;
+    /** Active preset name from plugin config (`active_preset`). */
+    activePreset?: string;
     onSyncSessionCreated?: (event: SyncSessionCreatedEvent) => Promise<void>;
 }
 export interface BuildSystemContentInput {

package/dist/tools/index.d.ts

@@ -9,6 +9,12 @@ 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 { createPresetTool } from "./preset";
 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/preset/index.d.ts

@@ -0,0 +1 @@
+export { createPresetTool } from "./tools";

package/dist/tools/preset/tools.d.ts

@@ -0,0 +1,7 @@
+import { type ToolDefinition } from "@opencode-ai/plugin/tool";
+import type { MatrixxConfig } from "../../config";
+export interface PresetToolOptions {
+    pluginConfig?: MatrixxConfig;
+    directory?: string;
+}
+export declare function createPresetTool(options?: PresetToolOptions): Record<string, ToolDefinition>;

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

@@ -1 +1,7 @@
+/**
+ * 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;
+export declare const DEDUP_WINDOW_MS: number;

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;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-matrixx",
-  "version": "2.6.3",
+  "version": "2.6.5",
   "description": "The Best AI Agent Harness - Batteries-Included OpenCode Plugin with Multi-Model Orchestration, Parallel Background Agents, and Crafted LSP/AST Tools",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/dist/config/presets.d.ts

@@ -1,4 +0,0 @@
-import type { MatrixxConfig } from "./schema/matrixx-config";
-export declare const PRESET_NAMES: readonly ["minimal", "balanced", "performance", "frontier"];
-export type PresetName = (typeof PRESET_NAMES)[number];
-export declare function expandPreset(preset: PresetName): MatrixxConfig;

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

@@ -1,32 +0,0 @@
-import { type TierResolverContext } from "../shared/tier-resolver";
-import type { MatrixxConfig } from "./schema/matrixx-config";
-interface WithTier {
-    model?: string;
-    tier?: string;
-}
-/**
- * Walk a merged MatrixxConfig and resolve any `tier: "..."` fields to concrete
- * `model: "..."` strings. The result is a new config object with the `tier`
- * fields cleared (so downstream code never re-resolves them).
- *
- * Precedence (per agent/category):
- *   1. Explicit `model` — kept as-is.
- *   2. Explicit `tier` — resolved against the live provider list.
- *   3. `default_tier` (top-level) — applied to any agent/category without
- *      a `model` or `tier` override, then resolved.
- *
- * If a tier cannot be resolved, the entry is left with `tier` set and `model`
- * undefined. The downstream `resolveModelPipeline` will fall through to
- * category defaults and the system default as a last resort.
- */
-export declare function resolveTiersInConfig(config: MatrixxConfig, ctx: TierResolverContext): MatrixxConfig;
-/**
- * Resolve tier fields in a category registry (e.g. `DEFAULT_CATEGORIES`) and
- * return a new object with `tier` cleared and `model` set where the tier
- * resolved. Entries that already have a concrete `model` are passed through.
- * Used at config load time to pre-resolve the built-in defaults so that
- * downstream code (createBuiltinAgents, buildAgent) only ever sees model
- * strings.
- */
-export declare function resolveTiersInCategoryRegistry(registry: Record<string, WithTier | undefined>, ctx: TierResolverContext): Record<string, WithTier>;
-export {};

package/dist/features/builtin-commands/templates/profile.d.ts

@@ -1 +0,0 @@
-export declare const PROFILE_TEMPLATE = "# /profile Command\n\n## Usage\n\n```\n/profile                  \u2192 List available profiles and show current\n/profile list            \u2192 List available profiles\n/profile show            \u2192 Show currently active profile\n/profile set <name>      \u2192 Change profile (edits project config, instructs to start new session)\n/profile set <name> --global  \u2192 Change profile globally (~/.config/opencode/matrixx.jsonc)\n/profile set <name> --project \u2192 Change profile project-scoped (.opencode/matrixx.jsonc)\n```\n\n## Available Profiles\n\n| Profile | Description | Key Characteristic |\n|---------|-------------|-------------------|\n| free | Zero-cost, uses only free/open models | Kimi K2.5 Free, Grok (free), GLM |\n| budget | Cost-optimized for tight budgets | Sonnet/Haiku mix, no Opus |\n| economy | Balanced cost and capability | Primarily Sonnet/Haiku |\n| balanced | Default \u2014 best overall value | Opus/Sonnet/Haiku tiered |\n| performance | Maximum quality, no compromises | Opus for all heavy agents |\n| go | Premium OpenCode Go subscription | Kimi K2.6, DeepSeek V4 Pro, GLM 5.1 |\n\n## How It Works\n\nEach profile sets the `model` field on every agent and category in Matrixx's configuration. When you switch profiles, the agent models are swapped accordingly.\n\nThe profile name is stored in your `matrixx.json` or `matrixx.jsonc` config file. On the next session, Matrixx reads it and applies the profile's model mapping, merging it with any explicit per-agent overrides you may have set.\n\n## Task: Change the Profile\n\nFollow these steps:\n\n### Step 1: Know the Current Config Location\n\nMatrixx reads config from two locations (user config wins over project config):\n- **Project**: `.opencode/matrixx.json` or `.opencode/matrixx.jsonc`\n- **Global**: `~/.config/opencode/matrixx.json` or `~/.config/opencode/matrixx.jsonc`\n\n### Step 2: Determine Which Config File to Edit\n\n- `--global` \u2192 Edit `~/.config/opencode/matrixx.jsonc`\n- `--project` (default) \u2192 Edit `.opencode/matrixx.jsonc`\n- If no flag and neither file exists, use `--project`\n\n### Step 3: Read the Target Config File\n\nUse the `read` tool to read the config file.\n\n### Step 4: Validate the Requested Profile\n\nIf the user asked for `/profile set <name>`, verify `<name>` is in the table above. If not, report the valid profiles and stop.\n\n### Step 5: Update the `profile` Key\n\nSet `\"profile\": \"<name>\"` in the config JSON. If the `profile` key already exists, update it. If it doesn't exist, add it at the top level. Do NOT modify any other keys.\n\n### Step 6: Write the Config File Back\n\nUse the `write` tool (or `edit` tool for minimal changes) to save the updated config.\n\n### Step 7: Confirm and Advise\n\nTell the user:\n1. The profile has been changed to `<name>`\n2. For the change to take effect, they MUST start a new session (`/new` or restart OpenCode)\n3. If they want session-level switching without restarting, suggest using the profile with `--global` or `--project` as appropriate\n\n### Step 8: If `/profile` Was Called Without Arguments\n\nJust list the available profiles and show the current configuration's profile value.";

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

@@ -1,31 +0,0 @@
-/**
- * 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.
- */
-export type TierName = "free" | "fast" | "standard" | "premium" | "frontier";
-export interface TierSpec {
-    name: TierName;
-    /** 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: {
-        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;

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

@@ -1,26 +0,0 @@
-import { parseTierReference, type TierName } from "./model-tiers";
-export interface TierResolverContext {
-    availableModels: Set<string>;
-    connectedProviders: string[] | null;
-}
-export type TierProvenance = "tier-resolved" | "tier-static-fallback";
-export interface TierResolutionResult {
-    model: string;
-    provenance: TierProvenance;
-    tier: TierName;
-}
-/**
- * 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).
- *   3. Recurse into `fallbackTier` if defined.
- *
- * Returns null when no match is possible (no live models, no static fallback
- * available, no fallback tier).
- */
-export declare function resolveTier(tier: TierName, ctx: TierResolverContext): TierResolutionResult | null;
-export { parseTierReference };