opencode-matrixx-v2 0.0.0-stage → 1.0.0

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/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 { BackgroundManager } from "../../features/background-agent/manager";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+export declare function createBddPipelineTool(opts: {
+    manager: BackgroundManager;
+}): MatrixxToolDefinition;

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

@@ -0,0 +1,21 @@
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+/**
+ * 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(): MatrixxToolDefinition;

package/dist/tools/dashboard-flux-validator/constants.d.ts

@@ -0,0 +1,8 @@
+import type { FluxSeverity } from "./types";
+export declare const DASHBOARD_FLUX_VALIDATE_DESCRIPTION = "Deterministic, read-only validator for Grafana dashboards and provisioning files backed by InfluxDB-Flux. Returns a JSON report with a status exit code (0=clean, 1=warnings, 2=errors).\n\nChecks:\n- DS001 datasource is provisioned as InfluxDB-Flux (dashboard present but no influxdb type declared).\n- VAR001 a symbol-like template variable does not use `schema.tagValues`.\n- PAN001 a staleness/lag/age panel has no value mappings (or thresholds).\n- GF001 Flux writes with `|> to()` without an explicit `timeColumn: \"_time\"` (server-side timestamp risk).\n- GF002 aggregation without `toFloat()` (field-type conflict risk).\n- GF003 `createEmpty: true` (gap masking).\n- GF004 `join()` instead of `pivot()` (unaligned basis).\n\nAccepts a Grafana provisioning YAML, a dashboard JSON, or a directory. JSON dashboards get structural checks; YAML is linted line-by-line. A missing path fails closed with status 2.";
+export declare const DASHBOARD_EXTENSIONS: string[];
+export declare const IGNORED_DIRS: Set<string>;
+export declare const RULE_CATALOG: Record<string, {
+    severity: FluxSeverity;
+    fix: string;
+}>;

package/dist/tools/dashboard-flux-validator/tools.d.ts

@@ -0,0 +1,3 @@
+import type { MatrixxContext } from "../../plugin/context";
+import { type MatrixxToolDefinition } from "../shared/define-tool";
+export declare function createDashboardFluxValidatorTool(ctx: MatrixxContext): Record<string, MatrixxToolDefinition>;

package/dist/tools/dashboard-flux-validator/types.d.ts

@@ -0,0 +1,20 @@
+export type FluxSeverity = "warn" | "error";
+export interface FluxFinding {
+    rule: string;
+    severity: FluxSeverity;
+    file: string;
+    line: number;
+    excerpt: string;
+    fix: string;
+}
+export interface FluxSummary {
+    filesScanned: number;
+    total: number;
+    byRule: Record<string, number>;
+    note?: string;
+}
+export interface FluxValidationResult {
+    status: 0 | 1 | 2;
+    findings: FluxFinding[];
+    summary: FluxSummary;
+}

package/dist/tools/dashboard-flux-validator/validator.d.ts

@@ -0,0 +1,5 @@
+import type { FluxValidationResult } from "./types";
+export declare function validateDashboard(opts: {
+    base: string;
+    target: string;
+}): FluxValidationResult;

package/dist/tools/delegate-task/available-models.d.ts

@@ -0,0 +1,2 @@
+import type { NativeClient } from "./types";
+export declare function getAvailableModelsForDelegateTask(client: NativeClient): Promise<Set<string>>;

package/dist/tools/delegate-task/background-continuation.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutorContext, ParentContext } from "./executor-types";
+import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types";
+export declare function executeBackgroundContinuation(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext): Promise<string>;

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

@@ -0,0 +1,8 @@
+import type { ExecutorContext, ParentContext } from "./executor-types";
+import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types";
+export declare function executeBackgroundTask(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, parentContext: ParentContext, agentToUse: string, categoryModel: {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+    temperature?: number;
+} | undefined, systemContent: string | undefined): Promise<string>;

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

@@ -0,0 +1,22 @@
+import type { CategoriesConfig, CategoryConfig, ModelPresetEntry, ModelRequirements } from "../../config/schema";
+interface ResolveCategoryConfigOptions {
+    userCategories?: CategoriesConfig;
+    inheritedModel?: string;
+    systemDefaultModel?: string;
+    availableModels?: Set<string>;
+    modelRequirements?: ModelRequirements;
+    /** Preset entry resolved at call time (session overlay > config active_preset). */
+    presetEntry?: ModelPresetEntry;
+}
+interface ResolveCategoryConfigResult {
+    config: CategoryConfig;
+    promptAppend: string;
+    model: string | undefined;
+    temperature: number | undefined;
+}
+/**
+ * Resolve the configuration for a given category name.
+ * Merges default and user configurations, handles model resolution.
+ */
+export declare function resolveCategoryConfig(categoryName: string, options: ResolveCategoryConfigOptions): ResolveCategoryConfigResult | null;
+export {};

