@harness-engineering/orchestrator 0.13.0 → 0.15.0

package/dist/index.d.ts

@@ -1,7 +1,8 @@
 import * as _harness_engineering_types from '@harness-engineering/types';
 import { Issue, WorkflowExecutionPlan, StageRun, AgentEvent, WorkflowConfig, TokenUsage, ConcernSignal, ScopeTier, EscalationConfig, IssueRoutingDecision, Result, WorkflowDefinition, BackendDef, RoutingConfig, RoutingDecision, RoutingUseCase, ContainerConfig, SecretConfig, AgentBackend, RoutingRequest, CapabilityTier, WorkspaceConfig, HooksConfig, SessionStartParams, AgentSession, AgentError, TurnParams, TurnResult, CheckScriptDefinition, OutputRetentionConfig, BackendCapabilityRegistry, RoutingPolicy, ComplexityVerdict, RoutingTelemetry, RoutingStatus, RoutingError, PrivacyClass, BackendCapabilities, AgentConfig, LocalModelStatus, CustomTaskDefinition, MaintenanceConfig, TokenScope, AuthToken, AuthTokenPublic, IndexedFileKind, SessionSearchResult, ReindexStats, SessionSummarizationConfig, SessionSummary, SessionSummaryMeta, SessionsConfig, GatewayEvent, NotificationEnvelope, NotificationDeliveryResult, NotificationSinkConfig, NotificationsConfig } from '@harness-engineering/types';
-import { IssueTrackerClient, Issue as Issue$1, CacheMetricsRecorder, TrackerConfig, eventSourcing, ArchiveHooks, SkillProposal, ProposalGateFinding, SkillKind } from '@harness-engineering/core';
-import { EnrichedSpec, ComplexityScore, SimulationResult, IntelligencePipeline, WeightedRecommendation, AnalysisProvider } from '@harness-engineering/intelligence';
+import { IssueTrackerClient, Issue as Issue$1, CacheMetricsRecorder, TrackerConfig, eventSourcing, RoadmapStore, ArchiveHooks, SkillProposal, ProposalGateFinding, SkillKind } from '@harness-engineering/core';
+import { EnrichedSpec, ComplexityScore, SimulationResult, IntelligencePipeline, WeightedRecommendation, AnalysisProvider, PrecedentLookup, ProbeConfig, ProbeInput, GraphScope, TriageVerdict, ForkGenerator, BrainstormOutcome, BrainstormInput, SpecDraft, GoNoGoCandidate } from '@harness-engineering/intelligence';
+export { RankableCandidate, TriageVerdict, pilotScore, rankTriageCandidates } from '@harness-engineering/intelligence';
 import { GraphStore } from '@harness-engineering/graph';
 import { execFile } from 'node:child_process';
 import { EventEmitter } from 'node:events';
