nexus-agents 2.131.0 → 2.132.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import { ZodError, z, ZodType, ZodSafeParseResult } from 'zod';
-import { C as CliNameLiteral, I as InputModality, O as OutputModality, T as ToolCapability, S as SpecialFeature, P as Pricing, Q as QualityScores, M as ModelId, V as VotingStrategy } from './consensus-vote-types-DdruG9-X.js';
-export { A as AgentVoteSummary, a as ConsensusVoteInput, b as ConsensusVoteInputSchema, c as ConsensusVoteResponse, d as VoteDecisionStatus } from './consensus-vote-types-DdruG9-X.js';
+import { C as CliNameLiteral, I as InputModality, O as OutputModality, T as ToolCapability, S as SpecialFeature, P as Pricing, Q as QualityScores, M as ModelId, D as DecisionCostSummary, V as VotingStrategy } from './consensus-vote-types-CYBHW8vY.js';
+export { A as AgentVoteSummary, a as ConsensusVoteInput, b as ConsensusVoteInputSchema, c as ConsensusVoteResponse, d as VoteDecisionStatus } from './consensus-vote-types-CYBHW8vY.js';
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
 
@@ -12111,9 +12111,9 @@ declare const BuiltInExpertTypeSchema: z.ZodEnum<{
     testing: "testing";
     devops: "devops";
     infrastructure: "infrastructure";
+    qa: "qa";
     pm: "pm";
     ux: "ux";
-    qa: "qa";
     "data-visualization": "data-visualization";
 }>;
 /**
@@ -14208,8 +14208,8 @@ declare const SkillLoaderConfigSchema: z.ZodObject<{
             "code-generation": "code-generation";
             observability: "observability";
             database: "database";
-            refactoring: "refactoring";
             deployment: "deployment";
+            refactoring: "refactoring";
             "file-operations": "file-operations";
             "code-analysis": "code-analysis";
             "coding-standards": "coding-standards";
@@ -14228,8 +14228,8 @@ declare const SkillLoaderConfigSchema: z.ZodObject<{
             "code-generation": "code-generation";
             observability: "observability";
             database: "database";
-            refactoring: "refactoring";
             deployment: "deployment";
+            refactoring: "refactoring";
             "file-operations": "file-operations";
             "code-analysis": "code-analysis";
             "coding-standards": "coding-standards";
@@ -15521,11 +15521,11 @@ type ExplorationEventType = 'tree_created' | 'node_created' | 'node_activated' |
  * Schema for ExplorationEventType validation.
  */
 declare const ExplorationEventTypeSchema: z.ZodEnum<{
+    node_completed: "node_completed";
     tree_created: "tree_created";
     node_created: "node_created";
     node_activated: "node_activated";
     node_deactivated: "node_deactivated";
-    node_completed: "node_completed";
     node_pruned: "node_pruned";
     path_scored: "path_scored";
     cross_tree_share: "cross_tree_share";
@@ -15555,11 +15555,11 @@ interface ExplorationEvent {
 declare const ExplorationEventSchema: z.ZodObject<{
     timestamp: z.ZodNumber;
     eventType: z.ZodEnum<{
+        node_completed: "node_completed";
         tree_created: "tree_created";
         node_created: "node_created";
         node_activated: "node_activated";
         node_deactivated: "node_deactivated";
-        node_completed: "node_completed";
         node_pruned: "node_pruned";
         path_scored: "path_scored";
         cross_tree_share: "cross_tree_share";
@@ -15697,11 +15697,11 @@ declare const ForestResultSchema: z.ZodObject<{
     explorationHistory: z.ZodOptional<z.ZodArray<z.ZodObject<{
         timestamp: z.ZodNumber;
         eventType: z.ZodEnum<{
+            node_completed: "node_completed";
             tree_created: "tree_created";
             node_created: "node_created";
             node_activated: "node_activated";
             node_deactivated: "node_deactivated";
-            node_completed: "node_completed";
             node_pruned: "node_pruned";
             path_scored: "path_scored";
             cross_tree_share: "cross_tree_share";
@@ -18346,8 +18346,52 @@ declare const AuditCategorySchema: z.ZodEnum<{
     tool_invocation: "tool_invocation";
     data_access: "data_access";
     data_modification: "data_modification";
+    governance: "governance";
 }>;
 type AuditCategory = z.infer<typeof AuditCategorySchema>;
+/**
+ * The two directions a loop can move on the authority ladder (ADR-0017
+ * §"Transition Rules"). A `promotion` moves UP a tier and is invalid without a
+ * linked ratification vote; a `demotion` moves DOWN and is automatic (needs no
+ * vote). The ratification gate (`scripts/check-authority-tier-drift.ts`) keys
+ * off this kind: a `promotion` event lacking `ratificationVoteRef` FAILS the
+ * gate, a `demotion` does not.
+ */
+declare const TierTransitionKindSchema: z.ZodEnum<{
+    promotion: "promotion";
+    demotion: "demotion";
+}>;
+type TierTransitionKind = z.infer<typeof TierTransitionKindSchema>;
+/**
+ * The authority tier vocabulary, mirrored from
+ * `orchestration/strategy-manifest.ts` `AuthorityTierSchema`. Declared here so
+ * the audit module has no dependency on the orchestration layer (the audit log
+ * is the lower layer). A drift between the two enums is caught by the audit
+ * tier-transition tests, which round-trip every tier through the emitter.
+ */
+declare const TierTransitionTierSchema: z.ZodEnum<{
+    enforce: "enforce";
+    observe: "observe";
+    suggest: "suggest";
+    advisory: "advisory";
+}>;
+type TierTransitionTier = z.infer<typeof TierTransitionTierSchema>;
+/**
+ * Options for {@link IAuditLogger.logTierTransition}. The `actor` defaults to the
+ * system actor at the emission site when omitted (a tier change recorded by the
+ * evidence ledger is a system event).
+ */
+interface TierTransitionAuditOpts {
+    kind: TierTransitionKind;
+    subject: string;
+    fromTier: TierTransitionTier;
+    toTier: TierTransitionTier;
+    evidenceRef: string;
+    ratificationVoteRef?: string | undefined;
+    actor?: AuditActor | undefined;
+    requestId?: string | undefined;
+    metadata?: Record<string, unknown> | undefined;
+}
 declare const AuditSeveritySchema: z.ZodEnum<{
     info: "info";
     warning: "warning";
@@ -18395,6 +18439,7 @@ declare const AuditEventSchema: z.ZodObject<{
         tool_invocation: "tool_invocation";
         data_access: "data_access";
         data_modification: "data_modification";
+        governance: "governance";
     }>;
     severity: z.ZodEnum<{
         info: "info";
@@ -18438,6 +18483,7 @@ declare const AuditEventSchema: z.ZodObject<{
     violationType: z.ZodOptional<z.ZodString>;
     previousHash: z.ZodOptional<z.ZodString>;
     hash: z.ZodOptional<z.ZodString>;
+    hashVersion: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
 type AuditEvent$1 = z.infer<typeof AuditEventSchema>;
 declare const AuditEventInputSchema: z.ZodObject<{
@@ -18450,6 +18496,7 @@ declare const AuditEventInputSchema: z.ZodObject<{
         tool_invocation: "tool_invocation";
         data_access: "data_access";
         data_modification: "data_modification";
+        governance: "governance";
     }>;
     severity: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
         info: "info";
@@ -18516,6 +18563,7 @@ declare const AuditLogConfigSchema: z.ZodObject<{
         tool_invocation: "tool_invocation";
         data_access: "data_access";
         data_modification: "data_modification";
+        governance: "governance";
     }>>>;
 }, z.core.$strip>;
 type AuditLogConfig = z.infer<typeof AuditLogConfigSchema>;
@@ -18541,6 +18589,7 @@ declare const AuditQueryCriteriaSchema: z.ZodObject<{
         tool_invocation: "tool_invocation";
         data_access: "data_access";
         data_modification: "data_modification";
+        governance: "governance";
     }>>>;
     severities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
         info: "info";
@@ -18572,6 +18621,8 @@ interface IAuditLogger {
     logSecurityEvent(opts: SecurityEventAuditOpts): void;
     /** Log a rate limit violation */
     logRateLimitViolation(opts: RateLimitAuditOpts): void;
+    /** Log an authority-tier transition (promotion/demotion) — Epic D, #3842. */
+    logTierTransition(opts: TierTransitionAuditOpts): void;
     /** Flush pending events */
     flush(): Promise<void>;
     /** Close the logger */
@@ -19471,6 +19522,138 @@ interface IEventBus {
     readonly bufferSize: number;
 }
 
+/**
+ * decision-cost-store — durable per-decision cost rollups.
+ *
+ * Source: Issue #3855 (epic #3854 child, M4).
+ *
+ * Persists one {@link DecisionCostRecord} per governed decision (a
+ * `consensus_vote` / `pr_review` run) so the question "what did this decision
+ * cost?" can be answered from recorded data later — feeding Epic G's
+ * weather_report / manifest cost profiles (#3856) and the governed-decision
+ * cost doc (#3857).
+ *
+ * Mirrors the established persistence idiom: it reuses the shared
+ * {@link JsonlStore} primitive ({@link module:config/jsonl-store}, #3762) rather
+ * than re-forking the hydrate/append/rotate fs plumbing, and writes under the
+ * shared learning dir like {@link module:orchestration/outcomes/outcome-store}.
+ * Record + measure ONLY — no routing or weighting change (#3855 acceptance).
+ *
+ * @module observability/decision-cost-store
+ */
+
+/** Decision surface that incurred the cost — the gate type (#3854). */
+declare const DecisionGateSchema: z.ZodEnum<{
+    consensus_vote: "consensus_vote";
+    pr_review: "pr_review";
+}>;
+type DecisionGate = z.infer<typeof DecisionGateSchema>;
+/** One persisted per-decision cost rollup. */
+declare const DecisionCostRecordSchema: z.ZodObject<{
+    decisionId: z.ZodString;
+    gate: z.ZodEnum<{
+        consensus_vote: "consensus_vote";
+        pr_review: "pr_review";
+    }>;
+    timestamp: z.ZodString;
+    summary: z.ZodObject<{
+        billingMode: z.ZodEnum<{
+            plan: "plan";
+            api: "api";
+        }>;
+        voterCount: z.ZodNumber;
+        measuredVoters: z.ZodNumber;
+        unmeasuredVoters: z.ZodNumber;
+        totalInputTokens: z.ZodNumber;
+        totalOutputTokens: z.ZodNumber;
+        totalTokens: z.ZodNumber;
+        totalCostUsd: z.ZodNumber;
+        perVoter: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            role: z.ZodString;
+            model: z.ZodString;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+            unmeasured: z.ZodBoolean;
+        }, z.core.$strip>>>;
+        perModel: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            model: z.ZodString;
+            voterCount: z.ZodNumber;
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            totalTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type DecisionCostRecord = z.infer<typeof DecisionCostRecordSchema>;
+
+/**
+ * decision-cost-aggregate — windowed CROSS-decision cost rollups by gate type.
+ *
+ * Source: Issue #3856 (epic #3854 child, M4).
+ *
+ * Where {@link module:observability/decision-cost} rolls N voters UP into one
+ * per-decision summary, this module rolls N *decisions* up into one per-GATE
+ * answer: "across the recent window, what does a `consensus_vote` / `pr_review`
+ * decision cost on average?". It is the aggregation `weather_report` surfaces
+ * (#3856) so an operator sees what governed decisions are costing without a new
+ * MCP tool — the report reads the {@link DecisionCostStore}'s persisted records
+ * and folds them through this PURE function.
+ *
+ * Pure and deterministic: no I/O, no clock, no env reads. The caller supplies
+ * the records (already windowed/queried) and this returns the per-gate averages.
+ * Averages are reported alongside the decision count and the measured/unmeasured
+ * voter split so a reader knows the confidence — a per-gate average is a FLOOR
+ * when unmeasured voters contributed (their unknown real cost counts as 0), the
+ * same honesty {@link module:observability/decision-cost} keeps per-decision.
+ *
+ * @module observability/decision-cost-aggregate
+ */
+
+/** Per-gate windowed cost aggregate surfaced in the weather report (#3856). */
+interface GateCostAggregate {
+    /** Which gate type these decisions came from. */
+    readonly gate: DecisionGate;
+    /** Number of decisions folded in. */
+    readonly decisionCount: number;
+    /** Mean total cost (USD) per decision over the window. */
+    readonly avgCostUsd: number;
+    /** Mean total tokens per decision over the window. */
+    readonly avgTokens: number;
+    /** Mean number of voters per decision. */
+    readonly avgVoters: number;
+    /** Sum of cost (USD) across all decisions in the window. */
+    readonly totalCostUsd: number;
+    /** Sum of tokens across all decisions in the window. */
+    readonly totalTokens: number;
+    /**
+     * Total voters that reported usage across the window. With `unmeasuredVoters`
+     * this is the confidence signal: the averages are a FLOOR when
+     * `unmeasuredVoters > 0` (unmeasured voters contribute 0, not their real cost).
+     */
+    readonly measuredVoters: number;
+    /** Total voters that reported no usage across the window. */
+    readonly unmeasuredVoters: number;
+    /**
+     * True when `unmeasuredVoters > 0` — the averages understate true spend
+     * because some voter calls reported no usage and were folded in as 0.
+     */
+    readonly costIsFloor: boolean;
+}
+/** The decision-cost section of the weather report (#3856). */
+interface DecisionCostReport {
+    /** Lookback window the records were drawn from, in ms (0 ⇒ all history). */
+    readonly windowMs: number;
+    /** Per-gate-type aggregates, sorted by total cost desc then gate name. */
+    readonly byGate: readonly GateCostAggregate[];
+    /** Total decisions across all gates in the window. */
+    readonly totalDecisions: number;
+    /** Total cost (USD) across all gates in the window. */
+    readonly totalCostUsd: number;
+}
+
 /**
  * nexus-agents/observability - Dashboard Types
  *
@@ -21806,12 +21989,12 @@ declare function selectModel(input: DelegateInput, requirements: TaskRequirement
  * - higher_order: alias for opinion_wise (Issue #514)
  */
 declare const ConsensusAlgorithmSchema: z.ZodEnum<{
+    higher_order: "higher_order";
     simple_majority: "simple_majority";
     supermajority: "supermajority";
     unanimous: "unanimous";
     proof_of_learning: "proof_of_learning";
     opinion_wise: "opinion_wise";
-    higher_order: "higher_order";
 }>;
 type ConsensusAlgorithm = z.infer<typeof ConsensusAlgorithmSchema>;
 /**
@@ -21914,12 +22097,12 @@ declare const ProposalSchema: z.ZodObject<{
     title: z.ZodString;
     description: z.ZodString;
     algorithm: z.ZodEnum<{
+        higher_order: "higher_order";
         simple_majority: "simple_majority";
         supermajority: "supermajority";
         unanimous: "unanimous";
         proof_of_learning: "proof_of_learning";
         opinion_wise: "opinion_wise";
-        higher_order: "higher_order";
     }>;
     timeout: z.ZodOptional<z.ZodNumber>;
     requiredVoters: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -21975,12 +22158,12 @@ declare const ConsensusResultSchema: z.ZodObject<{
         title: z.ZodString;
         description: z.ZodString;
         algorithm: z.ZodEnum<{
+            higher_order: "higher_order";
             simple_majority: "simple_majority";
             supermajority: "supermajority";
             unanimous: "unanimous";
             proof_of_learning: "proof_of_learning";
             opinion_wise: "opinion_wise";
-            higher_order: "higher_order";
         }>;
         timeout: z.ZodOptional<z.ZodNumber>;
         requiredVoters: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -22195,12 +22378,12 @@ declare const ConsensusMetricsSchema: z.ZodObject<{
     averageDurationMs: z.ZodNumber;
     averageVotesPerProposal: z.ZodNumber;
     algorithmUsage: z.ZodRecord<z.ZodEnum<{
+        higher_order: "higher_order";
         simple_majority: "simple_majority";
         supermajority: "supermajority";
         unanimous: "unanimous";
         proof_of_learning: "proof_of_learning";
         opinion_wise: "opinion_wise";
-        higher_order: "higher_order";
     }>, z.ZodNumber>;
 }, z.core.$strip>;
 
@@ -22547,6 +22730,25 @@ interface AgentVoteResult {
     readonly source: 'llm' | 'simulation' | 'error';
     /** CLI that executed this vote (for adaptive routing feedback). */
     readonly cli?: string | undefined;
+    /**
+     * Model id that executed this vote, when known (e.g. 'claude-sonnet'). Carried
+     * so per-decision cost aggregation can attribute spend per model (#3855). Absent
+     * for error/simulation votes that never reached a model.
+     */
+    readonly model?: string | undefined;
+    /**
+     * Input tokens the adapter reported for this voter's LLM call, when known
+     * (#3910). Propagated from `CompletionResponse.usage` so per-decision cost
+     * aggregation resolves from `unmeasured` to MEASURED. Absent for
+     * error/simulation votes that never reached a model, or for adapters that do
+     * not report usage (CLI subscriptions) — those stay honestly `unmeasured`.
+     */
+    readonly inputTokens?: number | undefined;
+    /**
+     * Output tokens the adapter reported for this voter's LLM call, when known
+     * (#3910). See {@link AgentVoteResult.inputTokens}.
+     */
+    readonly outputTokens?: number | undefined;
     /** Error message if vote fell back to simulation or encountered an error */
     readonly error?: string;
 }
@@ -24776,7 +24978,7 @@ declare const ImprovementReviewInputSchema: z.ZodObject<{
     selfEvalReportPath: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type ImprovementReviewInput = z.infer<typeof ImprovementReviewInputSchema>;
-type SignalCategory = 'routing' | 'tech-debt' | 'bug' | 'security' | 'consensus';
+type SignalCategory = 'routing' | 'tech-debt' | 'bug' | 'security' | 'consensus' | 'tool-fitness';
 interface ImprovementSignal {
     readonly category: SignalCategory;
     /** Stable key used for dedup against existing issues. */
@@ -24828,102 +25030,461 @@ declare function registerImprovementReviewTool(server: McpServer, deps: Improvem
  * (Source: Issue #865 — Weather report with adaptive routing)
  */
 
-type WeatherReportDeps = BaseMcpToolDeps;
+type WeatherReportDeps$1 = BaseMcpToolDeps;
 /** @category MCP */
-declare function registerWeatherReportTool(server: McpServer, deps: WeatherReportDeps): void;
+declare function registerWeatherReportTool(server: McpServer, deps: WeatherReportDeps$1): void;
 
 /**
- * Type definitions for the Weather Report MCP tool.
+ * nexus-agents/orchestration - Strategy Manifest schema + loader.
  *
- * Surfaces observed model performance as a living "weather report"
- * and computes adaptive routing bonuses from outcome data.
+ * The strategy-manifest registry (`governance/strategy-manifests.yaml`) is the
+ * single source of truth describing each routable execution strategy: which
+ * engine fronts it, whether it has a wired executor, when to force it, and the
+ * forward-compat governance (authority tier — Epic D) and cost (Epic G) fields.
+ * The MetaOrchestrator routes purely over manifest data — adding a capability
+ * becomes "register a manifest", not "edit the router" (Epic C, #3833).
  *
- * @module mcp/tools/weather-report-types
- * (Source: Issue #865 — Weather report with adaptive routing)
+ * This module owns ONLY the schema + loader/validator (child #3834). It MIRRORS
+ * the claims-registry pattern (versioned YAML + Zod schema + loader + Vitest) so
+ * a reviewer reasons about both with the same mental model.
+ *
+ * Explicitly deferred to siblings:
+ * - #3835: migrating the 8 live strategies (`STRATEGY_ENTRYPOINT_TOOL`,
+ *   run-tool.ts) to registered manifests + the behaviour-parity golden test.
+ * - #3836: the router refactor that consumes these manifests instead of the
+ *   hardcoded `decideStrategy` rules.
+ * - #3837: drift-gating the registry under `governance:check`.
+ *
+ * @module orchestration/strategy-manifest
+ * (Source: Issue #3833, #3834)
  */
 
-declare const WeatherReportInputSchema: z.ZodObject<{
-    cli: z.ZodOptional<z.ZodEnum<{
-        claude: "claude";
-        gemini: "gemini";
-        codex: "codex";
-        opencode: "opencode";
-    }>>;
-    category: z.ZodOptional<z.ZodEnum<{
-        planning: "planning";
-        architecture: "architecture";
-        code_generation: "code_generation";
-        code_review: "code_review";
-        research: "research";
-        security_review: "security_review";
-        documentation: "documentation";
-        testing: "testing";
-        devops: "devops";
-        exploration: "exploration";
-    }>>;
-    includeAdaptive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, z.core.$strip>;
-/** Options for generateWeatherReport (all fields optional). */
-interface WeatherReportOptions {
-    readonly cli?: CliNameLiteral;
-    readonly category?: string;
-    readonly includeAdaptive?: boolean;
-}
-/** Adapter attempt stats separating infra failures from model-quality failures (#1982). */
-interface AdapterAttemptStats {
-    /**
-     * Success rate excluding adapter_unavailable failures. Represents model-quality
-     * success when the adapter could actually attempt the task. Rounded to 3 decimals.
-     */
-    readonly adapterAttemptSuccessRate: number;
-    /** Count of adapter_unavailable failures in the sample. */
-    readonly adapterUnavailableCount: number;
+/**
+ * Cost profile (Epic G, #3856). A coarse cost hint scaled by a strategy's
+ * fan-out: `low` (one model call), `medium` (templated multi-stage gate), `high`
+ * (N-voter panel / multi-agent orchestration / greenfield build), `variable`
+ * (spend scales with input size — graph topology, research breadth). Populated
+ * for the live 8 manifests by #3856 and surfaced in the weather_report cost
+ * section alongside the measured per-decision aggregates (#3855). Stays optional
+ * on the schema so a future manifest can register before grading its profile.
+ */
+declare const CostProfileSchema: z.ZodEnum<{
+    high: "high";
+    low: "low";
+    medium: "medium";
+    variable: "variable";
+}>;
+type CostProfile = z.infer<typeof CostProfileSchema>;
+
+/**
+ * Pipeline Stage Types — Shared interfaces for graph-backed pipelines (#1735, Phase 2)
+ *
+ * Defines the IPipelineStage interface that all pipeline stages implement.
+ * Stages are wrapped as GraphBuilder NodeHandlers for execution.
+ *
+ * @module pipeline/stage-types
+ */
+/** Read-only pipeline context passed to every stage. */
+interface PipelineContext {
+    /** Unique pipeline execution ID. */
+    readonly executionId: string;
+    /** The original task/prompt that started the pipeline. */
+    readonly task: string;
+    /** Pipeline template being executed. */
+    readonly templateId: string;
     /**
-     * Fraction of total attempts that failed due to adapter_unavailable. Rounded
-     * to 3 decimals. Useful for comparing infra availability across CLIs/categories.
+     * Accumulated state from prior stages. The only cross-stage handoff
+     * channel — `sharedMemory` (the #1764 SharedMemoryStore) was removed
+     * in #2937 after being write-only since introduction. If you need
+     * structured cross-stage data, add a well-known key to
+     * `PIPELINE_STATE_KEYS` and write/read through `state`.
      */
-    readonly adapterUnavailableRate: number;
+    readonly state: Readonly<Record<string, unknown>>;
 }
-/** Per-CLI performance stats in the weather report. */
-interface CliWeather extends AdapterAttemptStats {
-    readonly cli: string;
-    readonly totalTasks: number;
-    readonly successRate: number;
-    readonly avgDurationMs: number;
-    readonly byCategory: ReadonlyMap<string, GroupStats>;
+/** Result of executing a single pipeline stage. */
+interface StageOutput {
+    /** The key to store this stage's output under in pipeline state. */
+    readonly stateKey: string;
+    /** The output value (stored in GraphState). */
+    readonly value: unknown;
+    /** Duration in milliseconds. */
+    readonly durationMs: number;
+    /** Whether the stage succeeded. */
+    readonly success: boolean;
+    /** Error message if failed. */
+    readonly error?: string | undefined;
 }
-/** Adaptive bonus for a CLI+category pair. */
-interface AdaptiveBonus {
-    readonly cli: string;
-    readonly category: TaskCategory;
-    readonly staticBonus: number;
-    readonly adaptiveBonus: number;
-    readonly sampleCount: number;
-    readonly sufficient: boolean;
+/** A pipeline stage that can be compiled into a graph node. */
+interface IPipelineStage {
+    /** Unique stage identifier (used as graph node ID). */
+    readonly id: string;
+    /** Human-readable stage name. */
+    readonly name: string;
+    /** Execute the stage. */
+    execute(context: PipelineContext): Promise<StageOutput>;
 }
-/** Tier recommendation surfaced in the weather report (#895). */
-interface TierRecommendationEntry {
-    readonly category: string;
-    readonly direction: 'promote' | 'demote';
-    readonly currentTier: number;
-    readonly recommendedTier: number;
-    readonly successRate: number;
-    readonly sampleCount: number;
-    readonly reason: string;
+/** Edge definition in a pipeline template. */
+type PipelineEdge = {
+    readonly type: 'fixed';
+    readonly from: string;
+    readonly to: string;
+} | {
+    readonly type: 'conditional';
+    readonly from: string;
+    readonly routerKey: string;
+    readonly targets: readonly string[];
+};
+/** A declarative pipeline template defining stages and their connections. */
+interface PipelineTemplate {
+    /** Unique template identifier. */
+    readonly id: string;
+    /** Human-readable name. */
+    readonly name: string;
+    /** Ordered stage IDs (for simple linear pipelines). */
+    readonly stages: readonly string[];
+    /** Edge overrides (for non-linear flows like vote→plan feedback loops). */
+    readonly edges?: readonly PipelineEdge[] | undefined;
+    /** Stage IDs that can be skipped via dryRun. */
+    readonly dryRunStopAfter?: string | undefined;
 }
-/** Learning insight for a CLI+category pair (Issue #901, Phase 4). */
-interface LearningInsight {
-    readonly cli: string;
-    readonly category: TaskCategory;
-    readonly trend: 'improving' | 'declining' | 'stable';
-    readonly confidence: number;
-    readonly adjustedBaseline: number;
-    readonly sampleCount: number;
+/** Standard state keys used across pipeline templates. */
+declare const PIPELINE_STATE_KEYS: {
+    readonly TASK: "task";
+    readonly RESEARCH: "research";
+    readonly PLAN: "plan";
+    readonly VOTE_RESULT: "voteResult";
+    readonly VOTE_FEEDBACK: "voteFeedback";
+    readonly VOTE_ITERATIONS: "voteIterations";
+    readonly TASKS: "tasks";
+    readonly IMPLEMENTATIONS: "implementations";
+    readonly QA_ITERATIONS: "qaIterations";
+    readonly SECURITY_PASSED: "securityPassed";
+    readonly FINDINGS: "findings";
+    readonly PARSED_SPEC: "parsedSpec";
+    readonly SCAFFOLD_OUTPUT: "scaffoldOutput";
+    readonly COMPLETED: "completed";
+};
+
+/**
+ * Pipeline Graph Compiler — Build executable graphs from templates (#1735, Phase 2)
+ *
+ * Compiles a PipelineTemplate + IPipelineStage implementations into a
+ * CompiledGraph that can be executed by the GraphExecutor.
+ *
+ * @module pipeline/pipeline-graph
+ */
+
+/** Result of compiling a pipeline template into a graph. */
+interface PipelineGraphResult {
+    readonly ok: boolean;
+    readonly graph?: CompiledGraph | undefined;
+    readonly error?: string | undefined;
 }
-/** Recommended CLI→category mapping for LinUCB cold-start (Epic #952, Phase 6). */
-interface RecommendedMapping {
-    readonly category: TaskCategory;
-    readonly recommendedCli: string;
+/** Map of stage ID → stage implementation. */
+type StageRegistry = ReadonlyMap<string, IPipelineStage>;
+/**
+ * Compile a pipeline template + stages into an executable graph.
+ *
+ * Each IPipelineStage is wrapped as a GraphBuilder node handler.
+ * Linear edges are auto-generated from template.stages order.
+ * Custom edges override the linear flow for feedback loops.
+ */
+declare function compilePipelineGraph(template: PipelineTemplate, stages: StageRegistry): PipelineGraphResult;
+
+/**
+ * Graph Pipeline Runner — Execute pipelines via GraphBuilder (#1735, Phase 2)
+ *
+ * Provides a runGraphPipeline() function that compiles a PipelineTemplate
+ * + stage registry into an executable graph and runs it through the
+ * graph executor with checkpoint/resume support.
+ *
+ * @module pipeline/graph-pipeline-runner
+ */
+
+/** Options for graph-based pipeline execution. */
+interface GraphPipelineOptions {
+    /** When true, stop after the dryRunStopAfter stage. */
+    readonly dryRun?: boolean | undefined;
+    /** Maximum graph execution steps (default: 20). */
+    readonly maxSteps?: number | undefined;
+}
+/** Result of a graph-based pipeline execution. */
+interface GraphPipelineResult {
+    readonly success: boolean;
+    readonly templateId: string;
+    readonly stepsExecuted: number;
+    readonly durationMs: number;
+    readonly finalState: Readonly<Record<string, unknown>>;
+    readonly error?: string | undefined;
+}
+/**
+ * Run a pipeline using graph-based execution.
+ *
+ * Compiles the template + stages into a graph, then executes via
+ * the graph executor (super-step BSP model).
+ */
+declare function runGraphPipeline(task: string, template: PipelineTemplate, stages: StageRegistry, options?: GraphPipelineOptions): Promise<GraphPipelineResult>;
+/** Extract a value from the final pipeline state. */
+declare function extractStateValue(state: Readonly<Record<string, unknown>>, key: string): unknown;
+
+/**
+ * Adaptive Orchestrator — Task-driven pipeline selection (#1736, Phase 3)
+ *
+ * Analyzes incoming tasks, selects the appropriate pipeline template,
+ * and executes via the graph pipeline runner. Single entry point
+ * for all pipeline types.
+ *
+ * Design pattern: deterministic state machine backbone + selective
+ * LLM invocation at decision nodes only (per CrewAI Flows / Temporal).
+ *
+ * @module pipeline/adaptive-orchestrator
+ */
+
+/** Options for the adaptive orchestrator. */
+interface AdaptiveOrchestratorOptions extends GraphPipelineOptions {
+    /** Force a specific template (skip auto-detection). */
+    readonly templateId?: string | undefined;
+    /** Stage registry to use. If omitted, stages must be provided per-template. */
+    readonly stages: StageRegistry;
+}
+/** Result of adaptive orchestration — extends GraphPipelineResult with metadata. */
+interface AdaptiveOrchestratorResult extends GraphPipelineResult {
+    /** How the template was selected. */
+    readonly selectionMethod: 'explicit' | 'auto-detected';
+    /** Task classification used for selection. */
+    readonly taskClassification: TaskClassification;
+}
+/** Classification of a task for template routing. */
+interface TaskClassification {
+    readonly pipelineType: PipelineType;
+    readonly complexity: 'simple' | 'moderate' | 'complex';
+    readonly confidence: number;
+    readonly keywords: readonly string[];
+}
+/** Pipeline type derived from task analysis. */
+type PipelineType = 'dev' | 'research' | 'audit' | 'greenfield' | 'general';
+/** Classify a task for pipeline routing. */
+declare function classifyTask(task: string): TaskClassification;
+/**
+ * Run the adaptive orchestrator — classify task, select template, execute.
+ *
+ * This is the single entry point for all pipeline execution.
+ */
+declare function runAdaptiveOrchestrator(task: string, options: AdaptiveOrchestratorOptions): Promise<AdaptiveOrchestratorResult>;
+
+/**
+ * nexus-agents/orchestration - Workflow Pattern Router
+ *
+ * Intelligent orchestration pattern selection based on task characteristics.
+ * Uses SharedTaskAnalyzer signals + caller hints to select the optimal
+ * workflow pattern (sequential, wave, graph, consensus, aflow, puppeteer).
+ *
+ * v1: Rule-based only (per consensus vote — no ML/RL yet).
+ *
+ * @module orchestration/workflow-router
+ * (Source: Issue #844 — Intelligent Workflow Pattern Router)
+ */
+
+/**
+ * Creates a workflow pattern router.
+ *
+ * Analyzes task characteristics and selects the optimal orchestration
+ * pattern using a rule-based classification system.
+ *
+ * Scope of `recordOutcome` / `getMetrics` (#2824): the recorded
+ * `PatternOutcome`s live in a buffer owned by this router instance.
+ * `route()` is a deterministic, rule-based classifier — it does NOT
+ * consume recorded outcomes, so there is no per-instance learning to
+ * "lose", and nothing to aggregate across processes. The pair is an
+ * observability surface only. If cross-process pattern metrics are
+ * ever needed, add a dedicated consumer that writes to a shared
+ * `OutcomeStore` rather than widening this router's responsibility.
+ */
+declare function createWorkflowRouter(options?: {
+    readonly logger?: ILogger | undefined;
+    readonly analyzer?: ISharedTaskAnalyzer | undefined;
+}): IWorkflowRouter;
+/** Public interface for the workflow router. */
+interface IWorkflowRouter {
+    /** Routes a task to the optimal workflow pattern. */
+    route(signals: TaskSignals, options?: WorkflowRouterOptions): RoutingDecision$1;
+    /**
+     * Records an execution outcome into this router instance's buffer.
+     * Observability only — `route()` never reads it back (#2824).
+     */
+    recordOutcome(outcome: PatternOutcome): void;
+    /** Aggregates this instance's recorded outcomes, optionally filtered by pattern. */
+    getMetrics(pattern?: WorkflowPattern): readonly PatternMetrics[];
+}
+
+/**
+ * nexus-agents/orchestration - MetaOrchestrator (adaptive selection tier)
+ *
+ * One adaptive entry point that, given a goal, SELECTS the right execution
+ * strategy among the existing specialized pipelines — it routes once per task,
+ * it does NOT switch patterns mid-flight and it does NOT execute anything
+ * itself. This is the "routing" pattern (Anthropic, Building Effective Agents):
+ * classify → dispatch to a specialized pipeline, rather than a generalist
+ * mega-pipeline.
+ *
+ * Step 1 (#3549) is a pure, deterministic selection function. It reuses the
+ * existing selection brains — `SharedTaskAnalyzer` (signals), `WorkflowRouter`
+ * (execution pattern), and `classifyTask` (pipeline template) — and maps their
+ * combined output to a single {@link ExecutionStrategy}. Dispatch wiring,
+ * decision logging, and learned selection are later steps of epic #3548.
+ *
+ * @module orchestration/meta-orchestrator
+ * (Source: Issue #3549 — MetaOrchestrator step 1)
+ */
+
+/**
+ * Execution strategies the MetaOrchestrator can select. Each maps to an
+ * existing entry point / engine — the MetaOrchestrator does not introduce a
+ * new execution path, it chooses among the ones that already exist.
+ */
+type ExecutionStrategy = 
+/** Trivial single-step task → `delegate_to_model`. */
+'single-shot'
+/** Code change with the dev gate (test/lint/typecheck) → `run_dev_pipeline`. */
+ | 'dev-pipeline'
+/** Multi-stage templated work (audit/general) → `run_pipeline`. */
+ | 'pipeline'
+/** DAG / conditional-edge workflow → `run_graph_workflow`. */
+ | 'graph-workflow'
+/** Pattern-based multi-agent orchestration (wave/aflow/puppeteer) → `orchestrate`. */
+ | 'orchestrate'
+/** Multi-perspective decision → `consensus_vote`. */
+ | 'consensus'
+/** Greenfield project from a spec → `execute_spec`. */
+ | 'spec'
+/** Research-heavy work → the research pipeline. */
+ | 'research';
+
+/**
+ * nexus-agents/orchestration - Strategy manifest registry (the live 8 manifests).
+ *
+ * The runtime source of truth for the eight routable execution strategies. This
+ * REPLACES the former hardcoded `STRATEGY_ENTRYPOINT_TOOL` map in run-tool.ts
+ * (#3835): the entrypoint-tool and executor-availability lookups the run path
+ * needs are now DATA, read from a validated manifest registry rather than a
+ * literal map embedded in the tool layer.
+ *
+ * The manifests are embedded here as a typed constant (no disk I/O on the MCP
+ * hot path) and validated through {@link parseStrategyManifestRegistry} AT MODULE
+ * LOAD — a malformed registry fails closed at import time, exactly as the
+ * disk-loaded path would. The companion `governance/strategy-manifests.yaml` is
+ * the human-facing / docs source of truth (#3838) and the drift-gate target
+ * (#3837); `strategy-manifest-registry.test.ts` asserts the two are equal so
+ * they cannot diverge.
+ *
+ * Out of scope (deferred): the selection-logic refactor that routes PURELY over
+ * this data — `decideStrategy` in meta-orchestrator.ts — is #3836. This module
+ * only relocates the entrypoint/executor lookups off the hardcoded map.
+ *
+ * @module orchestration/strategy-manifest-registry
+ * (Source: Issue #3833, #3835 — schema landed via #3834)
+ */
+
+/** One strategy's declared cost profile, for the weather_report cost section (#3856). */
+interface StrategyCostProfileEntry {
+    readonly strategy: ExecutionStrategy;
+    readonly entrypointTool: string;
+    /** The declared coarse cost hint; undefined for any manifest not yet populated. */
+    readonly costProfile: CostProfile | undefined;
+}
+
+/**
+ * Type definitions for the Weather Report MCP tool.
+ *
+ * Surfaces observed model performance as a living "weather report"
+ * and computes adaptive routing bonuses from outcome data.
+ *
+ * @module mcp/tools/weather-report-types
+ * (Source: Issue #865 — Weather report with adaptive routing)
+ */
+
+declare const WeatherReportInputSchema: z.ZodObject<{
+    cli: z.ZodOptional<z.ZodEnum<{
+        claude: "claude";
+        gemini: "gemini";
+        codex: "codex";
+        opencode: "opencode";
+    }>>;
+    category: z.ZodOptional<z.ZodEnum<{
+        planning: "planning";
+        architecture: "architecture";
+        code_generation: "code_generation";
+        code_review: "code_review";
+        research: "research";
+        security_review: "security_review";
+        documentation: "documentation";
+        testing: "testing";
+        devops: "devops";
+        exploration: "exploration";
+    }>>;
+    includeAdaptive: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+}, z.core.$strip>;
+/** Options for generateWeatherReport (all fields optional). */
+interface WeatherReportOptions {
+    readonly cli?: CliNameLiteral;
+    readonly category?: string;
+    readonly includeAdaptive?: boolean;
+}
+/** Adapter attempt stats separating infra failures from model-quality failures (#1982). */
+interface AdapterAttemptStats {
+    /**
+     * Success rate excluding adapter_unavailable failures. Represents model-quality
+     * success when the adapter could actually attempt the task. Rounded to 3 decimals.
+     */
+    readonly adapterAttemptSuccessRate: number;
+    /** Count of adapter_unavailable failures in the sample. */
+    readonly adapterUnavailableCount: number;
+    /**
+     * Fraction of total attempts that failed due to adapter_unavailable. Rounded
+     * to 3 decimals. Useful for comparing infra availability across CLIs/categories.
+     */
+    readonly adapterUnavailableRate: number;
+}
+/** Per-CLI performance stats in the weather report. */
+interface CliWeather extends AdapterAttemptStats {
+    readonly cli: string;
+    readonly totalTasks: number;
+    readonly successRate: number;
+    readonly avgDurationMs: number;
+    readonly byCategory: ReadonlyMap<string, GroupStats>;
+}
+/** Adaptive bonus for a CLI+category pair. */
+interface AdaptiveBonus {
+    readonly cli: string;
+    readonly category: TaskCategory;
+    readonly staticBonus: number;
+    readonly adaptiveBonus: number;
+    readonly sampleCount: number;
+    readonly sufficient: boolean;
+}
+/** Tier recommendation surfaced in the weather report (#895). */
+interface TierRecommendationEntry {
+    readonly category: string;
+    readonly direction: 'promote' | 'demote';
+    readonly currentTier: number;
+    readonly recommendedTier: number;
+    readonly successRate: number;
+    readonly sampleCount: number;
+    readonly reason: string;
+}
+/** Learning insight for a CLI+category pair (Issue #901, Phase 4). */
+interface LearningInsight {
+    readonly cli: string;
+    readonly category: TaskCategory;
+    readonly trend: 'improving' | 'declining' | 'stable';
+    readonly confidence: number;
+    readonly adjustedBaseline: number;
+    readonly sampleCount: number;
+}
+/** Recommended CLI→category mapping for LinUCB cold-start (Epic #952, Phase 6). */
+interface RecommendedMapping {
+    readonly category: TaskCategory;
+    readonly recommendedCli: string;
     readonly successRate: number;
     readonly sampleCount: number;
     readonly confidence: 'high' | 'medium' | 'low';
@@ -25007,6 +25568,19 @@ interface TriageStats {
         readonly count: number;
     }[];
 }
+/**
+ * Cost section of the weather report (Epic G, #3856). Answers "what do governed
+ * decisions cost?" by surfacing the MEASURED per-decision cost aggregates
+ * (DecisionCostStore, #3855) windowed by gate type, alongside each strategy's
+ * coarse declared `costProfile` from the manifest registry. Both ride existing
+ * surfaces — no new MCP tool.
+ */
+interface CostSection {
+    /** Measured per-gate-type cost aggregates over the lookback window (#3855/#3856). */
+    readonly decisionCosts: DecisionCostReport;
+    /** Each strategy's declared coarse cost profile from the manifest registry. */
+    readonly strategyCostProfiles: readonly StrategyCostProfileEntry[];
+}
 /** Full weather report response. */
 interface WeatherReportResponse {
     readonly overall: AdapterAttemptStats & {
@@ -25036,6 +25610,8 @@ interface WeatherReportResponse {
     readonly swarmHealth?: SwarmHealthMetrics;
     /** Worker failure triage statistics (#1506). */
     readonly triageStats?: TriageStats;
+    /** Cost section: per-gate decision-cost aggregates + strategy cost profiles (Epic G, #3856). */
+    readonly costSection?: CostSection;
     /** Recent performance within the lookback window (#1401). */
     readonly recentWindow?: {
         readonly windowMs: number;
@@ -25066,10 +25642,24 @@ type WeatherReportConfig = z.infer<typeof WeatherReportConfigSchema>;
  * (Source: Issue #865 — Weather report with adaptive routing)
  */
 
+/**
+ * Optional injectable dependencies for {@link generateWeatherReport} (#3856).
+ * The cost section reads persisted per-decision cost records; tests inject a
+ * deterministic set via {@link WeatherReportDeps.decisionCostRecords} rather than
+ * touching the durable {@link DecisionCostStore}.
+ */
+interface WeatherReportDeps {
+    /**
+     * Pre-resolved decision-cost records to aggregate for the cost section. When
+     * omitted, the records are read from the durable {@link DecisionCostStore} iff
+     * persistence is enabled (no store is constructed when it is off).
+     */
+    readonly decisionCostRecords?: readonly DecisionCostRecord[];
+}
 /**
  * Generates the weather report from current outcome data.
  */
-declare function generateWeatherReport(input: WeatherReportOptions, config?: Partial<WeatherReportConfig>): WeatherReportResponse;
+declare function generateWeatherReport(input: WeatherReportOptions, config?: Partial<WeatherReportConfig>, deps?: WeatherReportDeps): WeatherReportResponse;
 
 /**
  * nexus-agents/mcp - Registry Import MCP Tool
@@ -25676,8 +26266,28 @@ declare class AuditLogger implements IAuditLogger {
     private closed;
     private inFlightFlush;
     private droppedEventCount;
-    constructor(config: AuditLogConfig, storage?: IAuditStorage, logger?: ILogger);
+    private persistFailureCount;
+    private readonly onPersistFailure;
+    constructor(config: AuditLogConfig, storage?: IAuditStorage, logger?: ILogger, onPersistFailure?: (error: Error) => void);
     private startFlushTimer;
+    /**
+     * Fail-loud handler for an audit-persist failure (#3916). A dropped/failed
+     * audit write undermines the tamper-evident hash chain (ADR-0017 /
+     * docs/security/audit-hash-chain-threat-model.md), so unlike the best-effort
+     * cost path this is NOT swallowed: it logs prominently at error level,
+     * increments a process-lifetime counter (exposed via
+     * {@link getPersistFailureCount}), and invokes the optional `onPersistFailure`
+     * hook so a governance consumer can escalate (e.g. raise/alert). Callers on the
+     * awaited flush()/close() path additionally receive the thrown error directly.
+     */
+    private recordPersistFailure;
+    /**
+     * Process-lifetime count of audit flushes that FAILED to persist (#3916). A
+     * non-zero value means at least one audit event was not durably written — the
+     * hash chain may have a gap. Surfaced so the failure is observable rather than
+     * silent.
+     */
+    getPersistFailureCount(): number;
     private shouldLog;
     private createEvent;
     log(input: AuditEventInput): void;
@@ -25685,6 +26295,22 @@ declare class AuditLogger implements IAuditLogger {
     logPolicyDecision(opts: PolicyDecisionAuditOpts): void;
     logSecurityEvent(opts: SecurityEventAuditOpts): void;
     logRateLimitViolation(opts: RateLimitAuditOpts): void;
+    /**
+     * Log an authority-tier transition (Epic D / ADR-0017, #3842). A promotion or
+     * demotion of a loop's authority tier is recorded as a hash-chained
+     * `governance`-category event whose `metadata.tierTransition` carries the
+     * structured {@link TierTransitionPayload} ({subject, fromTier, toTier,
+     * evidenceRef, ratificationVoteRef?}).
+     *
+     * The emitter does NOT itself enforce the ratification invariant (a promotion
+     * with no `ratificationVoteRef` is still chained — tampering with the log to
+     * remove the field must not erase the event). The invariant is enforced by the
+     * ratification gate (`scripts/check-authority-tier-drift.ts`), which reads the
+     * chained events back and FAILS a `promotion` lacking a vote ref. A promotion
+     * is emitted at `warning` severity (it grants authority) so it surfaces above
+     * the default info floor; a demotion is `info` (it is the safe direction).
+     */
+    logTierTransition(opts: TierTransitionAuditOpts): void;
     /** Log system startup event */
     logSystemStartup(metadata?: Record<string, unknown>): void;
     /** Log system shutdown event */
@@ -25701,248 +26327,7 @@ declare class AuditLogger implements IAuditLogger {
     flush(): Promise<void>;
     close(): Promise<void>;
 }
-declare function createAuditLogger(config: AuditLogConfig, storage?: IAuditStorage, logger?: ILogger): AuditLogger;
-
-/**
- * Pipeline Stage Types — Shared interfaces for graph-backed pipelines (#1735, Phase 2)
- *
- * Defines the IPipelineStage interface that all pipeline stages implement.
- * Stages are wrapped as GraphBuilder NodeHandlers for execution.
- *
- * @module pipeline/stage-types
- */
-/** Read-only pipeline context passed to every stage. */
-interface PipelineContext {
-    /** Unique pipeline execution ID. */
-    readonly executionId: string;
-    /** The original task/prompt that started the pipeline. */
-    readonly task: string;
-    /** Pipeline template being executed. */
-    readonly templateId: string;
-    /**
-     * Accumulated state from prior stages. The only cross-stage handoff
-     * channel — `sharedMemory` (the #1764 SharedMemoryStore) was removed
-     * in #2937 after being write-only since introduction. If you need
-     * structured cross-stage data, add a well-known key to
-     * `PIPELINE_STATE_KEYS` and write/read through `state`.
-     */
-    readonly state: Readonly<Record<string, unknown>>;
-}
-/** Result of executing a single pipeline stage. */
-interface StageOutput {
-    /** The key to store this stage's output under in pipeline state. */
-    readonly stateKey: string;
-    /** The output value (stored in GraphState). */
-    readonly value: unknown;
-    /** Duration in milliseconds. */
-    readonly durationMs: number;
-    /** Whether the stage succeeded. */
-    readonly success: boolean;
-    /** Error message if failed. */
-    readonly error?: string | undefined;
-}
-/** A pipeline stage that can be compiled into a graph node. */
-interface IPipelineStage {
-    /** Unique stage identifier (used as graph node ID). */
-    readonly id: string;
-    /** Human-readable stage name. */
-    readonly name: string;
-    /** Execute the stage. */
-    execute(context: PipelineContext): Promise<StageOutput>;
-}
-/** Edge definition in a pipeline template. */
-type PipelineEdge = {
-    readonly type: 'fixed';
-    readonly from: string;
-    readonly to: string;
-} | {
-    readonly type: 'conditional';
-    readonly from: string;
-    readonly routerKey: string;
-    readonly targets: readonly string[];
-};
-/** A declarative pipeline template defining stages and their connections. */
-interface PipelineTemplate {
-    /** Unique template identifier. */
-    readonly id: string;
-    /** Human-readable name. */
-    readonly name: string;
-    /** Ordered stage IDs (for simple linear pipelines). */
-    readonly stages: readonly string[];
-    /** Edge overrides (for non-linear flows like vote→plan feedback loops). */
-    readonly edges?: readonly PipelineEdge[] | undefined;
-    /** Stage IDs that can be skipped via dryRun. */
-    readonly dryRunStopAfter?: string | undefined;
-}
-/** Standard state keys used across pipeline templates. */
-declare const PIPELINE_STATE_KEYS: {
-    readonly TASK: "task";
-    readonly RESEARCH: "research";
-    readonly PLAN: "plan";
-    readonly VOTE_RESULT: "voteResult";
-    readonly VOTE_FEEDBACK: "voteFeedback";
-    readonly VOTE_ITERATIONS: "voteIterations";
-    readonly TASKS: "tasks";
-    readonly IMPLEMENTATIONS: "implementations";
-    readonly QA_ITERATIONS: "qaIterations";
-    readonly SECURITY_PASSED: "securityPassed";
-    readonly FINDINGS: "findings";
-    readonly PARSED_SPEC: "parsedSpec";
-    readonly SCAFFOLD_OUTPUT: "scaffoldOutput";
-    readonly COMPLETED: "completed";
-};
-
-/**
- * Pipeline Graph Compiler — Build executable graphs from templates (#1735, Phase 2)
- *
- * Compiles a PipelineTemplate + IPipelineStage implementations into a
- * CompiledGraph that can be executed by the GraphExecutor.
- *
- * @module pipeline/pipeline-graph
- */
-
-/** Result of compiling a pipeline template into a graph. */
-interface PipelineGraphResult {
-    readonly ok: boolean;
-    readonly graph?: CompiledGraph | undefined;
-    readonly error?: string | undefined;
-}
-/** Map of stage ID → stage implementation. */
-type StageRegistry = ReadonlyMap<string, IPipelineStage>;
-/**
- * Compile a pipeline template + stages into an executable graph.
- *
- * Each IPipelineStage is wrapped as a GraphBuilder node handler.
- * Linear edges are auto-generated from template.stages order.
- * Custom edges override the linear flow for feedback loops.
- */
-declare function compilePipelineGraph(template: PipelineTemplate, stages: StageRegistry): PipelineGraphResult;
-
-/**
- * Graph Pipeline Runner — Execute pipelines via GraphBuilder (#1735, Phase 2)
- *
- * Provides a runGraphPipeline() function that compiles a PipelineTemplate
- * + stage registry into an executable graph and runs it through the
- * graph executor with checkpoint/resume support.
- *
- * @module pipeline/graph-pipeline-runner
- */
-
-/** Options for graph-based pipeline execution. */
-interface GraphPipelineOptions {
-    /** When true, stop after the dryRunStopAfter stage. */
-    readonly dryRun?: boolean | undefined;
-    /** Maximum graph execution steps (default: 20). */
-    readonly maxSteps?: number | undefined;
-}
-/** Result of a graph-based pipeline execution. */
-interface GraphPipelineResult {
-    readonly success: boolean;
-    readonly templateId: string;
-    readonly stepsExecuted: number;
-    readonly durationMs: number;
-    readonly finalState: Readonly<Record<string, unknown>>;
-    readonly error?: string | undefined;
-}
-/**
- * Run a pipeline using graph-based execution.
- *
- * Compiles the template + stages into a graph, then executes via
- * the graph executor (super-step BSP model).
- */
-declare function runGraphPipeline(task: string, template: PipelineTemplate, stages: StageRegistry, options?: GraphPipelineOptions): Promise<GraphPipelineResult>;
-/** Extract a value from the final pipeline state. */
-declare function extractStateValue(state: Readonly<Record<string, unknown>>, key: string): unknown;
-
-/**
- * Adaptive Orchestrator — Task-driven pipeline selection (#1736, Phase 3)
- *
- * Analyzes incoming tasks, selects the appropriate pipeline template,
- * and executes via the graph pipeline runner. Single entry point
- * for all pipeline types.
- *
- * Design pattern: deterministic state machine backbone + selective
- * LLM invocation at decision nodes only (per CrewAI Flows / Temporal).
- *
- * @module pipeline/adaptive-orchestrator
- */
-
-/** Options for the adaptive orchestrator. */
-interface AdaptiveOrchestratorOptions extends GraphPipelineOptions {
-    /** Force a specific template (skip auto-detection). */
-    readonly templateId?: string | undefined;
-    /** Stage registry to use. If omitted, stages must be provided per-template. */
-    readonly stages: StageRegistry;
-}
-/** Result of adaptive orchestration — extends GraphPipelineResult with metadata. */
-interface AdaptiveOrchestratorResult extends GraphPipelineResult {
-    /** How the template was selected. */
-    readonly selectionMethod: 'explicit' | 'auto-detected';
-    /** Task classification used for selection. */
-    readonly taskClassification: TaskClassification;
-}
-/** Classification of a task for template routing. */
-interface TaskClassification {
-    readonly pipelineType: PipelineType;
-    readonly complexity: 'simple' | 'moderate' | 'complex';
-    readonly confidence: number;
-    readonly keywords: readonly string[];
-}
-/** Pipeline type derived from task analysis. */
-type PipelineType = 'dev' | 'research' | 'audit' | 'greenfield' | 'general';
-/** Classify a task for pipeline routing. */
-declare function classifyTask(task: string): TaskClassification;
-/**
- * Run the adaptive orchestrator — classify task, select template, execute.
- *
- * This is the single entry point for all pipeline execution.
- */
-declare function runAdaptiveOrchestrator(task: string, options: AdaptiveOrchestratorOptions): Promise<AdaptiveOrchestratorResult>;
-
-/**
- * nexus-agents/orchestration - Workflow Pattern Router
- *
- * Intelligent orchestration pattern selection based on task characteristics.
- * Uses SharedTaskAnalyzer signals + caller hints to select the optimal
- * workflow pattern (sequential, wave, graph, consensus, aflow, puppeteer).
- *
- * v1: Rule-based only (per consensus vote — no ML/RL yet).
- *
- * @module orchestration/workflow-router
- * (Source: Issue #844 — Intelligent Workflow Pattern Router)
- */
-
-/**
- * Creates a workflow pattern router.
- *
- * Analyzes task characteristics and selects the optimal orchestration
- * pattern using a rule-based classification system.
- *
- * Scope of `recordOutcome` / `getMetrics` (#2824): the recorded
- * `PatternOutcome`s live in a buffer owned by this router instance.
- * `route()` is a deterministic, rule-based classifier — it does NOT
- * consume recorded outcomes, so there is no per-instance learning to
- * "lose", and nothing to aggregate across processes. The pair is an
- * observability surface only. If cross-process pattern metrics are
- * ever needed, add a dedicated consumer that writes to a shared
- * `OutcomeStore` rather than widening this router's responsibility.
- */
-declare function createWorkflowRouter(options?: {
-    readonly logger?: ILogger | undefined;
-    readonly analyzer?: ISharedTaskAnalyzer | undefined;
-}): IWorkflowRouter;
-/** Public interface for the workflow router. */
-interface IWorkflowRouter {
-    /** Routes a task to the optimal workflow pattern. */
-    route(signals: TaskSignals, options?: WorkflowRouterOptions): RoutingDecision$1;
-    /**
-     * Records an execution outcome into this router instance's buffer.
-     * Observability only — `route()` never reads it back (#2824).
-     */
-    recordOutcome(outcome: PatternOutcome): void;
-    /** Aggregates this instance's recorded outcomes, optionally filtered by pattern. */
-    getMetrics(pattern?: WorkflowPattern): readonly PatternMetrics[];
-}
+declare function createAuditLogger(config: AuditLogConfig, storage?: IAuditStorage, logger?: ILogger, onPersistFailure?: (error: Error) => void): AuditLogger;
 
 /**
  * PR Review Findings — typed verification gate per #2225 + #2233 Child 3
@@ -26076,6 +26461,13 @@ interface PrReviewResponse {
     readonly errorCount: number;
     readonly reviews: readonly PrReviewVote[];
     readonly totalDurationMs: number;
+    /**
+     * Per-decision cost rollup (#3855): per-voter / per-model token + USD totals
+     * for this governed review. Rides the existing response — no new MCP tool.
+     * Totals are a floor when `costSummary.unmeasuredVoters > 0` (voters whose
+     * adapter reported no usage are counted as unmeasured, not a measured $0).
+     */
+    readonly costSummary?: DecisionCostSummary;
 }
 type PrReviewDeps = BaseMcpToolDeps;
 /** Maps a voter's approve/reject/abstain to PR review semantics. */