package/dist/tools/delegate-task/category-resolver.d.ts

@@ -0,0 +1,24 @@
+import type { ModelFallbackInfo } from "../../features/task-toast-manager/types";
+import type { ExecutorContext } from "./executor-types";
+import type { DelegateTaskArgs } from "./types";
+export interface CategoryResolutionResult {
+    agentToUse: string;
+    categoryModel: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+        temperature?: number;
+    } | undefined;
+    categoryPromptAppend: string | undefined;
+    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,23 @@
+import type { ComplexityLevel } from "./complexity-types";
+export type ComplexityDowngradesConfig = Record<string, Record<string, string>>;
+export type ComplexityConfigHolder = {
+    complexityDowngrades?: ComplexityDowngradesConfig;
+};
+/**
+ * Resolve the model for a given category and complexity level.
+ *
+ * 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.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>, config?: ComplexityConfigHolder | ComplexityDowngradesConfig): {
+    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/constants.d.ts

@@ -0,0 +1,37 @@
+import type { AvailableCategory, AvailableSkill } from "../../agents/dynamic-agent-prompt-builder";
+import type { CategoryConfig } from "../../config/schema";
+export declare const TDD_TEST_FIRST_APPEND = "<TDD_Test_First>\n**NO IMPLEMENTATION WITHOUT A FAILING TEST FIRST.**\n\nMandatory RED-GREEN-REFACTOR cycle:\n- RED: write a failing test first; run it and confirm it fails for the right reason.\n- GREEN: write the minimum code to make the test pass.\n- REFACTOR: clean up; tests stay green throughout.\n\nEvery test uses //#given (setup), //#when (action), //#then (assert) markers.\nVerify with `bun test` (0 failures) before reporting done.\n</TDD_Test_First>";
+/**
+ * Code-writing categories requiring TDD enforcement (issue #127).
+ * Single source of truth for banner gating + fail-closed guard.
+ */
+export declare function isCodeWritingCategory(category: string | undefined): boolean;
+export declare const DEFAULT_CATEGORIES: Record<string, CategoryConfig>;
+export declare const CATEGORY_PROMPT_APPENDS: Record<string, string>;
+export declare const CATEGORY_DESCRIPTIONS: Record<string, string>;
+export declare const SHORT_CATEGORY_HINTS: Record<string, string>;
+export declare function buildPlanAgentSystemPrepend(categories?: AvailableCategory[], skills?: AvailableSkill[]): string;
+/**
+ * List of agent names that should be treated as plan agents (receive plan system prompt).
+ * Case-insensitive matching is used.
+ */
+export declare const PLAN_AGENT_NAMES: string[];
+/**
+ * Check if the given agent name is a plan agent (receives plan system prompt).
+ */
+export declare function isPlanAgent(agentName: string | undefined): boolean;
+/**
+ * Plan family: plan + oracle. Shares mutual delegation blocking and task tool permission.
+ * Does NOT share system prompt (only isPlanAgent controls that).
+ */
+export declare const PLAN_FAMILY_NAMES: string[];
+/**
+ * Get the deliverable tag for a given agent name.
+ * Returns undefined if no tagging applies.
+ */
+export declare function getDeliverableTag(agentName: string | undefined): string | undefined;
+/**
+ * Check if the given agent belongs to the plan family (blocking + task permission).
+ */
+export declare function isPlanFamily(category: string): boolean;
+export declare function isPlanFamily(category: string | undefined): boolean;