@@ -653,25 +654,6 @@ interface TriageConfig {
  * Returns undefined if no prefix is present.
  */
 declare function extractTitlePrefix(title: string | null | undefined): string | undefined;
-/**
- * Decide which skill/agent the orchestrator should dispatch this issue to.
- *
- * Rule order (first match wins):
- *  1. isRollback                          → debugging (high)
- *  2. security prefix or security paths   → security-review (high)
- *  3. docs prefix or docs-only diff       → docs (high)
- *  4. hasFailingTests                     → debugging (medium)
- *  5. touchesMigrationPaths               → planning (high)
- *  6. fix: with small change              → code-review (high)
- *  7. feat:                               → planning (medium)
- *  8. refactor:                           → refactoring (medium)
- *  9. default                             → code-review (low)
- *
- * Triage is meant to run BEFORE `routeIssue()`; the selected skill is
- * persisted on the live session so downstream dispatch does not
- * re-derive it.
- */
-declare function triageIssue(issue: Issue, signals: TriageSignals, config?: TriageConfig): TriageDecision;
 
 /**
  * A pending human interaction, typically from an escalation.
@@ -2620,6 +2602,34 @@ declare class Orchestrator extends EventEmitter {
      * evaluator's `execution_outcome` persistence is best-effort and never blocks.
      */
     private deriveAcceptanceEvalVerdict;
+    /**
+     * Roadmap Auto-Triage Phase 4 (SC1–SC3, SC5, SC7): the post-diff routing
+     * retrospective — a SIBLING quality-verdict source to the 4c feeder above,
+     * extending (not replacing) the proven escalation path. On a normal exit, when AMR
+     * is live AND auto-triage is enabled AND this unit carries a stored pre-dispatch
+     * prediction, it classifies the ACTUAL introduced diff at full strength
+     * (phase:'post-diff') and grades it against that prediction:
+     *   - MATCH   → records the graded outcome + annotates the PR "AI autonomous —
+     *               verify" (stage-2 human-verify handling, SC4) → returns `undefined`
+     *               (neutral: a match is not an escalation).
+     *   - MISMATCH (diff exceeded prediction, or a missing/garbled prediction, or ANY
+     *               error) → records the outcome (when a shape is known) + returns
+     *               `'quality-fail'`, which climbs the coherence unit's escalation floor
+     *               via `recordAmrOutcome`; exhaustion queues `needs-human` (SC3/SC7).
+     *
+     * Fail-safe & guarded (SC7): an error never a silent pass — it takes the MISMATCH
+     * (block+escalate) path. No-op (byte-identical) when AMR is off, auto-triage is
+     * off, or the unit was not dispatched through triage (no stored prediction) — the
+     * last means an ordinary non-triaged run is never graded.
+     */
+    private deriveRoutingRetrospectiveVerdict;
+    /**
+     * v1 stage-2 match handling (SC4): annotate the unit's PR/issue with a "verify this
+     * autonomous change" note so a human reviews every autonomous PR. Best-effort — a
+     * missing tracker config / token / a failed comment never breaks completion (the
+     * grade already recorded above). Mirrors `postLifecycleComment`'s adapter wiring.
+     */
+    private annotateRetrospectiveMatch;
     /**
      * Informs the state machine that an agent worker has exited.
      */
@@ -2906,6 +2916,226 @@ declare function launchTUI(orchestrator: Orchestrator): {
     waitUntilExit: () => Promise<void>;
 };
 
+/**
+ * Build the pure `ProbeInput` from an `Issue`. Reuses `buildTaskText` for the pre-diff
+ * text-only signals (title+description length, spec/acceptance hints, prompt) and
+ * `extractEntities` for the candidate entity mentions the scope lever will try to resolve.
+ *
+ * Pure over the Issue — unit-testable without instantiating an Orchestrator.
+ */
+declare function buildProbeInput(issue: Issue): ProbeInput;
+/**
+ * The concrete `GraphScope` seam over a loaded `GraphStore`. For each candidate it resolves
+ * a node (name → path → file-id) and simulates the blast radius via `CascadeSimulator`
+ * (`summary.totalAffected`). Returns `null` for unresolved candidates — the S3 contract: an
+ * unresolved candidate does NOT count toward scope. Never throws out of `resolve` (the probe
+ * also guards it, but we keep this defensive so one odd node can't sink the lever).
+ */
+declare function makeGraphScope(store: GraphStore): GraphScope;
+/** Injected dependencies for the wired triage over a single issue. */
+interface TriageWiringDeps {
+    /** The SEL analysis provider (from `buildAnalysisProviderForLayer('sel', …)`). */
+    provider?: AnalysisProvider | null;
+    /** The loaded knowledge-graph store. Absent ⇒ scope degrades ⇒ everything holds. */
+    graphStore?: GraphStore | null;
+    /** The precedent lever (Phase 4 wires the real one; absent ⇒ cold-start unknown). */
+    precedent?: PrecedentLookup;
+    /** Gate seeds from `roadmap.autoTriage.thresholds`. */
+    config?: Partial<ProbeConfig>;
+    /** Optional model overrides threaded to the classifier tie-break. */
+    models?: {
+        fast?: string;
+        standard?: string;
+    };
+}
+/**
+ * Run the scoping probe over a single `Issue`: build the input, resolve the injected SEL
+ * provider + graph seam, and invoke the pure probe. Returns the `TriageVerdict`. Never
+ * throws — the probe itself is total; the only added surface here is graph-store adaptation,
+ * which `makeGraphScope` keeps defensive.
+ */
+declare function triageIssue(issue: Issue, deps?: TriageWiringDeps): Promise<TriageVerdict>;
+
+/** The human-only rubric — named triggers that MUST bias the model to low confidence. */
+declare const BRAINSTORM_RUBRIC: string;
+interface SelForkGeneratorOptions {
+    /** Samples per fork for the self-consistency check (default 3; min 2 to detect a flip). */
+    samples?: number;
+    /** Optional model override threaded to the provider. */
+    model?: string;
+    /** Max tokens per sample (default 512). */
+    maxTokens?: number;
+}
+/**
+ * Build a real `ForkGenerator` over an `AnalysisProvider`. For each fork index the generator
+ * samples the model N times; it accepts the fork (passing through the model's reported `high`)
+ * only when EVERY sample agrees on the SAME fork identity (`forkId` + normalized `question`)
+ * AND the SAME recommended option, AND that recommendation is non-empty AND is one of the
+ * fork's offered `options`. Any drift, instability, or degenerate/off-menu recommendation
+ * forces `confidence:'low'` (the runner then halts and a human owns the fork). The generator
+ * NEVER throws for a well-formed provider; a provider error propagates and the pure runner maps
+ * it to `halted{ reason:'error' }`.
+ */
+declare function makeSelForkGenerator(provider: AnalysisProvider, input: BrainstormInput, opts?: SelForkGeneratorOptions): ForkGenerator;
+interface BrainstormWiringDeps {
+    /**
+     * An explicit `ForkGenerator` to drive the brainstorm. INJECTED in tests (no live model).
+     * When absent, `provider` is required and a real SEL generator is built.
+     */
+    generator?: ForkGenerator;
+    /** The SEL provider used to build the real generator when `generator` is absent. */
+    provider?: AnalysisProvider | null;
+    /** Self-consistency / model options for the built generator. */
+    generatorOptions?: SelForkGeneratorOptions;
+    /**
+     * Docs root under which a completed spec is written (`<docsRoot>/changes/<slug>/proposal.md`).
+     * Absent ⇒ no spec is written (dry run) but the outcome is still returned.
+     */
+    docsRoot?: string;
+    /** Re-score deps threaded to `triageIssue` (SC4). Absent ⇒ re-score is skipped. */
+    rescore?: {
+        graphStore?: GraphStore | null;
+    } & Pick<TriageWiringDeps, 'provider' | 'precedent' | 'config' | 'models'>;
+}
+/** The wired result: the pure outcome + (on completion) the written path + the re-score verdict. */
+interface WiredBrainstormResult {
+    /** The pure decision-core outcome (completed{spec} | halted{fork,reason}). */
+    outcome: BrainstormOutcome;
+    /** Absolute path of the written spec, when a spec was completed AND `docsRoot` was set. */
+    specPath?: string;
+    /** The re-score verdict over the enriched content (SC4), when the brainstorm completed. */
+    rescore?: TriageVerdict;
+}
+/**
+ * Build a `BrainstormInput` from an `Issue` + its Phase-1 complexity level. Pure over the Issue.
+ */
+declare function brainstormInputFromIssue(issue: Issue, level: BrainstormInput['level']): BrainstormInput;
+/**
+ * Run the autonomous brainstorm for one issue and, on a clean completion, write a
+ * proposal-shaped spec + re-score the enriched item (SC4). The generator is injected (tests)
+ * or built over the SEL provider (production). Never throws — the pure runner is total, and
+ * the doc-write / re-score are guarded.
+ */
+declare function runBrainstormForIssue(issue: Issue, level: BrainstormInput['level'], deps: BrainstormWiringDeps): Promise<WiredBrainstormResult>;
+/** Slugify an item identity into a docs directory name. */
+declare function slugFor(spec: SpecDraft): string;
+/**
+ * Render a `SpecDraft` as a proposal-shaped markdown spec: a decision record where each
+ * accepted fork becomes an "Approach" section (question → recommended option + rationale).
+ */
+declare function renderSpecMarkdown(spec: SpecDraft): string;
+/**
+ * Produce an enriched `Issue` whose description carries the drafted spec's substance, so the
+ * re-score (SC4) reads REAL content — the resolved decisions + rationale — not the original
+ * one-line length proxy. Pure over the inputs.
+ */
+declare function enrichIssueWithSpec(issue: Issue, spec: SpecDraft): Issue;
+
+/**
+ * One approved item to mark, bundling everything the two writes need: the go/no-go verdict
+ * (must be `humanApproved`), the roadmap feature name (→ shard slug), the Phase-2 spec path
+ * to attach, and the probe outputs for the prediction slice.
+ */
+interface TriageMarkItem {
+    /** The go/no-go candidate. Only acted on when `candidate.humanApproved` is true (SC5). */
+    candidate: GoNoGoCandidate;
+    /** The roadmap feature's display name — slugified to resolve its shard. */
+    featureName: string;
+    /** Repo-relative path to the generated spec (Phase 2 output) to attach to the feature. */
+    specPath: string;
+    /** Item labels (for the prediction's shapeKey bucket). */
+    labels: readonly string[];
+    /** The pre-diff complexity verdict from the probe (the prediction being made). */
+    verdict: ComplexityVerdict;
+    /** Predicted blast radius (from the scope lever) — recorded for the retrospective. */
+    scopeEstimate: number;
+    /**
+     * The EVIDENCE-DERIVED autonomy stage this item's SHAPE earned (SC6), resolved
+     * per-shape by the caller (`min(resolveStage(history), configuredCeiling, 2)`).
+     * When present it is stamped onto the prediction INSTEAD of the uniform
+     * `config.ratchetStage`, so the ratchet advances per-shape. Absent ⇒ the marker
+     * falls back to `config.ratchetStage` (the Phase-3 uniform behavior).
+     */
+    effectiveStage?: 1 | 2;
+}
+/** The feature-flag + ratchet surface the marker reads (default-off master switch). */
+interface TriageMarkConfig {
+    /** Master switch. `false` ⇒ complete no-op (SC7). */
+    enabled: boolean;
+    /** Ratchet stage stamped onto the prediction (Phase 3 pins 1). */
+    ratchetStage: 1 | 2 | 3 | 4;
+}
+/** Injected prediction writer — the Phase-0 TriageRecord store's append. Fakeable in tests. */
+type RecordPrediction = (payload: eventSourcing.TriagePredictedInput) => Promise<{
+    ok: boolean;
+    error?: Error;
+}>;
+interface TriageMarkDeps {
+    /** The roadmap store to patch (real via `resolveRoadmapStoreForFile`, fake in tests). */
+    store: RoadmapStore;
+    /** Feature-flag + ratchet config. */
+    config: TriageMarkConfig;
+    /** Prediction writer (Phase-0 store). */
+    recordPrediction: RecordPrediction;
+    /**
+     * The orchestrator's self-identity for the assignee gate. When provided, an item assigned
+     * to anyone else is skipped (SC6). When omitted, the gate is inactive (call-sites without
+     * identity — mirrors `candidate-selection.ts`'s `selfAssignee` optionality).
+     */
+    selfAssignee?: string | null;
+}
+/** Why an item was skipped rather than marked (legible, closed set). */
+type MarkSkipReason = 
+/** The candidate was not human-approved (SC5) — should not reach the marker, guarded anyway. */
+'not-approved'
+/** The item is assigned to a non-self assignee (SC6) — never stolen. */
+ | 'assigned-elsewhere'
+/** The feature was not found in the roadmap (stale externalId / renamed). */
+ | 'feature-not-found';
+interface MarkSkip {
+    externalId: string;
+    reason: MarkSkipReason;
+}
+/** The marker's outcome: which items were made eligible, and which were skipped + why. */
+interface TriageMarkResult {
+    /** externalIds of items successfully marked eligible (spec attached + prediction recorded). */
+    marked: string[];
+    /** Items intentionally not marked, each with the legible reason. */
+    skipped: MarkSkip[];
+}
+/**
+ * Mark human-approved items eligible for the existing orchestrator pickup, and record their
+ * pre-dispatch predictions. Returns `Ok` with the mark/skip partition, or `Err` on the first
+ * store write that fails (so a partial roadmap write surfaces rather than silently dropping).
+ *
+ * NOTE ON DISPATCH: nothing here dispatches. The orchestrator's own pickup loop selects the
+ * now-spec-bearing, active-status item on its next tick and runs it through unchanged gating.
+ */
+declare function markApprovedForDispatch(items: readonly TriageMarkItem[], deps: TriageMarkDeps): Promise<{
+    ok: true;
+    value: TriageMarkResult;
+} | {
+    ok: false;
+    error: Error;
+}>;
+
+/** The minimal stored-record shape the precedent aggregation reads (structural mirror). */
+interface StoredOutcomeRecord {
+    shapeKey: string;
+    outcome?: {
+        matched: boolean;
+    };
+}
+/**
+ * The REAL `PrecedentLookup` (SC5) — closes the Phase-1 degrade-empty stub. Aggregates
+ * the autonomous-success base-rate over recorded outcomes sharing a `shapeKey` via the
+ * pure `aggregatePrecedent`. Bridges core's `StoredTriageRecord` (whose `outcome` slice
+ * is structurally `{ matched }` for aggregation purposes) into the intelligence
+ * aggregation. With no outcome-bearing records for a shape it returns `unknown` — the
+ * exact Phase-1 cold-start behavior, now real once outcomes accrue.
+ */
+declare function precedentLookupFromStored(records: readonly StoredOutcomeRecord[]): PrecedentLookup;
+
 /**
  * Fail-closed signal: privacy floor / allowlist emptied the candidate set (S4-001).
  * Distinguishable from a tier/cost-only exclusion, which returns `undefined`.
@@ -3048,54 +3278,244 @@ declare function makeBackendResolver(backends: Record<string, BackendDef> | null
  */
 declare const BackendDefSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: z.ZodLiteral<"mock">;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "mock";
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
 }, {
     type: "mock";
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"claude">;
     command: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "claude";
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     command?: string | undefined;
 }, {
     type: "claude";
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     command?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"anthropic">;
     model: z.ZodString;
     apiKey: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "anthropic";
     model: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
 }, {
     type: "anthropic";
     model: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"openai">;
     model: z.ZodString;
     apiKey: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "openai";
     model: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
 }, {
     type: "openai";
     model: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"gemini">;
     model: z.ZodString;
     apiKey: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "gemini";
     model: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
 }, {
     type: "gemini";
     model: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
 }>, z.ZodObject<{
     type: z.ZodLiteral<"local">;
@@ -3104,10 +3524,40 @@ declare const BackendDefSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
     probeIntervalMs: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "local";
     model: string | [string, ...string[]];
     endpoint: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
     probeIntervalMs?: number | undefined;
@@ -3115,6 +3565,14 @@ declare const BackendDefSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: "local";
     model: string | [string, ...string[]];
     endpoint: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
     probeIntervalMs?: number | undefined;
@@ -3125,10 +3583,40 @@ declare const BackendDefSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     apiKey: z.ZodOptional<z.ZodString>;
     timeoutMs: z.ZodOptional<z.ZodNumber>;
     probeIntervalMs: z.ZodOptional<z.ZodNumber>;
+    capabilities: z.ZodOptional<z.ZodObject<{
+        tier: z.ZodEnum<["fast", "standard", "strong"]>;
+        costPer1kTokens: z.ZodNumber;
+        privacyClass: z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>;
+        contextWindow: z.ZodNumber;
+        vision: z.ZodOptional<z.ZodBoolean>;
+        toolUse: z.ZodOptional<z.ZodBoolean>;
+    }, "strict", z.ZodTypeAny, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }, {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     type: "pi";
     model: string | [string, ...string[]];
     endpoint: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
     probeIntervalMs?: number | undefined;
@@ -3136,6 +3624,14 @@ declare const BackendDefSchema: z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
     type: "pi";
     model: string | [string, ...string[]];
     endpoint: string;
+    capabilities?: {
+        tier: "fast" | "standard" | "strong";
+        costPer1kTokens: number;
+        privacyClass: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud";
+        contextWindow: number;
+        vision?: boolean | undefined;
+        toolUse?: boolean | undefined;
+    } | undefined;
     apiKey?: string | undefined;
     timeoutMs?: number | undefined;
     probeIntervalMs?: number | undefined;
@@ -3193,6 +3689,69 @@ declare const RoutingConfigSchema: z.ZodObject<{
     }>>;
     skills: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>>;
     modes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<[z.ZodString, z.ZodReadonly<z.ZodArray<z.ZodString, "atleastone">>]>>>;
+    policy: z.ZodOptional<z.ZodObject<{
+        complexityTierMatrix: z.ZodOptional<z.ZodRecord<z.ZodEnum<["trivial", "simple", "moderate", "complex"]>, z.ZodEnum<["fast", "standard", "strong"]>>>;
+        skillTierOverrides: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["fast", "standard", "strong"]>>>;
+        privacyFloor: z.ZodOptional<z.ZodEnum<["on-device", "pooled-isolated", "byo-endpoint", "shared-cloud"]>>;
+        budget: z.ZodOptional<z.ZodObject<{
+            capUsd: z.ZodNumber;
+            degradeAtPct: z.ZodOptional<z.ZodNumber>;
+            onBudgetExhausted: z.ZodEnum<["degrade", "pause", "human"]>;
+        }, "strip", z.ZodTypeAny, {
+            capUsd: number;
+            onBudgetExhausted: "human" | "degrade" | "pause";
+            degradeAtPct?: number | undefined;
+        }, {
+            capUsd: number;
+            onBudgetExhausted: "human" | "degrade" | "pause";
+            degradeAtPct?: number | undefined;
+        }>>;
+        sensitivePaths: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        escalationThreshold: z.ZodOptional<z.ZodNumber>;
+        allowedProviders: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        acceptanceEval: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodBoolean;
+            model: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            model?: string | undefined;
+        }, {
+            enabled: boolean;
+            model?: string | undefined;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        complexityTierMatrix?: Partial<Record<"trivial" | "simple" | "moderate" | "complex", "fast" | "standard" | "strong">> | undefined;
+        skillTierOverrides?: Record<string, "fast" | "standard" | "strong"> | undefined;
+        privacyFloor?: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud" | undefined;
+        budget?: {
+            capUsd: number;
+            onBudgetExhausted: "human" | "degrade" | "pause";
+            degradeAtPct?: number | undefined;
+        } | undefined;
+        sensitivePaths?: string[] | undefined;
+        escalationThreshold?: number | undefined;
+        allowedProviders?: string[] | undefined;
+        acceptanceEval?: {
+            enabled: boolean;
+            model?: string | undefined;
+        } | undefined;
+    }, {
+        complexityTierMatrix?: Partial<Record<"trivial" | "simple" | "moderate" | "complex", "fast" | "standard" | "strong">> | undefined;
+        skillTierOverrides?: Record<string, "fast" | "standard" | "strong"> | undefined;
+        privacyFloor?: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud" | undefined;
+        budget?: {
+            capUsd: number;
+            onBudgetExhausted: "human" | "degrade" | "pause";
+            degradeAtPct?: number | undefined;
+        } | undefined;
+        sensitivePaths?: string[] | undefined;
+        escalationThreshold?: number | undefined;
+        allowedProviders?: string[] | undefined;
+        acceptanceEval?: {
+            enabled: boolean;
+            model?: string | undefined;
+        } | undefined;
+    }>>;
 }, "strict", z.ZodTypeAny, {
     default: string | readonly [string, ...string[]];
     'quick-fix'?: string | readonly [string, ...string[]] | undefined;
@@ -3210,6 +3769,23 @@ declare const RoutingConfigSchema: z.ZodObject<{
     } | undefined;
     skills?: Record<string, string | readonly [string, ...string[]]> | undefined;
     modes?: Record<string, string | readonly [string, ...string[]]> | undefined;
+    policy?: {
+        complexityTierMatrix?: Partial<Record<"trivial" | "simple" | "moderate" | "complex", "fast" | "standard" | "strong">> | undefined;
+        skillTierOverrides?: Record<string, "fast" | "standard" | "strong"> | undefined;
+        privacyFloor?: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud" | undefined;
+        budget?: {
+            capUsd: number;
+            onBudgetExhausted: "human" | "degrade" | "pause";
+            degradeAtPct?: number | undefined;
+        } | undefined;
+        sensitivePaths?: string[] | undefined;
+        escalationThreshold?: number | undefined;
+        allowedProviders?: string[] | undefined;
+        acceptanceEval?: {
+            enabled: boolean;
+            model?: string | undefined;
+        } | undefined;
+    } | undefined;
 }, {
     default: string | readonly [string, ...string[]];
     'quick-fix'?: string | readonly [string, ...string[]] | undefined;
@@ -3227,6 +3803,23 @@ declare const RoutingConfigSchema: z.ZodObject<{
     } | undefined;
     skills?: Record<string, string | readonly [string, ...string[]]> | undefined;
     modes?: Record<string, string | readonly [string, ...string[]]> | undefined;
+    policy?: {
+        complexityTierMatrix?: Partial<Record<"trivial" | "simple" | "moderate" | "complex", "fast" | "standard" | "strong">> | undefined;
+        skillTierOverrides?: Record<string, "fast" | "standard" | "strong"> | undefined;
+        privacyFloor?: "on-device" | "pooled-isolated" | "byo-endpoint" | "shared-cloud" | undefined;
+        budget?: {
+            capUsd: number;
+            onBudgetExhausted: "human" | "degrade" | "pause";
+            degradeAtPct?: number | undefined;
+        } | undefined;
+        sensitivePaths?: string[] | undefined;
+        escalationThreshold?: number | undefined;
+        allowedProviders?: string[] | undefined;
+        acceptanceEval?: {
+            enabled: boolean;
+            model?: string | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 
 interface ResolverLogger {
@@ -4535,4 +5128,4 @@ declare function emitProposalCreated(bus: EventEmitter, proposal: SkillProposal)
 declare function emitProposalApproved(bus: EventEmitter, proposal: SkillProposal): void;
 declare function emitProposalRejected(bus: EventEmitter, proposal: SkillProposal): void;
 
-export { AdaptiveRouter, type AdaptiveRouterDeps, type AgentDispatchResult, type AgentDispatcher, type AgentDispatcherDeps, type AgentUpdateEvent, AnalysisArchive, type AnalysisRecord, type ApplyEventResult, type ArtifactPresence, type AttemptStats, BUILT_IN_TASKS, BackendDefSchema, type BackendResolver, BackendRouter, type BackendRouterOptions, type BaseRefFallbackEvent, type BuildArchiveHooksOptions, type BuildWorkflowContextDeps, type CheckCommandResult, type CheckCommandRunner, type CheckFailureClassification, type CheckFailureKind, CheckScriptRunner, ClaimManager, type ClaimManagerConfig, type CleanWorkspaceEffect, type CommandExecResult, type CommandExecutor, type CreateTokenInput, type CreateTokenResult, type CustomTaskValidationError, type DispatchEffect, type EmitLogEffect, type EscalateEffect, EscalationState, type ExecFileAsyncFn, type ExecFileError, type ExecFileFn$1 as ExecFileFn, type FromConfigOptions, GateNotReadyError, type GateResult, GateRunError, type HarnessSpawn, type Highlight, type HighlightsInfo, type IndexedDoc, InteractionQueue, LinearGraphQLClient, type LinearGraphQLClientOptions, type LinearGraphQLExtension, LinearGraphQLStub, type LiveSession, LocalModelResolver, type LocalModelResolverOptions, MAINTENANCE_CHECK_MAX_BUFFER, MAINTENANCE_CHECK_TIMEOUT_MS, MAX_ATTEMPTS, MaintenanceReporter, type MaintenanceReporterOptions, type MigrationResult, MockBackend, type NotificationSink, type NotificationSinkDeliverInput, ORCHESTRATOR_IDENTITY_FILE, Orchestrator, OrchestratorBackendFactory, type OrchestratorBackendFactoryOptions, type OrchestratorContext, type OrchestratorEvent, type OrchestratorState, PRDetector, type PRDetectorLogger, type PRLifecycleManager, type PendingInteraction, type PersistedOutputEntry, PrivacyNoMatch, PromotionError, type PromotionResult, PromptRenderer, type ProposalApprovedData, type ProposalCreatedData, type ProposalRejectedData, type PublishedIndex, type QueueInsertInput, type QueueRow, type QueueStats, RETRY_DELAYS_MS, type RateLimitSnapshot as RateLimitComputeSnapshot, type RateLimitConfig, type RateLimitSnapshot$1 as RateLimitSnapshot, type RegistryEntry, type ReleaseClaimEffect, type ResolverLogger, type RetryEntry, type RetryFiredEvent, RoadmapTrackerAdapter, RoutingConfigSchema, RoutingValueSchema, type RunAttemptPhase, type RunHarnessCheckOptions, type RunMode, type RunOrigin, type RunResult, type RunningEntry, type ScheduleRetryEffect, type SearchOptions, type SelectConstraints, type SideEffect, SinkConfigError, SinkRegistry, type SkillCatalogEntry, SlackSink, type SlackSinkOptions, SqliteSearchIndex, type StallDetectedEvent, type StopEffect, type StreamManifest, StreamRecorder, type SummarizeContext, type SummarizeResult, type SyncMainOptions, type SyncMainResult, type SyncSkipReason, type TaskDefinition, TaskOutputStore, TaskRunner, type TaskRunnerOptions, type TaskSelectionFilter, type TaskType, type TickEvent, TokenStore, type TokenTotals, type TriageConfig, type TriageDecision, type TriageSignals, type TriageSkill, type UpdateTokensEffect, type ValidateWorkflowConfigOptions, type ValidatedWorkflowConfig, WebhookQueue, type WorkerExitEvent, WorkflowLoader, type WorkflowRouterDep, WorkspaceHooks, WorkspaceManager, type WorkspaceManagerOptions, applyEvent, artifactPresenceFromIssue, buildArchiveHooks, buildCapabilityRegistry, buildWorkflowContext, calculateRetryDelay, canDispatch, classifyCheckExecutionFailure, computeRateLimitDelay, createAgentDispatcher, createBackend, createEmptyState, crossFieldRoutingIssues, defaultFetchModels, defaultPoolCapabilities, deriveSeedPaths, detectScopeTier, discoverSkillCatalog, discoverSkillCatalogNames, emitProposalApproved, emitProposalCreated, emitProposalRejected, estimateCost, explicitFindingsCount, extractHighlights, extractTitlePrefix, getAvailableSlots, getDefaultConfig, getPerStateCount, indexSessionDirectory, isCheckTimeoutError, isEligible, isSummaryEnabled, launchTUI, loadPublishedIndex, makeBackendResolver, migrateAgentConfig, normalizeFts5Query, normalizeHarnessCommand, normalizeLocalModel, openSearchIndex, promote, reconcile, recoverFindingsCount, reindexFromArchive, renderAnalysisComment, renderLlmSummaryMarkdown, renderPRComment, resolveEscalationConfig, resolveOrchestratorId, routeIssue, routingWarnings, runGate, runHarnessCheck, savePublishedIndex, searchIndexPath, selectCandidates, selectCheapestQualifying, selectTasks, sortCandidates, summarizeArchivedSession, syncMain, triageIssue, truncateForBudget, validateCustomTasks, validateWorkflowConfig, wireNotificationSinks, workflowFor, wrapAsEnvelope };
+export { AdaptiveRouter, type AdaptiveRouterDeps, type AgentDispatchResult, type AgentDispatcher, type AgentDispatcherDeps, type AgentUpdateEvent, AnalysisArchive, type AnalysisRecord, type ApplyEventResult, type ArtifactPresence, type AttemptStats, BRAINSTORM_RUBRIC, BUILT_IN_TASKS, BackendDefSchema, type BackendResolver, BackendRouter, type BackendRouterOptions, type BaseRefFallbackEvent, type BrainstormWiringDeps, type BuildArchiveHooksOptions, type BuildWorkflowContextDeps, type CheckCommandResult, type CheckCommandRunner, type CheckFailureClassification, type CheckFailureKind, CheckScriptRunner, ClaimManager, type ClaimManagerConfig, type CleanWorkspaceEffect, type CommandExecResult, type CommandExecutor, type CreateTokenInput, type CreateTokenResult, type CustomTaskValidationError, type DispatchEffect, type EmitLogEffect, type EscalateEffect, EscalationState, type ExecFileAsyncFn, type ExecFileError, type ExecFileFn$1 as ExecFileFn, type FromConfigOptions, GateNotReadyError, type GateResult, GateRunError, type HarnessSpawn, type Highlight, type HighlightsInfo, type IndexedDoc, InteractionQueue, LinearGraphQLClient, type LinearGraphQLClientOptions, type LinearGraphQLExtension, LinearGraphQLStub, type LiveSession, LocalModelResolver, type LocalModelResolverOptions, MAINTENANCE_CHECK_MAX_BUFFER, MAINTENANCE_CHECK_TIMEOUT_MS, MAX_ATTEMPTS, MaintenanceReporter, type MaintenanceReporterOptions, type MarkSkip, type MarkSkipReason, type MigrationResult, MockBackend, type NotificationSink, type NotificationSinkDeliverInput, ORCHESTRATOR_IDENTITY_FILE, Orchestrator, OrchestratorBackendFactory, type OrchestratorBackendFactoryOptions, type OrchestratorContext, type OrchestratorEvent, type OrchestratorState, PRDetector, type PRDetectorLogger, type PRLifecycleManager, type PendingInteraction, type PersistedOutputEntry, PrivacyNoMatch, PromotionError, type PromotionResult, PromptRenderer, type ProposalApprovedData, type ProposalCreatedData, type ProposalRejectedData, type PublishedIndex, type QueueInsertInput, type QueueRow, type QueueStats, RETRY_DELAYS_MS, type RateLimitSnapshot as RateLimitComputeSnapshot, type RateLimitConfig, type RateLimitSnapshot$1 as RateLimitSnapshot, type RecordPrediction, type RegistryEntry, type ReleaseClaimEffect, type ResolverLogger, type RetryEntry, type RetryFiredEvent, RoadmapTrackerAdapter, RoutingConfigSchema, RoutingValueSchema, type RunAttemptPhase, type RunHarnessCheckOptions, type RunMode, type RunOrigin, type RunResult, type RunningEntry, type ScheduleRetryEffect, type SearchOptions, type SelForkGeneratorOptions, type SelectConstraints, type SideEffect, SinkConfigError, SinkRegistry, type SkillCatalogEntry, SlackSink, type SlackSinkOptions, SqliteSearchIndex, type StallDetectedEvent, type StopEffect, type StoredOutcomeRecord, type StreamManifest, StreamRecorder, type SummarizeContext, type SummarizeResult, type SyncMainOptions, type SyncMainResult, type SyncSkipReason, type TaskDefinition, TaskOutputStore, TaskRunner, type TaskRunnerOptions, type TaskSelectionFilter, type TaskType, type TickEvent, TokenStore, type TokenTotals, type TriageConfig, type TriageDecision, type TriageMarkConfig, type TriageMarkDeps, type TriageMarkItem, type TriageMarkResult, type TriageSignals, type TriageSkill, type TriageWiringDeps, type UpdateTokensEffect, type ValidateWorkflowConfigOptions, type ValidatedWorkflowConfig, WebhookQueue, type WiredBrainstormResult, type WorkerExitEvent, WorkflowLoader, type WorkflowRouterDep, WorkspaceHooks, WorkspaceManager, type WorkspaceManagerOptions, applyEvent, artifactPresenceFromIssue, brainstormInputFromIssue, buildArchiveHooks, buildCapabilityRegistry, buildProbeInput, buildWorkflowContext, calculateRetryDelay, canDispatch, classifyCheckExecutionFailure, computeRateLimitDelay, createAgentDispatcher, createBackend, createEmptyState, crossFieldRoutingIssues, defaultFetchModels, defaultPoolCapabilities, deriveSeedPaths, detectScopeTier, discoverSkillCatalog, discoverSkillCatalogNames, emitProposalApproved, emitProposalCreated, emitProposalRejected, enrichIssueWithSpec, estimateCost, explicitFindingsCount, extractHighlights, extractTitlePrefix, getAvailableSlots, getDefaultConfig, getPerStateCount, indexSessionDirectory, isCheckTimeoutError, isEligible, isSummaryEnabled, launchTUI, loadPublishedIndex, makeBackendResolver, makeGraphScope, makeSelForkGenerator, markApprovedForDispatch, migrateAgentConfig, normalizeFts5Query, normalizeHarnessCommand, normalizeLocalModel, openSearchIndex, precedentLookupFromStored, promote, reconcile, recoverFindingsCount, reindexFromArchive, renderAnalysisComment, renderLlmSummaryMarkdown, renderPRComment, renderSpecMarkdown, resolveEscalationConfig, resolveOrchestratorId, routeIssue, routingWarnings, runBrainstormForIssue, runGate, runHarnessCheck, savePublishedIndex, searchIndexPath, selectCandidates, selectCheapestQualifying, selectTasks, slugFor, sortCandidates, summarizeArchivedSession, syncMain, triageIssue, truncateForBudget, validateCustomTasks, validateWorkflowConfig, wireNotificationSinks, workflowFor, wrapAsEnvelope };