@nathapp/nax 0.40.1 → 0.42.0

package/src/execution/runner-completion.ts

@@ -11,9 +11,11 @@ import { fireHook } from "../hooks";
 import { getSafeLogger } from "../logger";
 import type { StoryMetrics } from "../metrics";
 import type { PipelineEventEmitter } from "../pipeline/events";
+import type { AgentGetFn } from "../pipeline/types";
 import type { PluginRegistry } from "../plugins/registry";
 import { isComplete } from "../prd";
 import type { PRD } from "../prd";
+import { autoCommitIfDirty } from "../utils/git";
 import { stopHeartbeat, writeExitSummary } from "./crash-recovery";
 import { hookCtx } from "./story-context";
 
@@ -42,6 +44,10 @@ export interface RunnerCompletionOptions {
   statusWriter: any;
   pluginRegistry: PluginRegistry;
   eventEmitter?: PipelineEventEmitter;
+  /** Protocol-aware agent resolver */
+  agentGetFn?: AgentGetFn;
+  /** Path to prd.json — required for acceptance fix story writes */
+  prdPath: string;
 }
 
 /**
@@ -67,7 +73,7 @@ export async function runCompletionPhase(options: RunnerCompletionOptions): Prom
     const acceptanceResult = await runAcceptanceLoop({
       config: options.config,
       prd: options.prd,
-      prdPath: "", // Not needed for this extraction
+      prdPath: options.prdPath,
       workdir: options.workdir,
       featureDir: options.featureDir,
       hooks: options.hooks,
@@ -79,6 +85,7 @@ export async function runCompletionPhase(options: RunnerCompletionOptions): Prom
       pluginRegistry: options.pluginRegistry,
       eventEmitter: options.eventEmitter,
       statusWriter: options.statusWriter,
+      agentGetFn: options.agentGetFn,
     });
 
     Object.assign(options, {
@@ -153,6 +160,9 @@ export async function runCompletionPhase(options: RunnerCompletionOptions): Prom
     durationMs,
   );
 
+  // Commit status.json and any other nax runtime files left dirty at run end
+  await autoCommitIfDirty(options.workdir, "run.complete", "run-summary", options.feature);
+
   return {
     durationMs,
     runCompletedAt,

package/src/execution/runner-execution.ts

@@ -10,6 +10,7 @@ import type { LoadedHooksConfig } from "../hooks";
 import { getSafeLogger } from "../logger";
 import type { StoryMetrics } from "../metrics";
 import type { PipelineEventEmitter } from "../pipeline/events";
+import type { AgentGetFn } from "../pipeline/types";
 import type { PluginRegistry } from "../plugins/registry";
 import type { PRD } from "../prd";
 import { tryLlmBatchRoute } from "../routing/batch-route";
@@ -17,6 +18,7 @@ import { clearCache as clearLlmCache, routeBatch as llmRouteBatch } from "../rou
 import { precomputeBatchPlan } from "./batching";
 import { getAllReadyStories } from "./helpers";
 import type { ParallelExecutorOptions, ParallelExecutorResult } from "./parallel-executor";
+import type { PidRegistry } from "./pid-registry";
 
 /**
  * Options for the execution phase.
@@ -42,6 +44,10 @@ export interface RunnerExecutionOptions {
   headless: boolean;
   parallel?: number;
   runParallelExecution?: (options: ParallelExecutorOptions, prd: PRD) => Promise<ParallelExecutorResult>;
+  /** Protocol-aware agent resolver — created once in runner.ts from createAgentRegistry(config) */
+  agentGetFn?: AgentGetFn;
+  /** PID registry for crash recovery — passed to agent.run() to register child processes. */
+  pidRegistry?: PidRegistry;
 }
 
 /**
@@ -198,6 +204,8 @@ export async function runExecutionPhase(
       runId: options.runId,
       startTime: options.startTime,
       batchPlan,
+      agentGetFn: options.agentGetFn,
+      pidRegistry: options.pidRegistry,
     },
     prd,
   );

package/src/execution/runner-setup.ts

@@ -7,6 +7,7 @@
 
 import type { NaxConfig } from "../config";
 import type { LoadedHooksConfig } from "../hooks";
+import type { AgentGetFn } from "../pipeline/types";
 
 /**
  * Options for the setup phase.
@@ -31,6 +32,8 @@ export interface RunnerSetupOptions {
   getIterations: () => number;
   getStoriesCompleted: () => number;
   getTotalStories: () => number;
+  /** Protocol-aware agent resolver — created from createAgentRegistry(config) in runner.ts */
+  agentGetFn?: AgentGetFn;
 }
 
 /**
@@ -76,6 +79,7 @@ export async function runSetupPhase(options: RunnerSetupOptions): Promise<Runner
     // BUG-017: Pass getters for run.complete event on SIGTERM
     getStoriesCompleted: options.getStoriesCompleted,
     getTotalStories: options.getTotalStories,
+    agentGetFn: options.agentGetFn,
   });
 
   return setupResult;

package/src/execution/runner.ts

@@ -13,6 +13,7 @@
  * - runner-completion.ts: Acceptance loop, hooks, metrics
  */
 