package/dist/tools/delegate-task/default-model.d.ts

@@ -0,0 +1,27 @@
+type DefaultModelPair = {
+    providerID: string;
+    modelID: string;
+};
+type DefaultModelEditor = {
+    default?: {
+        get?: () => {
+            providerID?: string;
+            modelID?: string;
+        } | undefined;
+    };
+    [key: string]: unknown;
+};
+type ModelTransform = (callback: (editor: DefaultModelEditor) => void) => Promise<unknown>;
+export type SystemDefaultModelSource = {
+    model?: {
+        transform?: ModelTransform;
+    };
+};
+/**
+ * Reads the live default model. Precedence: `ModelEditor.default.get()` (the model actually
+ * in force) over the config draft — both derive from the same setting, but if they ever
+ * diverge the live default wins. The transform registration is released immediately so
+ * repeated calls cannot accumulate scoped transforms.
+ */
+export declare function resolveSystemDefaultModel(source?: SystemDefaultModelSource): Promise<string | undefined>;
+export type { DefaultModelPair };

package/dist/tools/delegate-task/diagnostic-shape.d.ts

@@ -0,0 +1,4 @@
+import type { SessionMessage } from "../../shared/session-message";
+export declare const DIAGNOSTIC_CAUSES = "Classified causes: (1) child produced no assistant message (empty model output / permission-denied delegation inside child); (2) messages exist but do not match the expected flat shape; (3) delegation was issued from inside code-mode (task has codemode:false) or with a permission-denied tool. Check /tmp/matrixx.log delegate-task entries for session ID.";
+export declare function describeMessageShape(messages: SessionMessage[]): string;
+export declare function describeLastMessageParts(messages: SessionMessage[]): string;

package/dist/tools/delegate-task/error-formatting.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Re-export shim for backward compatibility.
+ * The canonical location is src/shared/error-formatting.ts.
+ * New code should import directly from "../../shared/error-formatting".
+ */
+export { type ErrorContext, formatDetailedError } from "../../shared/error-formatting";

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

@@ -0,0 +1,37 @@
+import type { AgentOverrides, BrowserAutomationProvider, CategoriesConfig, ComplexityDowngrades, ModelPresets, ModelRequirements } from "../../config/schema";
+import type { BackgroundManager } from "../../features/background-agent";
+import type { NativeClient } from "./types";
+export interface ExecutorContext {
+    manager: BackgroundManager;
+    client: NativeClient;
+    directory: string;
+    userCategories?: CategoriesConfig;
+    mouseModel?: string;
+    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;
+        title: string;
+    }) => Promise<void>;
+}
+export interface ParentContext {
+    sessionID: string;
+    messageID: string;
+    agent?: string;
+    model?: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+    };
+}
+export type { ContentPart, SessionMessage } from "../../shared/session-message";

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

@@ -0,0 +1,11 @@
+export { executeBackgroundContinuation } from "./background-continuation";
+export { executeBackgroundTask } from "./background-task";
+export type { CategoryResolutionResult } from "./category-resolver";
+export { resolveCategoryExecution } from "./category-resolver";
+export type { ExecutorContext, ParentContext } from "./executor-types";
+export { resolveParentContext } from "./parent-context-resolver";
+export { resolveSkillContent } from "./skill-resolver";
+export { resolveSubagentExecution } from "./subagent-resolver";
+export { executeSyncContinuation } from "./sync-continuation";
+export { executeSyncTask } from "./sync-task";
+export { executeUnstableAgentTask } from "./unstable-agent-task";

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

