@nathapp/nax 0.24.0 → 0.26.0

package/nax/features/trigger-completion/prd.json

@@ -0,0 +1,150 @@
+{
+  "project": "nax",
+  "branchName": "feat/trigger-completion",
+  "feature": "trigger-completion",
+  "version": "0.25.0",
+  "description": "Wire all 8 unwired interaction triggers to correct pipeline decision points, add 3 missing hook events, and add integration tests for auto/telegram/webhook plugins.",
+  "userStories": [
+    {
+      "id": "TC-001",
+      "title": "Wire cost-exceeded and cost-warning triggers",
+      "description": "In src/execution/sequential-executor.ts: (1) Before exiting on cost limit (line ~93), call checkCostExceeded({featureName: ctx.feature, cost: totalCost, limit: ctx.config.execution.costLimit}, ctx.config, ctx.interactionChain). Import checkCostExceeded from src/interaction/triggers.ts. If isTriggerEnabled(\"cost-exceeded\", config) is false or chain is null, keep today behavior. Trigger abort = exit \"cost-limit\". Trigger skip/continue = allow run to proceed past limit. (2) Add cost-warning: track a boolean warningSent=false. In the iteration loop, when totalCost >= costLimit * (interaction.triggers[\"cost-warning\"]?.threshold ?? 0.8) and !warningSent, call checkCostWarning({featureName, cost, limit}, config, interactionChain), set warningSent=true. isTriggerEnabled guards the call. Default fallback continue = proceed silently. Both calls must be best-effort: guard with if(interactionChain) check.",
+      "complexity": "medium",
+      "status": "passed",
+      "acceptanceCriteria": [
+        "When cost hits 80% of limit and cost-warning trigger is enabled, checkCostWarning fires once",
+        "Warning fires only once per run even if cost stays above threshold for multiple iterations",
+        "When cost hits 100% of limit and cost-exceeded is enabled, checkCostExceeded fires before exit",
+        "abort response exits with cost-limit reason; skip/continue allows run to proceed",
+        "When interaction plugin not configured, behavior is identical to today",
+        "Unit tests cover 80% threshold, 100% threshold, abort, skip, continue responses"
+      ],
+      "attempts": 0,
+      "priorErrors": [],
+      "priorFailures": [],
+      "escalations": [],
+      "dependencies": [],
+      "tags": [],
+      "storyPoints": 2,
+      "passes": true
+    },
+    {
+      "id": "TC-002",
+      "title": "Wire max-retries trigger",
+      "description": "In src/pipeline/subscribers/interaction.ts, extend wireInteraction to also subscribe to story:failed event. When story:failed fires with countsTowardEscalation=true (permanent failure, all tiers exhausted), call executeTrigger(\"max-retries\", {featureName: ev.feature ?? \"\", storyId: ev.storyId, iteration: ev.attempts ?? 0}, config, interactionChain). Import StoryFailedEvent from event-bus. Guard with isTriggerEnabled(\"max-retries\", config) and interactionChain check. Response handling: abort = emit a new run:paused event with reason \"max-retries-abort\" (the executor checks this to halt); skip = default, proceed; escalate = not supported for this trigger, treat as skip. Note: the actual run halt on abort requires reading from a shared flag or emitting run:paused — simplest: log a warning and let the run continue (abort behavior can be enhanced later). For now, abort = warn log only.",
+      "complexity": "medium",
+      "status": "passed",
+      "acceptanceCriteria": [
+        "max-retries trigger fires when story:failed event has countsTowardEscalation=true",
+        "max-retries trigger does NOT fire when countsTowardEscalation=false",
+        "When trigger disabled or no chain, no-op",
+        "abort response logs a warning (full halt is future work)",
+        "Unit tests cover enabled/disabled, countsTowardEscalation true/false, all fallback responses"
+      ],
+      "attempts": 0,
+      "priorErrors": [],
+      "priorFailures": [],
+      "escalations": [],
+      "dependencies": [],
+      "tags": [],
+      "storyPoints": 2,
+      "passes": true
+    },
+    {
+      "id": "TC-003",
+      "title": "Wire security-review, merge-conflict, and pre-merge triggers",
+      "description": "Three trigger wiring points: (1) security-review in src/pipeline/stages/review.ts: when plugin reviewer (semgrep etc) returns failure (the existing check at ~line 50 that returns action:fail for plugin reviewer rejection), before permanently failing, call checkSecurityReview({featureName, storyId: ctx.story.id}, ctx.config, ctx.interactionChain) if isTriggerEnabled and chain present. abort=fail (today), escalate=return {action:\"escalate\"}. Import from interaction. (2) merge-conflict: add conflict detection in src/execution/git.ts — after any git merge/rebase/commit operation, check if stdout/stderr contains \"CONFLICT\" or \"conflict\". If detected and isTriggerEnabled(\"merge-conflict\") and chain, call checkMergeConflict. Export a detectMergeConflict(output: string): boolean helper. (3) pre-merge in sequential-executor.ts: after all stories complete (isComplete(prd)=true) and before emitting run:completed, call checkPreMerge({featureName: ctx.feature, totalStories: prd.userStories.length, cost: totalCost}, ctx.config, ctx.interactionChain) if enabled. abort = exit without completing.",
+      "complexity": "medium",
+      "status": "passed",
+      "acceptanceCriteria": [
+        "security-review trigger fires when plugin reviewer rejects (not lint/typecheck)",
+        "security-review abort = story permanently fails; escalate = story retried",
+        "detectMergeConflict(output) returns true when CONFLICT present in git output",
+        "merge-conflict trigger fires when git conflict detected and trigger enabled",
+        "pre-merge trigger fires once after all stories pass, before run:completed",
+        "pre-merge abort exits run; continue = complete normally",
+        "Unit tests for each trigger point with mock chain"
+      ],
+      "attempts": 0,
+      "priorErrors": [],
+      "priorFailures": [],
+      "escalations": [],
+      "dependencies": [],
+      "tags": [],
+      "storyPoints": 3,
+      "passes": true
+    },
+    {
+      "id": "TC-004",
+      "title": "Wire story-ambiguity and review-gate triggers",
+      "description": "Two opt-in triggers (disabled by default): (1) story-ambiguity in src/pipeline/stages/execution.ts: after agent session result is parsed, check if agent output contains ambiguity signals. Add helper isAmbiguousOutput(output: string): boolean that returns true if output contains any of: [\"unclear\", \"ambiguous\", \"need clarification\", \"please clarify\", \"which one\", \"not sure which\"]. If detected and isTriggerEnabled(\"story-ambiguity\", config) and interactionChain, call checkStoryAmbiguity({featureName, storyId: ctx.story.id, reason: \"Agent output suggests ambiguity\"}, config, ctx.interactionChain). abort = escalate story; continue = proceed as normal. (2) review-gate in src/pipeline/stages/completion.ts (or wherever story:completed is emitted): if isTriggerEnabled(\"review-gate\", config) and interactionChain, call checkReviewGate({featureName, storyId: ctx.story.id}, config, ctx.interactionChain) after story passes. abort = mark story as needing re-review (log warning, do not fail); continue = proceed. Both triggers default to disabled in config.",
+      "complexity": "medium",
+      "status": "passed",
+      "acceptanceCriteria": [
+        "isAmbiguousOutput() detects all 6 keyword phrases (case-insensitive)",
+        "story-ambiguity trigger fires when isAmbiguousOutput=true and trigger enabled",
+        "story-ambiguity is disabled by default (isTriggerEnabled returns false)",
+        "review-gate trigger fires after each story passes when enabled",
+        "review-gate is disabled by default",
+        "Unit tests for isAmbiguousOutput and both trigger dispatch paths"
+      ],
+      "attempts": 0,
+      "priorErrors": [],
+      "priorFailures": [],
+      "escalations": [],
+      "dependencies": [],
+      "tags": [],
+      "storyPoints": 2,
+      "passes": true
+    },
+    {
+      "id": "TC-005",
+      "title": "Wire missing hook events: on-resume, on-session-end, on-error",
+      "description": "Three missing hook events to wire in src/pipeline/subscribers/hooks.ts: (1) on-resume: add RunResumedEvent {type:\"run:resumed\"; feature: string} to PipelineEventBus. Emit it in sequential-executor.ts when resuming from pause state (detect via interaction state or run:paused→run:resumed cycle). Wire bus.on(\"run:resumed\") → fireHook(hooks, \"on-resume\", ...) in wireHooks. (2) on-session-end: fire after every agent session ends (pass OR fail). Wire bus.on(\"story:completed\") AND bus.on(\"story:failed\") → fireHook(hooks, \"on-session-end\", hookCtx(feature, {storyId, status: passed?\"passed\":\"failed\"})). (3) on-error: emit a run:errored event in src/execution/crash-recovery.ts crash handler (unhandledRejection / SIGTERM / SIGINT handlers). Wire bus.on(\"run:errored\") → fireHook(hooks, \"on-error\", hookCtx(feature, {reason: signal/error})). Add RunErroredEvent type to event-bus. All three follow existing best-effort fire-and-forget pattern.",
+      "complexity": "medium",
+      "status": "passed",
+      "acceptanceCriteria": [
+        "RunResumedEvent type added to PipelineEventBus",
+        "on-resume hook fires when run:resumed event emitted",
+        "on-session-end hook fires after story:completed AND story:failed events",
+        "RunErroredEvent type added to PipelineEventBus",
+        "on-error hook fires in crash-recovery handlers (SIGTERM, SIGINT, unhandledRejection)",
+        "All three follow fire-and-forget pattern (no await, errors logged)",
+        "Extend hooks.test.ts with tests for all three new events"
+      ],
+      "attempts": 0,
+      "priorErrors": [],
+      "priorFailures": [],
+      "escalations": [],
+      "dependencies": [],
+      "tags": [],
+      "storyPoints": 2,
+      "passes": true
+    },
+    {
+      "id": "TC-006",
+      "title": "Auto plugin and Telegram/Webhook plugin integration tests",
+      "description": "Add mock-based integration tests for the three untested plugins. File locations: test/unit/interaction/auto-plugin.test.ts, extend test/unit/interaction-plugins.test.ts. (1) AutoInteractionPlugin (_deps pattern): mock the LLM call via _deps.callLlm. Test: LLM returns approve → response.action=\"continue\"; LLM returns reject → response.action=\"abort\"; confidence < threshold → fallback to chain default; trigger=security-review → always rejects auto-approval (hardcoded block), returns chain default. Add _deps.callLlm to auto.ts if not present. (2) Telegram send flow: mock fetch globally in test. Verify send() POSTs to correct API URL with message text and inline keyboard buttons (approve/reject). Verify poll() parses callback_query correctly. (3) Webhook: mock an HTTP server using Bun.serve in test. Verify send() POSTs payload with correct Content-Type. Verify HMAC signature validation rejects tampered payload. All tests are pure unit/mock — no real network calls.",
+      "complexity": "medium",
+      "status": "passed",
+      "acceptanceCriteria": [
+        "AutoInteractionPlugin: approve, reject, low-confidence, security-review-block all tested",
+        "Auto plugin uses _deps pattern for LLM call (testable without real API)",
+        "Telegram send() verified to POST correct message structure with inline keyboard",
+        "Telegram poll() parses callback_query response correctly",
+        "Webhook send() verified with correct Content-Type and payload structure",
+        "Webhook HMAC validation: valid signature passes, tampered payload rejected",
+        "Zero real network calls in any test"
+      ],
+      "attempts": 0,
+      "priorErrors": [],
+      "priorFailures": [],
+      "escalations": [],
+      "dependencies": [],
+      "tags": [],
+      "storyPoints": 2,
+      "passes": true
+    }
+  ],
+  "updatedAt": "2026-03-07T14:53:47.398Z"
+}