+import { createAgentRegistry } from "../agents/registry";
 import type { NaxConfig } from "../config";
 import type { LoadedHooksConfig } from "../hooks";
 import { fireHook } from "../hooks";
@@ -116,6 +117,10 @@ export async function run(options: RunOptions): Promise<RunResult> {
 
   const logger = getSafeLogger();
 
+  // Create protocol-aware agent registry (ACP wiring — ACP-003/registry-wiring)
+  const registry = createAgentRegistry(config);
+  const agentGetFn = registry.getAgent.bind(registry);
+
   // Declare prd before crash handler setup to avoid TDZ if SIGTERM arrives during setup
   // biome-ignore lint/suspicious/noExplicitAny: PRD type initialized during setup
   let prd: any | undefined;
@@ -137,6 +142,7 @@ export async function run(options: RunOptions): Promise<RunResult> {
     skipPrecheck,
     headless,
     formatterMode,
+    agentGetFn,
     getTotalCost: () => totalCost,
     getIterations: () => iterations,
     // BUG-017: Pass getters for run.complete event on SIGTERM
@@ -170,6 +176,8 @@ export async function run(options: RunOptions): Promise<RunResult> {
         headless,
         parallel,
         runParallelExecution: _runnerDeps.runParallelExecution ?? undefined,
+        agentGetFn,
+        pidRegistry,
       },
       prd,
       pluginRegistry,
@@ -198,6 +206,7 @@ export async function run(options: RunOptions): Promise<RunResult> {
       hooks,
       feature,
       workdir,
+      prdPath,
       statusFile,
       logFilePath,
       runId,
@@ -214,6 +223,7 @@ export async function run(options: RunOptions): Promise<RunResult> {
       statusWriter,
       pluginRegistry,
       eventEmitter,
+      agentGetFn,
     });
 
     const { durationMs } = completionResult;

package/src/interaction/plugins/webhook.ts

@@ -10,6 +10,15 @@ import type { Server } from "node:http";
 import { z } from "zod";
 import type { InteractionPlugin, InteractionRequest, InteractionResponse } from "../types";
 
+/**
+ * Injectable sleep for WebhookInteractionPlugin.receive() polling loop.
+ * Replace in tests to avoid real backoff delays.
+ * @internal
+ */
+export const _webhookPluginDeps = {
+  sleep: (ms: number): Promise<void> => Bun.sleep(ms),
+};
+
 /** Webhook plugin configuration */
 interface WebhookConfig {
   /** Webhook URL to POST requests to */
@@ -119,7 +128,7 @@ export class WebhookInteractionPlugin implements InteractionPlugin {
         this.pendingResponses.delete(requestId);
         return response;
       }
-      await Bun.sleep(backoffMs);
+      await _webhookPluginDeps.sleep(backoffMs);
       // Exponential backoff: double interval up to max
       backoffMs = Math.min(backoffMs * 2, maxBackoffMs);
     }

package/src/pipeline/stages/execution.ts

@@ -107,7 +107,7 @@ export const executionStage: PipelineStage = {
     const logger = getLogger();
 
     // HARD FAILURE: No agent available — cannot proceed without an agent
-    const agent = _executionDeps.getAgent(ctx.config.autoMode.defaultAgent);
+    const agent = (ctx.agentGetFn ?? _executionDeps.getAgent)(ctx.config.autoMode.defaultAgent);
     if (!agent) {
       return {
         action: "fail",
@@ -133,6 +133,7 @@ export const executionStage: PipelineStage = {
         config: ctx.config,
         workdir: ctx.workdir,
         modelTier: ctx.routing.modelTier,
+        featureName: ctx.prd.feature,
         contextMarkdown: ctx.contextMarkdown,
         constitution: ctx.constitution?.content,
         dryRun: false,
@@ -217,6 +218,37 @@ export const executionStage: PipelineStage = {
       modelDef: resolveModel(ctx.config.models[ctx.routing.modelTier]),
       timeoutSeconds: ctx.config.execution.sessionTimeoutSeconds,
       dangerouslySkipPermissions: ctx.config.execution.dangerouslySkipPermissions,
+      pidRegistry: ctx.pidRegistry,
+      featureName: ctx.prd.feature,
+      storyId: ctx.story.id,
+      // No sessionRole for single-session strategies (no role suffix in session name)
+      interactionBridge: (() => {
+        const plugin = ctx.interaction?.getPrimary();
+        if (!plugin) return undefined;
+        const QUESTION_PATTERNS = [/\?/, /\bwhich\b/i, /\bshould i\b/i, /\bunclear\b/i, /\bplease clarify\b/i];
+        return {
+          detectQuestion: async (text: string) => QUESTION_PATTERNS.some((p) => p.test(text)),
+          onQuestionDetected: async (text: string) => {
+            const requestId = `ix-acp-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+            await plugin.send({
+              id: requestId,
+              type: "input",
+              featureName: ctx.prd.feature,
+              storyId: ctx.story.id,
+              stage: "execution",
+              summary: text,
+              fallback: "continue",
+              createdAt: Date.now(),
+            });
+            try {
+              const response = await plugin.receive(requestId, 120_000);
+              return response.value ?? "continue";
+            } catch {
+              return "continue";
+            }
+          },
+        };
+      })(),
     });
 
     ctx.agentResult = result;

package/src/pipeline/stages/routing.ts

@@ -44,7 +44,13 @@ import type { PipelineContext, PipelineStage, RoutingResult, StageResult } from
  * Used as the default implementation in _routingDeps.runDecompose.
  * In production, replace with an LLM-backed adapter.
  */
-async function runDecompose(story: UserStory, prd: PRD, config: NaxConfig, _workdir: string): Promise<DecomposeResult> {
+async function runDecompose(
+  story: UserStory,
+  prd: PRD,
+  config: NaxConfig,
+  _workdir: string,
+  agentGetFn?: import("../types").AgentGetFn,
+): Promise<DecomposeResult> {
   const naxDecompose = config.decompose;
   const builderConfig: BuilderDecomposeConfig = {
     maxSubStories: naxDecompose?.maxSubstories ?? 5,
@@ -52,10 +58,15 @@ async function runDecompose(story: UserStory, prd: PRD, config: NaxConfig, _work
     maxRetries: naxDecompose?.maxRetries ?? 2,
   };
 
-  // Stub adapter — replaced in tests via _routingDeps injection.
+  // Resolve the default agent adapter for LLM-backed decompose.
+  // Falls back to agent.complete() with JSON mode — works with both CLI and ACP adapters.
+  const agent = (agentGetFn ?? getAgent)(config.autoMode.defaultAgent);
+  if (!agent) {
+    throw new Error(`[decompose] Agent "${config.autoMode.defaultAgent}" not found — cannot decompose`);
+  }
   const adapter = {
-    async decompose(_prompt: string): Promise<string> {
-      throw new Error("[decompose] No LLM adapter configured for story decomposition");
+    async decompose(prompt: string): Promise<string> {
+      return agent.complete(prompt, { jsonMode: true });
     },
   };
 
@@ -71,7 +82,7 @@ export const routingStage: PipelineStage = {
 
     // Resolve agent adapter for LLM routing (shared with execution)
     const agentName = ctx.config.execution?.agent ?? "claude";
-    const adapter = _routingDeps.getAgent(agentName);
+    const adapter = (ctx.agentGetFn ?? _routingDeps.getAgent)(agentName);
 
     // Staleness detection (RRP-003):
     // - story.routing absent                   → cache miss (no prior routing)
@@ -173,7 +184,7 @@ export const routingStage: PipelineStage = {
             `Story ${ctx.story.id} is oversized (${acCount} ACs) but decompose is disabled — continuing with original`,
           );
         } else if (decomposeConfig.trigger === "auto") {
-          const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir);
+          const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir, ctx.agentGetFn);
           if (result.validation.valid) {
             _routingDeps.applyDecomposition(ctx.prd, result);
             if (ctx.prdPath) {
@@ -193,7 +204,7 @@ export const routingStage: PipelineStage = {
             ctx.interaction!,
           );
           if (action === "decompose") {
-            const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir);
+            const result = await _routingDeps.runDecompose(ctx.story, ctx.prd, ctx.config, ctx.workdir, ctx.agentGetFn);
             if (result.validation.valid) {
               _routingDeps.applyDecomposition(ctx.prd, result);
               if (ctx.prdPath) {

package/src/pipeline/types.ts

@@ -8,6 +8,7 @@ import type { AgentResult } from "../agents/types";
 import type { NaxConfig } from "../config/schema";
 import type { ConstitutionResult } from "../constitution/types";
 import type { BuiltContext } from "../context/types";
+import type { PidRegistry } from "../execution/pid-registry";
 import type { HooksConfig } from "../hooks/types";
 import type { InteractionChain } from "../interaction/chain";
 import type { StoryMetrics } from "../metrics/types";
@@ -52,6 +53,8 @@ export interface RoutingResult {
  * };
  * ```
  */
+export type AgentGetFn = (name: string) => import("../agents/types").AgentAdapter | undefined;
+
 export interface PipelineContext {
   /** Ngent configuration */
   config: NaxConfig;
@@ -73,6 +76,13 @@ export interface PipelineContext {
   hooks: HooksConfig;
   /** Plugin registry (optional, for plugin-provided extensions) */
   plugins?: PluginRegistry;
+  /**
+   * Protocol-aware agent resolver. When set (ACP mode), returns AcpAgentAdapter;
+   * falls back to standalone getAgent (CLI mode) when absent.
+   */
+  agentGetFn?: AgentGetFn;
+  /** PID registry for crash recovery — passed through to agent.run() for child process registration. */
+  pidRegistry?: PidRegistry;
   /** Interaction chain (optional, for human-in-the-loop triggers) */
   interaction?: InteractionChain;
   /** Constitution result (set by constitutionStage) */

package/src/prd/schema.ts

@@ -0,0 +1,249 @@
+/**
+ * PRD JSON Validation and Schema Enforcement
+ *
+ * Validates and normalizes LLM-generated PRD JSON output before writing to disk.
+ */
+
+import type { Complexity, TestStrategy } from "../config";
+import type { PRD, UserStory } from "./types";
+import { validateStoryId } from "./validate";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const VALID_COMPLEXITY: Complexity[] = ["simple", "medium", "complex", "expert"];
+const VALID_TEST_STRATEGIES: TestStrategy[] = [
+  "test-after",
+  "tdd-simple",
+  "three-session-tdd",
+  "three-session-tdd-lite",
+];
+
+/** Pattern matching ST001 → ST-001 style IDs (prefix letters + digits, no separator) */
+const STORY_ID_NO_SEPARATOR = /^([A-Za-z]+)(\d+)$/;
+
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Extract JSON from a markdown code block.
+ *
+ * Handles:
+ *   ```json ... ```
+ *   ``` ... ```
+ *
+ * Returns the input unchanged if no code block is detected.
+ */
+export function extractJsonFromMarkdown(text: string): string {
+  const match = text.match(/```(?:json)?\s*\n([\s\S]*?)\n?\s*```/);
+  if (match) {
+    return match[1] ?? text;
+  }
+  return text;
+}
+
+/**
+ * Strip trailing commas before closing braces/brackets to handle a common LLM quirk.
+ * e.g. `{"a":1,}` → `{"a":1}`
+ */
+function stripTrailingCommas(text: string): string {
+  return text.replace(/,\s*([}\]])/g, "$1");
+}
+
+/**
+ * Normalize a story ID: convert e.g. ST001 → ST-001.
+ * Leaves IDs that already have separators unchanged.
+ */
+function normalizeStoryId(id: string): string {
+  const match = id.match(STORY_ID_NO_SEPARATOR);
+  if (match) {
+    return `${match[1]}-${match[2]}`;
+  }
+  return id;
+}
+
+/**
+ * Normalize complexity string (case-insensitive) to a valid Complexity value.
+ * Returns null if no match found.
+ */
+function normalizeComplexity(raw: string): Complexity | null {
+  const lower = raw.toLowerCase() as Complexity;
+  if ((VALID_COMPLEXITY as string[]).includes(lower)) {
+    return lower;
+  }
+  return null;
+}
+
+/**
+ * Validate a single story from raw LLM output.
+ * Returns a normalized UserStory or throws with field-level error.
+ */
+function validateStory(raw: unknown, index: number, allIds: Set<string>): UserStory {
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+    throw new Error(`[schema] story[${index}] must be an object`);
+  }
+
+  const s = raw as Record<string, unknown>;
+
+  // id
+  const rawId = s.id;
+  if (rawId === undefined || rawId === null || rawId === "") {
+    throw new Error(`[schema] story[${index}].id is required and must be non-empty`);
+  }
+  if (typeof rawId !== "string") {
+    throw new Error(`[schema] story[${index}].id must be a string`);
+  }
+  const id = normalizeStoryId(rawId);
+  validateStoryId(id);
+
+  // title
+  const title = s.title;
+  if (!title || typeof title !== "string" || title.trim() === "") {
+    throw new Error(`[schema] story[${index}].title is required and must be non-empty`);
+  }
+
+  // description
+  const description = s.description;
+  if (!description || typeof description !== "string" || description.trim() === "") {
+    throw new Error(`[schema] story[${index}].description is required and must be non-empty`);
+  }
+
+  // acceptanceCriteria
+  const ac = s.acceptanceCriteria;
+  if (!Array.isArray(ac) || ac.length === 0) {
+    throw new Error(`[schema] story[${index}].acceptanceCriteria is required and must be a non-empty array`);
+  }
+  for (let i = 0; i < ac.length; i++) {
+    if (typeof ac[i] !== "string") {
+      throw new Error(`[schema] story[${index}].acceptanceCriteria[${i}] must be a string`);
+    }
+  }
+
+  // complexity — accept from routing.complexity (PRD format) or top-level complexity (legacy)
+  const routing = typeof s.routing === "object" && s.routing !== null ? (s.routing as Record<string, unknown>) : {};
+  const rawComplexity = routing.complexity ?? s.complexity;
+  if (rawComplexity === undefined || rawComplexity === null) {
+    throw new Error(
+      `[schema] story[${index}] missing complexity. Set routing.complexity to one of: ${VALID_COMPLEXITY.join(", ")}`,
+    );
+  }
+  if (typeof rawComplexity !== "string") {
+    throw new Error(`[schema] story[${index}].routing.complexity must be a string`);
+  }
+  const complexity = normalizeComplexity(rawComplexity);
+  if (complexity === null) {
+    throw new Error(
+      `[schema] story[${index}].routing.complexity "${rawComplexity}" is invalid. Valid values: ${VALID_COMPLEXITY.join(", ")}`,
+    );
+  }
+
+  // testStrategy — accept from routing.testStrategy or top-level testStrategy
+  const rawTestStrategy = routing.testStrategy ?? s.testStrategy;
+  const testStrategy: TestStrategy =
+    rawTestStrategy !== undefined && (VALID_TEST_STRATEGIES as unknown[]).includes(rawTestStrategy)
+      ? (rawTestStrategy as TestStrategy)
+      : "tdd-simple";
+
+  // dependencies
+  const rawDeps = s.dependencies;
+  const dependencies: string[] = Array.isArray(rawDeps) ? (rawDeps as string[]) : [];
+
+  // Validate dependency references (against already-known IDs)
+  for (const dep of dependencies) {
+    if (!allIds.has(dep)) {
+      throw new Error(`[schema] story[${index}].dependencies references unknown story ID "${dep}"`);
+    }
+  }
+
+  // tags
+  const rawTags = s.tags;
+  const tags: string[] = Array.isArray(rawTags) ? (rawTags as string[]) : [];
+
+  return {
+    id,
+    title: title.trim(),
+    description: description.trim(),
+    acceptanceCriteria: ac as string[],
+    tags,
+    dependencies,
+    // Force runtime state — never trust LLM output
+    status: "pending",
+    passes: false,
+    attempts: 0,
+    escalations: [],
+    routing: {
+      complexity,
+      testStrategy,
+      reasoning: "validated from LLM output",
+    },
+  };
+}
+
+/**
+ * Parse raw string input, handling markdown wrapping and trailing commas.
+ * Throws with parse error context on failure.
+ */
+function parseRawString(text: string): unknown {
+  const extracted = extractJsonFromMarkdown(text);
+  const cleaned = stripTrailingCommas(extracted);
+
+  try {
+    return JSON.parse(cleaned);
+  } catch (err) {
+    const parseErr = err as SyntaxError;
+    throw new Error(`[schema] Failed to parse JSON: ${parseErr.message}`, { cause: parseErr });
+  }
+}
+
+/**
+ * Validate and normalize the JSON output from the planning LLM.
+ *
+ * @param raw - Raw LLM output (string or already-parsed object)
+ * @param feature - Feature name for auto-fill
+ * @param branch - Branch name for auto-fill
+ * @returns Validated PRD object
+ */
+export function validatePlanOutput(raw: unknown, feature: string, branch: string): PRD {
+  // Parse string input
+  const parsed: unknown = typeof raw === "string" ? parseRawString(raw) : raw;
+
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("[schema] PRD output must be a JSON object");
+  }
+
+  const obj = parsed as Record<string, unknown>;
+
+  // Validate top-level userStories
+  const rawStories = obj.userStories;
+  if (!Array.isArray(rawStories) || rawStories.length === 0) {
+    throw new Error("[schema] userStories is required and must be a non-empty array");
+  }
+
+  // First pass: collect all story IDs (after normalization) for dependency validation
+  const allIds = new Set<string>();
+  for (const story of rawStories) {
+    if (typeof story === "object" && story !== null && !Array.isArray(story)) {
+      const s = story as Record<string, unknown>;
+      const rawId = s.id;
+      if (typeof rawId === "string" && rawId !== "") {
+        allIds.add(normalizeStoryId(rawId));
+      }
+    }
+  }
+
+  // Second pass: full validation
+  const userStories: UserStory[] = rawStories.map((story, index) => validateStory(story, index, allIds));
+
+  const now = new Date().toISOString();
+
+  return {
+    project: typeof obj.project === "string" && obj.project !== "" ? obj.project : feature,
+    feature,
+    branchName: branch,
+    createdAt: typeof obj.createdAt === "string" ? obj.createdAt : now,
+    updatedAt: now,
+    userStories,
+  };
+}

package/src/tdd/orchestrator.ts

@@ -28,6 +28,8 @@ export interface ThreeSessionTddOptions {
   config: NaxConfig;
   workdir: string;
   modelTier: ModelTier;
+  /** Feature name — used for ACP session naming (nax-<hash>-<feature>-<story>-<role>) */
+  featureName?: string;
   contextMarkdown?: string;
   constitution?: string;
   dryRun?: boolean;
@@ -45,6 +47,7 @@ export async function runThreeSessionTdd(options: ThreeSessionTddOptions): Promi
     config,
     workdir,
     modelTier,
+    featureName,
     contextMarkdown,
     constitution,
     dryRun = false,
@@ -135,6 +138,7 @@ export async function runThreeSessionTdd(options: ThreeSessionTddOptions): Promi
       lite,
       lite,
       constitution,
+      featureName,
     );
     sessions.push(session1);
   }
@@ -240,6 +244,7 @@ export async function runThreeSessionTdd(options: ThreeSessionTddOptions): Promi
     lite,
     lite,
     constitution,
+    featureName,
   );
   sessions.push(session2);
 
@@ -269,6 +274,7 @@ export async function runThreeSessionTdd(options: ThreeSessionTddOptions): Promi
     contextMarkdown,
     lite,
     logger,
+    featureName,
   );
 
   // Session 3: Verifier
@@ -286,6 +292,7 @@ export async function runThreeSessionTdd(options: ThreeSessionTddOptions): Promi
     false,
     false,
     constitution,
+    featureName,
   );
   sessions.push(session3);
 

package/src/tdd/rectification-gate.ts

@@ -34,6 +34,7 @@ export async function runFullSuiteGate(
   contextMarkdown: string | undefined,
   lite: boolean,
   logger: ReturnType<typeof getLogger>,
+  featureName?: string,
 ): Promise<boolean> {
   const rectificationEnabled = config.execution.rectification?.enabled ?? false;
   if (!rectificationEnabled) return false;
@@ -67,6 +68,7 @@ export async function runFullSuiteGate(
         rectificationConfig,
         testCmd,
         fullSuiteTimeout,
+        featureName,
       );
     }
 
@@ -118,6 +120,7 @@ async function runRectificationLoop(
   rectificationConfig: NonNullable<NaxConfig["execution"]["rectification"]>,
   testCmd: string,
   fullSuiteTimeout: number,
+  featureName?: string,
 ): Promise<boolean> {
   const rectificationState: RectificationState = {
     attempt: 0,
@@ -156,6 +159,9 @@ async function runRectificationLoop(
       modelDef: resolveModel(config.models[implementerTier]),
       timeoutSeconds: config.execution.sessionTimeoutSeconds,
       dangerouslySkipPermissions: config.execution.dangerouslySkipPermissions,
+      featureName,
+      storyId: story.id,
+      sessionRole: "implementer",
     });
 
     if (!rectifyResult.success && rectifyResult.pid) {