@@ -0,0 +1,10 @@
+export { resolveComplexityModel } from "./complexity-constants";
+export { autoScoreComplexity } from "./complexity-scorer";
+export type { ComplexityInput, ComplexityLevel } from "./complexity-types";
+export * from "./constants";
+export { resolveSystemDefaultModel, type SystemDefaultModelSource } from "./default-model";
+export { isSoftwareDevExecutorTarget, isSoftwareDevOrchestratorTarget, softwareDevDisabledSkillError, } from "./software-dev-enforcement";
+export { resolveSoftwareDevEnforcementContent, type SoftwareDevEnforcementResult, } from "./software-dev-payload";
+export type { BuildSystemContentInput, DelegateTaskToolOptions, SyncSessionCreatedEvent } from "./tools";
+export { buildSystemContent, createDelegateTask, resolveCategoryConfig } from "./tools";
+export type * from "./types";

package/dist/tools/delegate-task/model-selection.d.ts

@@ -0,0 +1,11 @@
+import type { FallbackEntry } from "../../shared/model-requirements";
+export declare function resolveModelForDelegateTask(input: {
+    userModel?: string;
+    categoryDefaultModel?: string;
+    fallbackChain?: FallbackEntry[];
+    availableModels: Set<string>;
+    systemDefaultModel?: string;
+}): {
+    model: string;
+    variant?: string;
+} | undefined;

package/dist/tools/delegate-task/model-string-parser.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Parse a model string in "provider/model" format.
+ */
+export declare function parseModelString(model: string): {
+    providerID: string;
+    modelID: string;
+} | undefined;

package/dist/tools/delegate-task/mouse-agent.d.ts

@@ -0,0 +1 @@
+export declare const MOUSE_AGENT = "mouse";

package/dist/tools/delegate-task/parent-context-resolver.d.ts

@@ -0,0 +1,3 @@
+import type { ParentContext } from "./executor-types";
+import type { NativeClient, ToolContextWithMetadata } from "./types";
+export declare function resolveParentContext(ctx: ToolContextWithMetadata, client: NativeClient): Promise<ParentContext>;

package/dist/tools/delegate-task/prompt-builder.d.ts

@@ -0,0 +1,7 @@
+import type { BuildSystemContentInput } from "./types";
+/**
+ * Build the system content to inject into the agent prompt.
+ * Combines skill content, category prompt append, and plan agent system prepend.
+ * Appends the TDD test-first banner LAST only for code-writing categories.
+ */
+export declare function buildSystemContent(input: BuildSystemContentInput): string | undefined;

package/dist/tools/delegate-task/skill-resolver.d.ts

@@ -0,0 +1,8 @@
+import type { BrowserAutomationProvider } from "../../config/schema";
+export declare function resolveSkillContent(skills: string[], options: {
+    browserProvider?: BrowserAutomationProvider;
+    disabledSkills?: Set<string>;
+}): {
+    content: string | undefined;
+    error: string | null;
+};

package/dist/tools/delegate-task/software-dev-enforcement.d.ts

@@ -0,0 +1 @@
+export { isSoftwareDevExecutorTarget, isSoftwareDevOrchestratorTarget, softwareDevDisabledSkillError, } from "../../shared/software-dev-enforcement";

package/dist/tools/delegate-task/software-dev-payload.d.ts

@@ -0,0 +1 @@
+export { resolveSoftwareDevEnforcementContent, type SoftwareDevEnforcementResult, } from "../../shared/software-dev-enforcement";

package/dist/tools/delegate-task/subagent-resolver.d.ts

@@ -0,0 +1,11 @@
+import type { ExecutorContext } from "./executor-types";
+import type { DelegateTaskArgs } from "./types";
+export declare function resolveSubagentExecution(args: DelegateTaskArgs, executorCtx: ExecutorContext, parentAgent: string | undefined, categoryExamples: string): Promise<{
+    agentToUse: string;
+    categoryModel: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+    } | undefined;
+    error?: string;
+}>;

package/dist/tools/delegate-task/sync-continuation-deps.d.ts