package/nax/features/trigger-completion/progress.txt

@@ -0,0 +1,7 @@
+[2026-03-07T14:04:48.521Z] TC-001 — PASSED — Wire cost-exceeded and cost-warning triggers — Cost: $1.1231
+[2026-03-07T14:11:47.185Z] TC-002 — PASSED — Wire max-retries trigger — Cost: $0.1029
+[2026-03-07T14:30:04.761Z] TC-003 — PASSED — Wire security-review, merge-conflict, and pre-merge triggers — Cost: $1.3628
+[2026-03-07T14:36:14.823Z] TC-004 — PASSED — Wire story-ambiguity and review-gate triggers — Cost: $0.0000
+[2026-03-07T14:38:01.345Z] TC-004 — PASSED — Wire story-ambiguity and review-gate triggers — Cost: $0.1019
+[2026-03-07T14:43:51.353Z] TC-005 — PASSED — Wire missing hook events: on-resume, on-session-end, on-error — Cost: $0.4284
+[2026-03-07T14:53:47.397Z] TC-006 — PASSED — Auto plugin and Telegram/Webhook plugin integration tests — Cost: $0.7347

package/nax/status.json

@@ -1,37 +1,36 @@
 {
   "version": 1,
   "run": {
-    "id": "run-2026-03-07T06-14-21-018Z",
-    "feature": "status-file-consolidation",
-    "startedAt": "2026-03-07T06:14:21.018Z",
-    "status": "crashed",
+    "id": "run-2026-03-07T16-14-49-336Z",
+    "feature": "routing-persistence",
+    "startedAt": "2026-03-07T16:14:49.336Z",
+    "status": "running",
     "dryRun": false,
-    "pid": 217461,
-    "crashedAt": "2026-03-07T06:22:36.300Z",
-    "crashSignal": "SIGTERM"
+    "pid": 3412
   },
   "progress": {
     "total": 4,
-    "passed": 0,
+    "passed": 1,
     "failed": 0,
     "paused": 0,
     "blocked": 0,
-    "pending": 4
+    "pending": 3
   },
   "cost": {
-    "spent": 0,
-    "limit": 3
+    "spent": 0.52230675,
+    "limit": 8
   },
   "current": {
-    "storyId": "SFC-002",
-    "title": "Write feature-level status on run end",
+    "storyId": "RRP-002",
+    "title": "Add initialComplexity to StoryRouting and StoryMetrics for accurate reporting",
     "complexity": "medium",
     "tddStrategy": "test-after",
     "model": "balanced",
     "attempt": 1,
     "phase": "routing"
   },
-  "iterations": 0,
-  "updatedAt": "2026-03-07T06:22:36.300Z",
-  "durationMs": 495282
+  "iterations": 2,
+  "updatedAt": "2026-03-07T16:45:19.261Z",
+  "durationMs": 1829925,
+  "lastHeartbeat": "2026-03-07T16:45:19.261Z"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nathapp/nax",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "description": "AI Coding Agent Orchestrator \u2014 loops until done",
   "type": "module",
   "bin": {

package/src/config/types.ts

@@ -309,7 +309,9 @@ export interface InteractionConfig {
     fallback: "continue" | "skip" | "escalate" | "abort";
   };
   /** Enable/disable built-in triggers */
-  triggers: Partial<Record<string, boolean | { enabled: boolean; fallback?: string; timeout?: number }>>;
+  triggers: Partial<
+    Record<string, boolean | { enabled: boolean; fallback?: string; timeout?: number; threshold?: number }>
+  >;
 }
 
 /** Test coverage context config */

package/src/execution/crash-recovery.ts

@@ -32,6 +32,8 @@ export interface CrashRecoveryContext {
   getStartTime?: () => number;
   getTotalStories?: () => number;
   getStoriesCompleted?: () => number;
+  /** Optional callback to emit run:errored event (fire-and-forget) */
+  emitError?: (reason: string) => void;
 }
 
 /**
@@ -171,6 +173,9 @@ export function installCrashHandlers(ctx: CrashRecoveryContext): () => void {
       await ctx.pidRegistry.killAll();
     }
 
+    // Emit run:errored event (fire-and-forget)
+    ctx.emitError?.(signal.toLowerCase());
+
     // Write fatal log
     await writeFatalLog(ctx.jsonlFilePath, signal);
 
@@ -209,6 +214,9 @@ export function installCrashHandlers(ctx: CrashRecoveryContext): () => void {
       await ctx.pidRegistry.killAll();
     }
 
+    // Emit run:errored event (fire-and-forget)
+    ctx.emitError?.("uncaughtException");
+
     // Write fatal log with stack trace
     await writeFatalLog(ctx.jsonlFilePath, "uncaughtException", error);
 
@@ -242,6 +250,9 @@ export function installCrashHandlers(ctx: CrashRecoveryContext): () => void {
       await ctx.pidRegistry.killAll();
     }
 
+    // Emit run:errored event (fire-and-forget)
+    ctx.emitError?.("unhandledRejection");
+
     // Write fatal log
     await writeFatalLog(ctx.jsonlFilePath, "unhandledRejection", error);
 

package/src/execution/executor-types.ts

@@ -40,7 +40,7 @@ export interface SequentialExecutionResult {
   storiesCompleted: number;
   totalCost: number;
   allStoryMetrics: StoryMetrics[];
-  exitReason: "completed" | "cost-limit" | "max-iterations" | "stalled" | "no-stories";
+  exitReason: "completed" | "cost-limit" | "max-iterations" | "stalled" | "no-stories" | "pre-merge-aborted";
 }
 
 /**

package/src/execution/iteration-runner.ts

@@ -66,6 +66,7 @@ export async function runIteration(
     stories: storiesToExecute,
     routing,
     workdir: ctx.workdir,
+    prdPath: ctx.prdPath,
     featureDir: ctx.featureDir,
     hooks: ctx.hooks,
     plugins: ctx.pluginRegistry,

package/src/execution/lifecycle/run-setup.ts

@@ -21,6 +21,7 @@ import { fireHook } from "../../hooks";
 import type { InteractionChain } from "../../interaction";
 import { initInteractionChain } from "../../interaction";
 import { getSafeLogger } from "../../logger";
+import { pipelineEventBus } from "../../pipeline/event-bus";
 import { loadPlugins } from "../../plugins/loader";
 import type { PluginRegistry } from "../../plugins/registry";
 import type { PRD } from "../../prd";
@@ -123,6 +124,9 @@ export async function setupRun(options: RunSetupOptions): Promise<RunSetupResult
     getStartTime: () => options.startTime,
     getTotalStories: options.getTotalStories,
     getStoriesCompleted: options.getStoriesCompleted,
+    emitError: (reason: string) => {
+      pipelineEventBus.emit({ type: "run:errored", reason, feature: options.feature });
+    },
   });
 
   // Load PRD (before try block so it's accessible in finally for onRunEnd)

package/src/execution/sequential-executor.ts

@@ -1,5 +1,6 @@
 /** Sequential Story Executor (ADR-005, Phase 4) — main execution loop. */
 
+import { checkCostExceeded, checkCostWarning, checkPreMerge, isTriggerEnabled } from "../interaction/triggers";
 import { getSafeLogger } from "../logger";
 import type { StoryMetrics } from "../metrics";
 import { pipelineEventBus } from "../pipeline/event-bus";
@@ -35,6 +36,7 @@ export async function executeSequential(
     0,
   ];
   const allStoryMetrics: StoryMetrics[] = [];
+  let warningSent = false;
 
   pipelineEventBus.clear();
   wireHooks(pipelineEventBus, ctx.hooks, ctx.workdir, ctx.feature);
@@ -69,6 +71,17 @@ export async function executeSequential(
         prdDirty = false;
       }
       if (isComplete(prd)) {
+        // pre-merge trigger: prompt before completing the run
+        if (ctx.interactionChain && isTriggerEnabled("pre-merge", ctx.config)) {
+          const shouldProceed = await checkPreMerge(
+            { featureName: ctx.feature, totalStories: prd.userStories.length, cost: totalCost },
+            ctx.config,
+            ctx.interactionChain,
+          );
+          if (!shouldProceed) {
+            return buildResult("pre-merge-aborted");
+          }
+        }
         pipelineEventBus.emit({
           type: "run:completed",
           totalStories: 0,
@@ -91,13 +104,24 @@ export async function executeSequential(
       if (!ctx.useBatch) lastStoryId = selection.story.id;
 
       if (totalCost >= ctx.config.execution.costLimit) {
-        pipelineEventBus.emit({
-          type: "run:paused",
-          reason: `Cost limit reached: $${totalCost.toFixed(2)}`,
-          storyId: selection.story.id,
-          cost: totalCost,
-        });
-        return buildResult("cost-limit");
+        const shouldProceed =
+          ctx.interactionChain && isTriggerEnabled("cost-exceeded", ctx.config)
+            ? await checkCostExceeded(
+                { featureName: ctx.feature, cost: totalCost, limit: ctx.config.execution.costLimit },
+                ctx.config,
+                ctx.interactionChain,
+              )
+            : false;
+        if (!shouldProceed) {
+          pipelineEventBus.emit({
+            type: "run:paused",
+            reason: `Cost limit reached: $${totalCost.toFixed(2)}`,
+            storyId: selection.story.id,
+            cost: totalCost,
+          });
+          return buildResult("cost-limit");
+        }
+        pipelineEventBus.emit({ type: "run:resumed", feature: ctx.feature });
       }
 
       pipelineEventBus.emit({
@@ -118,6 +142,20 @@ export async function executeSequential(
         iter.prdDirty,
       ];
 
+      if (ctx.interactionChain && isTriggerEnabled("cost-warning", ctx.config) && !warningSent) {
+        const costLimit = ctx.config.execution.costLimit;
+        const triggerCfg = ctx.config.interaction?.triggers?.["cost-warning"];
+        const threshold = typeof triggerCfg === "object" ? (triggerCfg.threshold ?? 0.8) : 0.8;
+        if (totalCost >= costLimit * threshold) {
+          await checkCostWarning(
+            { featureName: ctx.feature, cost: totalCost, limit: costLimit },
+            ctx.config,
+            ctx.interactionChain,
+          );
+          warningSent = true;
+        }
+      }
+
       if (iter.prdDirty) {
         prd = await loadPRD(ctx.prdPath);
         prdDirty = false;

package/src/interaction/plugins/auto.ts

@@ -38,6 +38,14 @@ interface DecisionResponse {
   reasoning: string;
 }
 
+/**
+ * Module-level deps for testability (_deps pattern).
+ * Override callLlm in tests to avoid spawning the claude CLI.
+ */
+export const _deps = {
+  callLlm: null as ((request: InteractionRequest) => Promise<DecisionResponse>) | null,
+};
+
 /**
  * Auto plugin for AI-powered interaction responses
  */
@@ -80,7 +88,8 @@ export class AutoInteractionPlugin implements InteractionPlugin {
     }
 
     try {
-      const decision = await this.callLlm(request);
+      const callFn = _deps.callLlm ?? this.callLlm.bind(this);
+      const decision = await callFn(request);
 
       // Check confidence threshold
       if (decision.confidence < (this.config.confidenceThreshold ?? 0.7)) {

package/src/metrics/aggregator.ts

@@ -110,7 +110,8 @@ export function calculateAggregateMetrics(runs: RunMetrics[]): AggregateMetrics
   >();
 
   for (const story of allStories) {
-    const complexity = story.complexity;
+    // Use initialComplexity (first-classify prediction) when available; fall back to complexity
+    const complexity = story.initialComplexity ?? story.complexity;
     const existing = complexityStats.get(complexity) || {
       predicted: 0,
       tierCounts: new Map<string, number>(),

package/src/metrics/tracker.ts

@@ -58,9 +58,14 @@ export function collectStoryMetrics(ctx: PipelineContext, storyStartTime: string
   const modelDef = modelEntry ? resolveModel(modelEntry) : null;
   const modelUsed = modelDef?.model || routing.modelTier;
 
+  // initialComplexity: prefer story.routing.initialComplexity (first classify),
+  // fall back to routing.complexity for backward compat
+  const initialComplexity = story.routing?.initialComplexity ?? routing.complexity;
+
   return {
     storyId: story.id,
     complexity: routing.complexity,
+    initialComplexity,
     modelTier: routing.modelTier,
     modelUsed,
     attempts,
@@ -108,20 +113,27 @@ export function collectBatchMetrics(ctx: PipelineContext, storyStartTime: string
   const modelDef = modelEntry ? resolveModel(modelEntry) : null;
   const modelUsed = modelDef?.model || routing.modelTier;
 
-  return stories.map((story) => ({
-    storyId: story.id,
-    complexity: routing.complexity,
-    modelTier: routing.modelTier,
-    modelUsed,
-    attempts: 1, // batch stories don't escalate individually
-    finalTier: routing.modelTier,
-    success: true, // if batch succeeded, all stories succeeded
-    cost: costPerStory,
-    durationMs: durationPerStory,
-    firstPassSuccess: true, // batch = first pass success
-    startedAt: storyStartTime,
-    completedAt: new Date().toISOString(),
-  }));
+  return stories.map((story) => {
+    // initialComplexity: prefer story.routing.initialComplexity (if individual routing exists),
+    // fall back to shared routing.complexity (batch stories classified together)
+    const initialComplexity = story.routing?.initialComplexity ?? routing.complexity;
+
+    return {
+      storyId: story.id,
+      complexity: routing.complexity,
+      initialComplexity,
+      modelTier: routing.modelTier,
+      modelUsed,
+      attempts: 1, // batch stories don't escalate individually
+      finalTier: routing.modelTier,
+      success: true, // if batch succeeded, all stories succeeded
+      cost: costPerStory,
+      durationMs: durationPerStory,
+      firstPassSuccess: true, // batch = first pass success
+      startedAt: storyStartTime,
+      completedAt: new Date().toISOString(),
+    };
+  });
 }
 
 /**

package/src/metrics/types.ts

@@ -12,6 +12,8 @@ export interface StoryMetrics {
   storyId: string;
   /** Classified complexity */
   complexity: string;
+  /** Initial complexity from first classification — preserved across escalations */
+  initialComplexity?: string;
   /** Initial model tier */
   modelTier: string;
   /** Actual model used (e.g., "claude-sonnet-4.5") */

package/src/pipeline/event-bus.ts

@@ -135,6 +135,17 @@ export interface StoryPausedEvent {
   cost: number;
 }
 
+export interface RunResumedEvent {
+  type: "run:resumed";
+  feature: string;
+}
+
+export interface RunErroredEvent {
+  type: "run:errored";
+  reason: string;
+  feature?: string;
+}
+
 /** Discriminated union of all pipeline events. */
 export type PipelineEvent =
   | StoryStartedEvent
@@ -150,7 +161,9 @@ export type PipelineEvent =
   | HumanReviewRequestedEvent
   | RunStartedEvent
   | RunPausedEvent
-  | StoryPausedEvent;
+  | StoryPausedEvent
+  | RunResumedEvent
+  | RunErroredEvent;
 
 export type PipelineEventType = PipelineEvent["type"];
 

package/src/pipeline/stages/completion.ts

@@ -13,6 +13,7 @@
  */
 
 import { appendProgress } from "../../execution/progress";
+import { checkReviewGate, isTriggerEnabled } from "../../interaction/triggers";
 import { getLogger } from "../../logger";
 import { collectBatchMetrics, collectStoryMetrics } from "../../metrics";
 import { countStories, markStoryPassed, savePRD } from "../../prd";
@@ -72,6 +73,18 @@ export const completionStage: PipelineStage = {
         modelTier: ctx.routing?.modelTier,
         testStrategy: ctx.routing?.testStrategy,
       });
+
+      // review-gate trigger: check if story needs re-review after passing
+      if (ctx.interaction && isTriggerEnabled("review-gate", ctx.config)) {
+        const shouldContinue = await _completionDeps.checkReviewGate(
+          { featureName: ctx.prd.feature, storyId: completedStory.id },
+          ctx.config,
+          ctx.interaction,
+        );
+        if (!shouldContinue) {
+          logger.warn("completion", "Story marked for re-review", { storyId: completedStory.id });
+        }
+      }
     }
 
     // Save PRD
@@ -89,3 +102,10 @@ export const completionStage: PipelineStage = {
     return { action: "continue" };
   },
 };
+
+/**
+ * Swappable dependencies for testing (avoids mock.module() which leaks in Bun 1.x).
+ */
+export const _completionDeps = {
+  checkReviewGate,
+};

package/src/pipeline/stages/execution.ts

@@ -32,11 +32,33 @@
 
 import { getAgent, validateAgentForTier } from "../../agents";
 import { resolveModel } from "../../config";
+import { checkMergeConflict, checkStoryAmbiguity, isTriggerEnabled } from "../../interaction/triggers";
 import { getLogger } from "../../logger";
 import type { FailureCategory } from "../../tdd";
 import { runThreeSessionTdd } from "../../tdd";
+import { detectMergeConflict } from "../../utils/git";
 import type { PipelineContext, PipelineStage, StageResult } from "../types";
 
+/**
+ * Detect if agent output contains ambiguity signals
+ * Checks for keywords that indicate the agent is unsure about the implementation
+ */
+export function isAmbiguousOutput(output: string): boolean {
+  if (!output) return false;
+
+  const ambiguityKeywords = [
+    "unclear",
+    "ambiguous",
+    "need clarification",
+    "please clarify",
+    "which one",
+    "not sure which",
+  ];
+
+  const lowerOutput = output.toLowerCase();
+  return ambiguityKeywords.some((keyword) => lowerOutput.includes(keyword));
+}
+
 /**
  * Determine the pipeline action for a failed TDD result, based on its failureCategory.
  *
@@ -172,6 +194,42 @@ export const executionStage: PipelineStage = {
 
     ctx.agentResult = result;
 
+    // merge-conflict trigger: detect CONFLICT markers in agent output
+    const combinedOutput = (result.output ?? "") + (result.stderr ?? "");
+    if (
+      _executionDeps.detectMergeConflict(combinedOutput) &&
+      ctx.interaction &&
+      isTriggerEnabled("merge-conflict", ctx.config)
+    ) {
+      const shouldProceed = await _executionDeps.checkMergeConflict(
+        { featureName: ctx.prd.feature, storyId: ctx.story.id },
+        ctx.config,
+        ctx.interaction,
+      );
+      if (!shouldProceed) {
+        logger.error("execution", "Merge conflict detected — aborting story", { storyId: ctx.story.id });
+        return { action: "fail", reason: "Merge conflict detected" };
+      }
+    }
+
+    // story-ambiguity trigger: detect ambiguity signals in agent output
+    if (
+      result.success &&
+      _executionDeps.isAmbiguousOutput(combinedOutput) &&
+      ctx.interaction &&
+      isTriggerEnabled("story-ambiguity", ctx.config)
+    ) {
+      const shouldContinue = await _executionDeps.checkStoryAmbiguity(
+        { featureName: ctx.prd.feature, storyId: ctx.story.id, reason: "Agent output suggests ambiguity" },
+        ctx.config,
+        ctx.interaction,
+      );
+      if (!shouldContinue) {
+        logger.warn("execution", "Story ambiguity detected — escalating story", { storyId: ctx.story.id });
+        return { action: "escalate", reason: "Story ambiguity detected — needs clarification" };
+      }
+    }
+
     if (!result.success) {
       logger.error("execution", "Agent session failed", {
         exitCode: result.exitCode,
@@ -199,4 +257,8 @@ export const executionStage: PipelineStage = {
 export const _executionDeps = {
   getAgent,
   validateAgentForTier,
+  detectMergeConflict,
+  checkMergeConflict,
+  isAmbiguousOutput,
+  checkStoryAmbiguity,
 };