opencode-matrixx 2.1.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";
@@ -45,6 +45,7 @@ export * from "./shell-env";
 export * from "./system-directive";
 export * from "./tmux";
 export * from "./token-cache";
+export * from "./tool-guards";
 export * from "./transcript-path";
 export * from "./truncate-description";
 export * from "./zip-extractor";

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-pipeline.d.ts

@@ -1,25 +1,2 @@
-import type { FallbackEntry } from "./model-requirements";
-export type ModelResolutionRequest = {
-    intent?: {
-        uiSelectedModel?: string;
-        userModel?: string;
-        categoryDefaultModel?: string;
-    };
-    constraints: {
-        availableModels: Set<string>;
-        connectedProviders?: string[] | null;
-    };
-    policy?: {
-        fallbackChain?: FallbackEntry[];
-        systemDefaultModel?: string;
-    };
-};
-export type ModelResolutionProvenance = "override" | "category-default" | "provider-fallback" | "system-default";
-export type ModelResolutionResult = {
-    model: string;
-    provenance: ModelResolutionProvenance;
-    variant?: string;
-    attempted?: string[];
-    reason?: string;
-};
+import type { ModelResolutionRequest, ModelResolutionResult } from "./model-resolution-types";
 export declare function resolveModelPipeline(request: ModelResolutionRequest): ModelResolutionResult | undefined;

package/dist/shared/model-resolution-types.d.ts