@@ -0,0 +1,7 @@
+import { fetchSyncResult } from "./sync-result-fetcher";
+import { pollSyncSession } from "./sync-session-poller";
+export declare const syncContinuationDeps: {
+    pollSyncSession: typeof pollSyncSession;
+    fetchSyncResult: typeof fetchSyncResult;
+};
+export type SyncContinuationDeps = typeof syncContinuationDeps;

package/dist/tools/delegate-task/sync-continuation.d.ts

@@ -0,0 +1,4 @@
+import type { ExecutorContext } from "./executor-types";
+import { type SyncContinuationDeps } from "./sync-continuation-deps";
+import type { DelegateTaskArgs, ToolContextWithMetadata } from "./types";
+export declare function executeSyncContinuation(args: DelegateTaskArgs, ctx: ToolContextWithMetadata, executorCtx: ExecutorContext, deps?: SyncContinuationDeps): Promise<string>;

package/dist/tools/delegate-task/sync-empty-retry.d.ts

@@ -0,0 +1,8 @@
+import type { SessionMessage } from "./executor-types";
+import type { DelegateTaskArgs, NativeClient } from "./types";
+export declare const SYNC_EMPTY_RETRY_BACKOFF_MS = 1500;
+export declare function getEmptyRetryBackoffMs(): number;
+export declare function __setEmptyRetryBackoffMs(ms: number): void;
+export declare function __resetEmptyRetryBackoffMs(): void;
+export declare function isSessionEmpty(client: NativeClient, sessionID: string): Promise<boolean>;
+export declare function formatEmptySessionError(args: DelegateTaskArgs, sessionID: string, agentToUse: string, observed?: SessionMessage[]): string;

package/dist/tools/delegate-task/sync-prompt-sender.d.ts

@@ -0,0 +1,27 @@
+import { promptNativeWithModelSuggestionRetry } from "../../shared/model-suggestion-retry";
+import type { DelegateTaskArgs, NativeClient } from "./types";
+type SendSyncPromptDeps = {
+    sendNativePrompt: typeof promptNativeWithModelSuggestionRetry;
+};
+export interface SyncPromptV2Args {
+    sessionID: string;
+    text: string;
+    [key: string]: unknown;
+}
+export declare function sendSyncPrompt(client: NativeClient, input: {
+    sessionID: string;
+    agentToUse: string;
+    args: DelegateTaskArgs;
+    systemContent: string | undefined;
+    categoryModel: {
+        providerID: string;
+        modelID: string;
+        variant?: string;
+        temperature?: number;
+    } | undefined;
+    toastManager: {
+        removeTask: (id: string) => void;
+    } | null | undefined;
+    taskId: string | undefined;
+}, deps?: SendSyncPromptDeps): Promise<string | null>;
+export {};

package/dist/tools/delegate-task/sync-result-fetcher.d.ts

@@ -0,0 +1,13 @@
+import type { NativeClient } from "./types";
+type FetchSyncResultOptions = {
+    deliverableTag?: string;
+    finalTextOnly?: boolean;
+};
+export declare function fetchSyncResult(client: NativeClient, sessionID: string, anchorMessageCount?: number, options?: FetchSyncResultOptions): Promise<{
+    ok: true;
+    textContent: string;
+} | {
+    ok: false;
+    error: string;
+}>;
+export {};

package/dist/tools/delegate-task/sync-session-creator.d.ts

@@ -0,0 +1,21 @@
+import type { NativeClient } from "./types";
+export interface SyncSessionModel {
+    providerID: string;
+    modelID: string;
+    variant?: string;
+}
+export declare function createSyncSession(client: NativeClient, input: {
+    parentSessionID: string;
+    agentToUse: string;
+    description: string;
+    defaultDirectory: string;
+    category?: string;
+    model?: SyncSessionModel;
+}): Promise<{
+    ok: true;
+    sessionID: string;
+    parentDirectory: string;
+} | {
+    ok: false;
+    error: string;
+}>;