opencode-matrixx 2.2.0 → 2.3.0

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

@@ -1,6 +1,6 @@
 import type { HookName, MatrixxConfig } from "../../config";
 import type { BackgroundManager } from "../../features/background-agent";
-import { createArchitectHook, createBackgroundNotificationHook, createCompactionContextInjector, createCompactionTodoPreserverHook, createStopContinuationGuardHook, createTodoContinuationEnforcer } from "../../hooks";
+import { createArchitectHook, createBackgroundNotificationHook, createCompactionContextInjector, createCompactionTodoPreserverHook, createPlanPersister, createStopContinuationGuardHook, createTodoContinuationEnforcer } from "../../hooks";
 import type { PluginContext } from "../types";
 import { createUnstableAgentBabysitter } from "../unstable-agent-babysitter";
 export type ContinuationHooks = {
@@ -11,6 +11,7 @@ export type ContinuationHooks = {
     unstableAgentBabysitter: ReturnType<typeof createUnstableAgentBabysitter> | null;
     backgroundNotificationHook: ReturnType<typeof createBackgroundNotificationHook> | null;
     architectHook: ReturnType<typeof createArchitectHook> | null;
+    planPersister: ReturnType<typeof createPlanPersister> | null;
 };
 type SessionRecovery = {
     setOnAbortCallback: (callback: (sessionID: string) => void) => void;

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

@@ -8,6 +8,7 @@ export declare function createCoreHooks(args: {
 }): {
     keywordDetector: ReturnType<typeof import("../../hooks").createKeywordDetectorHook> | null;
     contextInjectorMessagesTransform: ReturnType<typeof import("../../features/context-injector").createContextInjectorMessagesTransformHook>;
+    envContextInjector: ReturnType<typeof import("../../hooks").createEnvContextInjectorHook> | null;
     thinkingBlockValidator: ReturnType<typeof import("../../hooks").createThinkingBlockValidatorHook> | null;
     toolPairValidator: ReturnType<typeof import("../../hooks").createToolPairValidatorHook> | null;
     designIntentPreserver: ReturnType<typeof import("../../hooks").createDesignIntentPreserverHook> | null;

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

@@ -1,10 +1,11 @@
 import type { MatrixxConfig } from "../../config";
 import { createContextInjectorMessagesTransformHook } from "../../features/context-injector";
-import { createDesignIntentPreserverHook, createKeywordDetectorHook, createThinkingBlockValidatorHook, createToolPairValidatorHook } from "../../hooks";
+import { createDesignIntentPreserverHook, createEnvContextInjectorHook, createKeywordDetectorHook, createThinkingBlockValidatorHook, createToolPairValidatorHook } from "../../hooks";
 import type { PluginContext } from "../types";
 export type TransformHooks = {
     keywordDetector: ReturnType<typeof createKeywordDetectorHook> | null;
     contextInjectorMessagesTransform: ReturnType<typeof createContextInjectorMessagesTransformHook>;
+    envContextInjector: ReturnType<typeof createEnvContextInjectorHook> | null;
     thinkingBlockValidator: ReturnType<typeof createThinkingBlockValidatorHook> | null;
     toolPairValidator: ReturnType<typeof createToolPairValidatorHook> | null;
     designIntentPreserver: ReturnType<typeof createDesignIntentPreserverHook> | null;

package/dist/plugin-config.d.ts

@@ -24,5 +24,5 @@ export declare function getDisabledSets(config: MatrixxConfig): DisabledSets;
  */
 export declare function _resetDisabledSetsCacheForTesting(): void;
 export declare function mergeConfigs(base: MatrixxConfig, override: MatrixxConfig): MatrixxConfig;
-export declare function loadPluginConfig(directory: string, ctx: unknown): MatrixxConfig;
+export declare function loadPluginConfig(directory: string, ctx: unknown): Promise<MatrixxConfig>;
 export {};

package/dist/plugin-handlers/agent-config-handler.d.ts

@@ -1,5 +1,7 @@
 import type { MatrixxConfig } from "../config";
 import type { PluginComponents } from "./plugin-components-loader";
+export declare function setAvailableToolNames(names: string[]): void;
+export declare function getAvailableToolNames(): string[];
 export declare function applyAgentConfig(params: {
     config: Record<string, unknown>;
     pluginConfig: MatrixxConfig;

package/dist/plugin-handlers/plugin-components-loader.d.ts

@@ -17,6 +17,6 @@ export type PluginComponents = {
         error: string;
     }>;
 };
-export declare function loadPluginComponents(params: {
+export declare function loadPluginComponents(_params: {
     pluginConfig: MatrixxConfig;
 }): Promise<PluginComponents>;

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

@@ -19,5 +19,6 @@ export declare function buildOracleAgentConfig(params: {
     pluginOracleOverride: OracleOverride | undefined;
     userCategories: Record<string, CategoryConfig> | undefined;
     currentModel: string | undefined;
+    globalOverrideModel?: string;
 }): Promise<Record<string, unknown>>;
 export {};

package/dist/shared/index.d.ts

@@ -1,7 +1,7 @@
 export * from "./agent-tool-restrictions";
 export * from "./agent-variant";
 export * from "./binary-downloader";
-export * from "./claude-config-dir";
+export * from "./code-patterns";
 export * from "./code-patterns";
 export * from "./command-executor";
 export * from "./config-errors";

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

@@ -2,5 +2,9 @@ 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-resolution-types.d.ts

@@ -1,6 +1,9 @@
 import type { FallbackEntry } from "./model-requirements";
 export type ModelResolutionRequest = {
     intent?: {
+        /** Global override for all agents and categories — set via the global_model config.
+         * Highest priority; checked before everything else. */
+        globalOverrideModel?: string;
         uiSelectedModel?: string;
         userModel?: string;
         categoryDefaultModel?: string;

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

@@ -0,0 +1,31 @@
+/**
+ * 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

@@ -0,0 +1,26 @@
+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 };

package/dist/tools/bdd-create-contract/constants.d.ts

@@ -0,0 +1 @@
+export declare const BDD_CREATE_CONTRACT_TOOL_NAME = "bdd_create_contract";

package/dist/tools/bdd-create-contract/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export { createBddCreateContractTool } from "./tools";
+export * from "./types";

package/dist/tools/bdd-create-contract/tools.d.ts

@@ -0,0 +1,3 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/** Create a tool that produces a Contract JSON from a parsed Gherkin AST. */
+export declare function createBddCreateContractTool(): ToolDefinition;

package/dist/tools/bdd-create-contract/types.d.ts

@@ -0,0 +1,12 @@
+export interface BddCreateContractArgs {
+    parsedAst: string;
+    sourceFile: string;
+    sourceText: string;
+    force?: boolean;
+    outputPath?: string;
+}
+export interface BddCreateContractResult {
+    success: boolean;
+    outputPath?: string;
+    error?: string;
+}

package/dist/tools/bdd-parse-gherkin/constants.d.ts

@@ -0,0 +1 @@
+export declare const BDD_PARSE_GHERKIN_TOOL_NAME = "bdd_parse_gherkin";

package/dist/tools/bdd-parse-gherkin/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export { createBddParseGherkinTool } from "./tools";
+export * from "./types";

package/dist/tools/bdd-parse-gherkin/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * Create a tool that parses Gherkin .feature files into structured JSON AST.
+ */
+export declare function createBddParseGherkinTool(): ToolDefinition;

package/dist/tools/bdd-parse-gherkin/types.d.ts

@@ -0,0 +1,9 @@
+export interface BddParseGherkinArgs {
+    filePath: string;
+    includeSourceMap?: boolean;
+}
+export interface BddParseGherkinResult {
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: string;
+}

package/dist/tools/bdd-pipeline/analysis-report-sections.d.ts

@@ -0,0 +1,10 @@
+import type { Contract } from "../../features/bdd/schema";
+import type { BddPipelineResult, BddPipelineStageName, BddPipelineStageResult } from "./types";
+export declare function stageStatusBadge(stage: BddPipelineStageResult): string;
+export declare function buildAnnotationsSection(contract: Contract): string;
+export declare function buildFrontendMappingSection(contract: Contract, stage: BddPipelineStageResult): string;
+export declare function buildBackendMappingSection(contract: Contract, stage: BddPipelineStageResult): string;
+export declare function buildTestCoverageSection(result: BddPipelineResult): string;
+export declare function buildAssumptionsSection(contract: Contract): string;
+export declare function buildAmbiguitiesSection(result: BddPipelineResult): string;
+export declare function buildFilesGeneratedSection(result: BddPipelineResult, featureDir: string, order: readonly BddPipelineStageName[]): string;

package/dist/tools/bdd-pipeline/analysis-report.d.ts

@@ -0,0 +1,9 @@
+import type { Contract } from "../../features/bdd/schema";
+import type { BddPipelineResult } from "./types";
+export { stageStatusBadge } from "./analysis-report-sections";
+export interface AnalysisReportInput {
+    result: BddPipelineResult;
+    contract: Contract;
+    featureDir: string;
+}
+export declare function buildAnalysisReport(input: AnalysisReportInput): string;

package/dist/tools/bdd-pipeline/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const BDD_PIPELINE_TOOL_NAME = "bdd_pipeline_run";
+export declare const BDD_PIPELINE_DESCRIPTION: string;
+export declare const PIPELINE_REQUIRED_OUTPUTS: readonly ["ANALYSIS.md", "cucumber.cjs", "run-tests.sh"];
+export declare const PIPELINE_STAGES: readonly ["tests", "frontend", "backend"];

package/dist/tools/bdd-pipeline/feature-resolver.d.ts

@@ -0,0 +1,5 @@
+export declare function isFeaturePath(input: string): boolean;
+export declare function looksLikeGlob(input: string): boolean;
+export declare function listFeatureFilesInDir(input: string): string[];
+export declare function expandGlob(input: string): string[];
+export declare function resolveFeaturePaths(inputs: string[]): string[];

package/dist/tools/bdd-pipeline/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./constants";
+export { createBddPipelineTool } from "./tools";
+export * from "./types";

package/dist/tools/bdd-pipeline/pipeline-runner.d.ts

@@ -0,0 +1,6 @@
+import type { BddPipelineContext, BddPipelineDeps, BddPipelineResult } from "./types";
+export declare function runBddPipeline(args: {
+    featurePaths: string[];
+    outDir: string;
+    force?: boolean;
+}, ctxIn: Omit<BddPipelineContext, "outDir" | "force" | "featureName">, deps: BddPipelineDeps): Promise<BddPipelineResult>;

package/dist/tools/bdd-pipeline/subagent-runner.d.ts

@@ -0,0 +1,14 @@
+import type { BackgroundManager } from "../../features/background-agent/manager";
+import type { BddPipelineStageName, BddPipelineStageResult } from "./types";
+export interface SpawnSubagentOptions {
+    manager: BackgroundManager;
+    stage: BddPipelineStageName;
+    prompt: string;
+    contractPath: string;
+    parentSessionID: string;
+    parentMessageID: string;
+    parentAgent?: string;
+    abort?: AbortSignal;
+    outDir: string;
+}
+export declare function spawnStageSubagent(opts: SpawnSubagentOptions): Promise<BddPipelineStageResult>;

package/dist/tools/bdd-pipeline/tools.d.ts

@@ -0,0 +1,5 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { BackgroundManager } from "../../features/background-agent/manager";
+export declare function createBddPipelineTool(opts: {
+    manager: BackgroundManager;
+}): ToolDefinition;

package/dist/tools/bdd-pipeline/types.d.ts

@@ -0,0 +1,74 @@
+import type { Contract } from "../../features/bdd/schema";
+export interface BddPipelineArgs {
+    featurePaths: string[];
+    outDir: string;
+    force?: boolean;
+}
+export type BddPipelineStageName = "tests" | "frontend" | "backend";
+export type BddPipelineStageStatus = "completed" | "failed" | "timeout";
+export interface BddPipelineStageResult {
+    stage: BddPipelineStageName;
+    status: BddPipelineStageStatus;
+    filesCreated: string[];
+    testsRun: number;
+    testsPassed: number;
+    testsFailed: number;
+    testOutput: string;
+    error?: string;
+}
+export type BddPipelineStatus = "PASS" | "FAIL";
+export interface BddPipelineResult {
+    feature: string;
+    sourceFile: string;
+    contractPath: string;
+    status: BddPipelineStatus;
+    stages: Record<BddPipelineStageName, BddPipelineStageResult>;
+    missingOutputs: string[];
+    ambiguities: string[];
+    startedAt: string;
+    finishedAt: string;
+    error?: string;
+}
+export interface BddPipelineContext {
+    parentSessionID: string;
+    parentMessageID: string;
+    parentAgent?: string;
+    abort?: AbortSignal;
+    outDir: string;
+    force: boolean;
+    featureName: string;
+}
+export interface ParseFeatureResult {
+    success: boolean;
+    data?: unknown;
+    error?: string;
+}
+export interface CreateContractResult {
+    success: boolean;
+    outputPath?: string;
+    error?: string;
+}
+export interface EnrichContractResult {
+    success: boolean;
+    contract?: Contract;
+    error?: string;
+}
+export interface GateResult {
+    ok: boolean;
+    missing: string[];
+}
+export interface BddPipelineDeps {
+    parseFeature: (path: string) => Promise<ParseFeatureResult>;
+    createContract: (args: {
+        parsedAst: string;
+        sourceFile: string;
+        sourceText: string;
+        force?: boolean;
+        outputPath?: string;
+    }) => Promise<CreateContractResult>;
+    enrichContract: (contractPath: string) => Promise<EnrichContractResult>;
+    spawnSubagent: (stage: BddPipelineStageName, prompt: string, contract: Contract, ctx: BddPipelineContext) => Promise<BddPipelineStageResult>;
+    gateRequiredOutputs: (featureDir: string) => Promise<GateResult>;
+    writeAnalysis: (featureDir: string, report: BddPipelineResult) => Promise<void>;
+    readFeatureSource: (path: string) => Promise<string>;
+}

package/dist/tools/bdd-validate-contract/index.d.ts

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

package/dist/tools/bdd-validate-contract/tools.d.ts

@@ -0,0 +1,21 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+/**
+ * The bdd_validate_contract tool reads a contract JSON from disk and
+ * validates it against the strict ContractSchema. It is the single source
+ * of truth for what a valid contract looks like.
+ *
+ * Use this tool:
+ *   - After the bdd-contract agent edits a contract file in any way
+ *     (read-back-then-validate is the only way to be sure the on-disk
+ *     bytes conform to the schema).
+ *   - In a CI gate that re-validates every contract in the repo.
+ *   - Whenever the bdd-pipeline runs as a pre-flight check before
+ *     bdd-frontend / bdd-backend / bdd-tests phase starts.
+ *
+ * Returns:
+ *   { success: true, contract }            -- when validation passes
+ *   { success: false, errors: <ZodFlatten> } -- when validation fails
+ *   { success: false, error: <string> }    -- when the file is missing,
+ *                                             unreadable, or not JSON
+ */
+export declare function createBddValidateContractTool(): ToolDefinition;

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

@@ -1,9 +1,11 @@
 import type { CategoriesConfig, CategoryConfig } from "../../config/schema";
+import type { TierResolverContext } from "../../shared/tier-resolver";
 interface ResolveCategoryConfigOptions {
     userCategories?: CategoriesConfig;
     inheritedModel?: string;
     systemDefaultModel?: string;
     availableModels?: Set<string>;
+    tierContext?: TierResolverContext;
 }
 interface ResolveCategoryConfigResult {
     config: CategoryConfig;
@@ -14,6 +16,11 @@ 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/category-resolver.d.ts

@@ -13,6 +13,12 @@ export interface CategoryResolutionResult {
     modelInfo: ModelFallbackInfo | undefined;
     actualModel: string | undefined;
     isUnstableAgent: boolean;
+    /** The complexity level that was applied (auto-scored or caller-provided) */
+    complexityApplied?: import("./complexity-types").ComplexityLevel;
+    /** If true, model was downgraded due to low complexity */
+    complexityDowngraded?: boolean;
+    /** Human-readable note about complexity-based model selection */
+    _complexityNote?: string;
     error?: string;
 }
 export declare function resolveCategoryExecution(args: DelegateTaskArgs, executorCtx: ExecutorContext, inheritedModel: string | undefined, systemDefaultModel: string | undefined): Promise<CategoryResolutionResult>;

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

@@ -0,0 +1,24 @@
+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>>>;
+/**
+ * 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
+ *
+ * @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
+ * @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>): {
+    model: string;
+    downgraded: boolean;
+};

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

@@ -0,0 +1,31 @@
+import type { ComplexityLevel } from "./complexity-types";
+export interface ComplexityScorerInput {
+    /** Short task description (3-5 words) */
+    description?: string;
+    /** Full task prompt content */
+    prompt?: string;
+    /** Skill names requested */
+    loadSkills?: string[];
+    /** Task category name */
+    category?: string;
+}
+/**
+ * Category baseline complexity levels.
+ * Used when no keyword signal is present to provide a sensible default.
+ */
+export declare const CATEGORY_BASELINE: Partial<Record<string, ComplexityLevel>>;
+/**
+ * Auto-score complexity from task context.
+ *
+ * Heuristic:
+ * 1. Start with category baseline (defaults to 3 for unknown categories)
+ * 2. Keyword detection in description/prompt can override:
+ *    - Trivial keywords → level 1 (unless complex keywords also present)
+ *    - Simple keywords → level 2 (unless complex keywords also present)
+ *    - Architectural keywords → level 5
+ *    - Complex keywords → level 4
+ * 3. Skills signal: many skills bump minimum score
+ *
+ * Returns a ComplexityLevel (1-5).
+ */
+export declare function autoScoreComplexity(input: ComplexityScorerInput): ComplexityLevel;

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

@@ -0,0 +1,10 @@
+/**
+ * Complexity level for per-task model routing.
+ * 1 = trivial, 2 = simple, 3 = standard, 4 = complex, 5 = architectural
+ */
+export type ComplexityLevel = 1 | 2 | 3 | 4 | 5;
+export declare const COMPLEXITY_LEVELS: readonly [1, 2, 3, 4, 5];
+export type ComplexityInput = ComplexityLevel | "auto";
+export declare const COMPLEXITY_DESCRIPTIONS: Record<ComplexityLevel, string>;
+/** Returns true if this complexity level is eligible for model downgrade. */
+export declare function isDowngradable(level: ComplexityLevel): boolean;

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

@@ -7,6 +7,7 @@ export interface ExecutorContext {
     directory: string;
     userCategories?: CategoriesConfig;
     mouseModel?: string;
+    globalModel?: string;
     browserProvider?: BrowserAutomationProvider;
     agentOverrides?: AgentOverrides;
     onSyncSessionCreated?: (event: {

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

@@ -1,3 +1,6 @@
+export { BUILTIN_COMPLEXITY_DOWNGRADES, resolveComplexityModel } from "./complexity-constants";
+export { autoScoreComplexity } from "./complexity-scorer";
+export type { ComplexityInput, ComplexityLevel } from "./complexity-types";
 export * from "./constants";
 export type { BuildSystemContentInput, DelegateTaskToolOptions, SyncSessionCreatedEvent } from "./tools";
 export { buildSystemContent, createDelegateTask, resolveCategoryConfig } from "./tools";

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

@@ -16,6 +16,12 @@ export interface DelegateTaskArgs {
         task_id: string;
         task_dir?: string;
     };
+    /**
+     * Task complexity level (1-5) or "auto" for automatic scoring.
+     * When < 3, model may be downgraded to a cheaper tier.
+     * Default: "auto" (scored from prompt/description heuristics)
+     */
+    complexity?: import("./complexity-types").ComplexityLevel | "auto";
 }
 export interface ToolContextWithMetadata {
     sessionID: string;
@@ -55,6 +61,8 @@ export interface DelegateTaskToolOptions {
      */
     availableModelsOverride?: Set<string>;
     userCategories?: CategoriesConfig;
+    /** Global provider/model override for ALL tasks (overrides all category models) */
+    globalModel?: string;
     mouseModel?: string;
     browserProvider?: BrowserAutomationProvider;
     disabledSkills?: Set<string>;

package/dist/tools/index.d.ts

@@ -1,5 +1,9 @@
 import { lspManager } from "./lsp";
 export { createAstGrepTools } from "./ast-grep";
+export { createBddCreateContractTool } from "./bdd-create-contract";
+export { createBddParseGherkinTool } from "./bdd-parse-gherkin";
+export { createBddPipelineTool } from "./bdd-pipeline";
+export { createBddValidateContractTool } from "./bdd-validate-contract";
 export { createGlobTools } from "./glob";
 export { createGrepTools } from "./grep";
 export { createHandoffTools } from "./handoff";

package/dist/tools/task/todo-sync.d.ts

@@ -1,5 +1,5 @@
 import type { PluginInput } from "@opencode-ai/plugin";
-import type { Task } from "../../features/claude-tasks/types.ts";
+import type { Task } from "../../features/task-storage/types.ts";
 export interface TodoInfo {
     id?: string;
     content: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-matrixx",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "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",
@@ -49,16 +49,17 @@
   "license": "SUL-1.0",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/klpanagi/matrixx.git"
+    "url": "git+https://github.com/klpanagi/opencode-matrixx.git"
   },
   "bugs": {
-    "url": "https://github.com/klpanagi/matrixx/issues"
+    "url": "https://github.com/klpanagi/opencode-matrixx/issues"
   },
-  "homepage": "https://github.com/klpanagi/matrixx#readme",
+  "homepage": "https://github.com/klpanagi/opencode-matrixx#readme",
   "dependencies": {
     "@ast-grep/cli": "^0.40.0",
     "@ast-grep/napi": "^0.40.0",
     "@code-yeongyu/comment-checker": "^0.6.1",
+    "@cucumber/gherkin": "^34.0.0",
     "@modelcontextprotocol/sdk": "^1.25.1",
     "@opencode-ai/plugin": "1.3.15",
     "@opencode-ai/sdk": "1.3.15",
@@ -70,9 +71,23 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.5.0",
+    "@cucumber/cucumber": "^13.0.0",
+    "@playwright/test": "^1.61.1",
+    "@testing-library/jest-dom": "^6.6.3",
+    "@testing-library/react": "^16.3.0",
+    "@testing-library/user-event": "^14.6.1",
+    "@types/chai": "^5.2.3",
     "@types/js-yaml": "^4.0.9",
     "@types/picomatch": "^3.0.2",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
     "bun-types": "1.3.6",
+    "chai": "^6.2.2",
+    "happy-dom": "^15.11.7",
+    "jsdom": "^29.1.1",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsx": "^4.23.0",
     "typescript": "^5.7.3"
   },
   "trustedDependencies": [

package/dist/agents/builtin-agents/environment-context.d.ts

@@ -1,2 +0,0 @@
-import type { AgentConfig } from "@opencode-ai/sdk";
-export declare function applyEnvironmentContext(config: AgentConfig, directory?: string): AgentConfig;

package/dist/config/profiles.d.ts

@@ -1,4 +0,0 @@
-import type { MatrixxConfig } from "./schema/matrixx-config";
-export declare const PROFILE_NAMES: readonly ["free", "budget", "economy", "balanced", "performance", "go", "xiaomi-ultimate", "go-ultimate", "go-trio", "go-duo"];
-export type ProfileName = (typeof PROFILE_NAMES)[number];
-export declare function expandProfile(profile: ProfileName): Partial<MatrixxConfig>;

package/dist/config/schema/claude-code.d.ts

@@ -1,10 +0,0 @@
-import { z } from "zod";
-export declare const ClaudeCodeConfigSchema: z.ZodObject<{
-    mcp: z.ZodOptional<z.ZodBoolean>;
-    commands: z.ZodOptional<z.ZodBoolean>;
-    skills: z.ZodOptional<z.ZodBoolean>;
-    agents: z.ZodOptional<z.ZodBoolean>;
-    plugins: z.ZodOptional<z.ZodBoolean>;
-    plugins_override: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodBoolean>>;
-}, z.core.$strip>;
-export type ClaudeCodeConfig = z.infer<typeof ClaudeCodeConfigSchema>;