@@ -1,12 +1,16 @@
 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;
     };
     constraints: {
         availableModels: Set<string>;
+        connectedProviders?: string[];
     };
     policy?: {
         fallbackChain?: FallbackEntry[];

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

@@ -1,13 +1,15 @@
 import type { FallbackEntry } from "./model-requirements";
+import type { ModelResolutionProvenance } from "./model-resolution-types";
 export type ModelResolutionInput = {
     userModel?: string;
     inheritedModel?: string;
     systemDefault?: string;
 };
-export type ModelSource = "override" | "category-default" | "provider-fallback" | "system-default";
+/** @deprecated Use ModelResolutionProvenance from model-resolution-types.ts */
+export type ModelSource = ModelResolutionProvenance;
 export type ModelResolutionResult = {
     model: string;
-    source: ModelSource;
+    source: ModelResolutionProvenance;
     variant?: string;
 };
 export type ExtendedModelResolutionInput = {

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

@@ -1,8 +1,7 @@
-import type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths } from "./opencode-config-dir-types";
+import type { OpenCodeConfigDirOptions, OpenCodeConfigPaths } from "./opencode-config-dir-types";
 export type { OpenCodeBinaryType, OpenCodeConfigDirOptions, OpenCodeConfigPaths, } from "./opencode-config-dir-types";
 export declare const TAURI_APP_IDENTIFIER = "ai.opencode.desktop";
 export declare const TAURI_APP_IDENTIFIER_DEV = "ai.opencode.desktop.dev";
 export declare function isDevBuild(version: string | null | undefined): boolean;
 export declare function getOpenCodeConfigDir(options: OpenCodeConfigDirOptions): string;
 export declare function getOpenCodeConfigPaths(options: OpenCodeConfigDirOptions): OpenCodeConfigPaths;
-export declare function detectExistingConfigDir(binary: OpenCodeBinaryType, version?: string | null): string | null;

package/dist/shared/session-directory-resolver.d.ts

@@ -1,7 +1 @@
 export declare function isWindowsAppDataDirectory(directory: string): boolean;
-export declare function resolveSessionDirectory(options: {
-    parentDirectory: string | null | undefined;
-    fallbackDirectory: string;
-    platform?: NodeJS.Platform;
-    currentWorkingDirectory?: string;
-}): string;

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/shared/tool-guards.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Shared tool name guard functions.
+ * Used by multiple hooks to check tool types (read/write).
+ */
+/**
+ * Check if a tool name represents a read operation.
+ * @param toolName - The tool name to check (case-insensitive)
+ * @returns true if the tool is a read tool
+ */
+export declare function isReadTool(toolName: string): boolean;
+/**
+ * Check if a tool name represents a write operation.
+ * @param toolName - The tool name to check (case-insensitive)
+ * @returns true if the tool is a write tool
+ */
+export declare function isWriteTool(toolName: string): boolean;

package/dist/tools/assembly/assembly-executor.d.ts

@@ -0,0 +1,17 @@
+import type { AssemblyConfig } from "../../config/schema/assembly";
+import type { BackgroundManager } from "../../features/background-agent/manager";
+import type { AssemblyArgs, SynthesisResult, VoterResult } from "./types";
+export interface AssemblyExecutorInput {
+    manager: BackgroundManager;
+    args: AssemblyArgs;
+    config: AssemblyConfig | undefined;
+    sessionID: string;
+    messageID: string;
+}
+export interface AssemblyOutput {
+    question: string;
+    voters: VoterResult[];
+    rounds: SynthesisResult[];
+    finalConsensus: string;
+}
+export declare function executeAssembly(input: AssemblyExecutorInput): Promise<AssemblyOutput>;

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

@@ -0,0 +1,6 @@
+import type { ProviderModel } from "./types";
+export declare const DEFAULT_VOTERS = 3;
+export declare const DEFAULT_ROUNDS = 2;
+export declare const VOTER_TIMEOUT_MS = 120000;
+export declare const POLL_INTERVAL_MS = 1000;
+export declare const DEFAULT_PROVIDERS: ProviderModel[];

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

@@ -0,0 +1,2 @@
+export type { AssemblyToolOptions } from "./tools";
+export { createAssemblyTool } from "./tools";

package/dist/tools/assembly/provider-selector.d.ts

@@ -0,0 +1,3 @@
+import type { AssemblyConfig } from "../../config/schema/assembly";
+import type { ProviderModel } from "./types";
+export declare function selectProviders(count: number, modelsOverride: string[] | undefined, config: AssemblyConfig | undefined): ProviderModel[];

package/dist/tools/assembly/synthesizer.d.ts

@@ -0,0 +1,3 @@
+import type { BackgroundManager } from "../../features/background-agent/manager";
+import type { SynthesisResult, VoterResult } from "./types";
+export declare function synthesizeResults(manager: BackgroundManager, question: string, voterResults: VoterResult[], round: number, parentSessionID: string, parentMessageID: string): Promise<SynthesisResult>;

package/dist/tools/assembly/tool-description.d.ts

@@ -0,0 +1,2 @@
+/** Assembly tool description for LLM consumption */
+export declare const TOOL_DESCRIPTION = "\nSpawns multiple AI agents (voters) with different model providers to independently analyze a question or decision, then synthesizes their reasoning into a unified consensus.\n\n## When to use\n- Making critical decisions that benefit from multiple perspectives\n- Evaluating complex tradeoffs where bias reduction matters\n- Validating architectural choices through multi-model reasoning\n- When you need confidence scoring on analysis\n\n## How it works\n1. **Voter selection**: Auto-selects N models from configured providers (or use your override)\n2. **Independent voting**: Each voter independently analyzes the question\n3. **Synthesis**: All voter outputs are fed to a synthesis round that identifies agreement, disagreement, and confidence\n4. **Multi-round**: Optionally repeat synthesis for deeper convergence\n\n## Output format\nReturns a structured consensus with:\n- Unified answer/conclusion\n- Confidence level (high/medium/low)\n- Key disagreements between voters\n- Per-voter reasoning traces\n";

package/dist/tools/assembly/tools.d.ts

@@ -0,0 +1,10 @@
+import { type ToolDefinition } from "@opencode-ai/plugin";
+import type { AssemblyConfig } from "../../config/schema/assembly";
+import type { BackgroundManager } from "../../features/background-agent/manager";
+export interface AssemblyToolOptions {
+    manager: BackgroundManager;
+    pluginConfig?: {
+        assembly?: AssemblyConfig;
+    };
+}
+export declare function createAssemblyTool(options: AssemblyToolOptions): ToolDefinition;

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

@@ -0,0 +1,25 @@
+import { z } from "zod";
+export declare const AssemblyArgsSchema: z.ZodObject<{
+    question: z.ZodString;
+    voters: z.ZodOptional<z.ZodNumber>;
+    rounds: z.ZodOptional<z.ZodNumber>;
+    models: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+export type AssemblyArgs = z.infer<typeof AssemblyArgsSchema>;
+export interface VoterResult {
+    voterIndex: number;
+    modelLabel: string;
+    reasoning: string;
+    status: "completed" | "error" | "timeout";
+    error?: string;
+}
+export interface SynthesisResult {
+    round: number;
+    consensus: string;
+    confidence: "high" | "medium" | "low";
+    disagreements: string[];
+}
+export interface ProviderModel {
+    providerID: string;
+    modelID: string;
+}

package/dist/tools/assembly/voter-spawner.d.ts

@@ -0,0 +1,3 @@
+import type { BackgroundManager } from "../../features/background-agent/manager";
+import type { ProviderModel, VoterResult } from "./types";
+export declare function spawnVoters(manager: BackgroundManager, question: string, providers: ProviderModel[], parentSessionID: string, parentMessageID: string): Promise<VoterResult[]>;

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/{features/run-continuation-state → tools/bdd-pipeline}/index.d.ts

@@ -1,3 +1,3 @@
 export * from "./constants";
-export * from "./storage";
+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>;