@trailstep/create-flows 0.3.1 → 0.3.3

package/dist/chunk-RF3PMHPX.js

@@ -0,0 +1,2594 @@
+// src/feature-implementation/story-router/step.ts
+import { fail as fail3, state as state11, step as step10 } from "@trailstep/authoring";
+
+// src/feature-implementation/implement-green/step.ts
+import { state as state6, step as step5 } from "@trailstep/authoring";
+
+// src/feature-implementation/shared/story-state.ts
+import { state } from "@trailstep/authoring";
+
+// src/feature-implementation/commit-reviewed-story/run-git.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function runGit(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync("git", [...args], {
+      cwd,
+      maxBuffer: 1024 * 1024 * 10
+    });
+    return { ok: true, stdout: stdout.trimEnd() };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  }
+}
+
+// src/feature-implementation/shared/story-state.ts
+var STORY_STATE_KEYS = {
+  activePhase: "activePhase",
+  activeStory: "activeStory",
+  activeStoryContext: "activeStoryContext",
+  activeStoryStartCommit: "activeStoryStartCommit",
+  attemptsByPhase: "attemptsByPhase",
+  completedStories: "completedStories",
+  blockedReason: "blockedReason",
+  latestExplorationBrief: "latestExplorationBrief",
+  latestImplementationSummary: "latestImplementationSummary",
+  latestPreflightStatus: "latestPreflightStatus",
+  planningCheckpointCount: "planningCheckpointCount",
+  skipNextPlanningCheckpoint: "skipNextPlanningCheckpoint",
+  latestRedTestSummary: "latestRedTestSummary",
+  latestReviewResult: "latestReviewResult",
+  latestStoryRouterState: "latestStoryRouterState",
+  latestValidationSummary: "latestValidationSummary",
+  storyBaseline: "storyBaseline",
+  storyContextQueue: "storyContextQueue",
+  storyQueue: "storyQueue",
+  workflowOptions: "workflowOptions",
+  workflowWarnings: "workflowWarnings"
+};
+async function loadStoryPhaseContext(phase) {
+  const context = await state.get(
+    STORY_STATE_KEYS.activeStoryContext
+  );
+  if (!context) {
+    return void 0;
+  }
+  if (typeof context === "string") {
+    return context.length > 0 ? context : void 0;
+  }
+  const scopedContext = context[phase];
+  return scopedContext && scopedContext.length > 0 ? scopedContext : void 0;
+}
+async function incrementStoryPhaseAttempt(phase) {
+  const attempts = await state.get(STORY_STATE_KEYS.attemptsByPhase) ?? {};
+  const nextAttempt = (attempts[phase] ?? 0) + 1;
+  await state.set(STORY_STATE_KEYS.attemptsByPhase, { ...attempts, [phase]: nextAttempt });
+  return nextAttempt;
+}
+async function resetActiveStoryStartCommit() {
+  await state.set(STORY_STATE_KEYS.activeStoryStartCommit, null);
+}
+async function resetStoryLocalState(options = {}) {
+  await resetStoryLocalStateFields(options);
+}
+async function resetStoryLocalStateForNextStory() {
+  await resetStoryLocalStateFields({
+    preserveActiveStoryStartCommit: false,
+    preserveLatestStoryRouterState: false,
+    preserveStoryBaseline: false
+  });
+}
+async function resetStoryLocalStateFields(options) {
+  await state.set(STORY_STATE_KEYS.attemptsByPhase, {});
+  if (!options.preserveStoryBaseline) {
+    await state.set(STORY_STATE_KEYS.storyBaseline, null);
+  }
+  if (!options.preserveActiveStoryStartCommit) {
+    await resetActiveStoryStartCommit();
+  }
+  await state.set(STORY_STATE_KEYS.latestPreflightStatus, null);
+  await state.set(STORY_STATE_KEYS.latestExplorationBrief, null);
+  await state.set(STORY_STATE_KEYS.latestRedTestSummary, null);
+  await state.set(STORY_STATE_KEYS.latestImplementationSummary, null);
+  await state.set(STORY_STATE_KEYS.latestValidationSummary, null);
+  await state.set(STORY_STATE_KEYS.latestReviewResult, null);
+  if (!options.preserveLatestStoryRouterState) {
+    await state.set(STORY_STATE_KEYS.latestStoryRouterState, null);
+  }
+  await state.set(STORY_STATE_KEYS.blockedReason, null);
+}
+async function loadStoryReviewGitContext() {
+  const baseline = await state.get(
+    STORY_STATE_KEYS.activeStoryStartCommit
+  );
+  const warnings = [];
+  if (baseline?.warning) {
+    warnings.push(baseline.warning);
+  }
+  const cwd = state.cwd;
+  if (!cwd) {
+    warnings.push(
+      "Workflow cwd is unavailable; reviewer must treat committed story-change context as missing."
+    );
+    return {
+      storyStartCommit: baseline?.commit,
+      changedFiles: [],
+      committedChangedFiles: [],
+      uncommittedChangedFiles: [],
+      warnings
+    };
+  }
+  const status = await runGit(["status", "--short"], cwd);
+  if (!status.ok) {
+    warnings.push(`Unable to inspect \`git status --short\`: ${status.error}`);
+  }
+  const uncommittedChangedFilesResult = await runGit(["diff", "--name-only"], cwd);
+  if (!uncommittedChangedFilesResult.ok) {
+    warnings.push(
+      `Unable to inspect uncommitted changed files with \`git diff --name-only\`: ${uncommittedChangedFilesResult.error}`
+    );
+  }
+  const uncommittedDiffStatResult = await runGit(["diff", "--stat"], cwd);
+  if (!uncommittedDiffStatResult.ok) {
+    warnings.push(
+      `Unable to inspect uncommitted diffstat with \`git diff --stat\`: ${uncommittedDiffStatResult.error}`
+    );
+  }
+  const storyStartCommit = baseline?.commit;
+  let committedChangedFiles = [];
+  let committedDiffStat;
+  if (!storyStartCommit) {
+    warnings.push(
+      "No durable story start commit is recorded; reviewer must not silently review only the current working tree diff."
+    );
+  } else {
+    const baselineReachable = await runGit(["cat-file", "-e", `${storyStartCommit}^{commit}`], cwd);
+    if (!baselineReachable.ok) {
+      warnings.push(
+        `Recorded story start commit \`${storyStartCommit}\` is invalid or unreachable: ${baselineReachable.error}`
+      );
+    } else {
+      const committedChangedFilesResult = await runGit(
+        ["diff", "--name-only", `${storyStartCommit}..HEAD`],
+        cwd
+      );
+      if (!committedChangedFilesResult.ok) {
+        warnings.push(
+          `Unable to inspect committed changed files with \`git diff --name-only ${storyStartCommit}..HEAD\`: ${committedChangedFilesResult.error}`
+        );
+      } else {
+        committedChangedFiles = splitGitLines(committedChangedFilesResult.stdout);
+      }
+      const committedDiffStatResult = await runGit(
+        ["diff", "--stat", `${storyStartCommit}..HEAD`],
+        cwd
+      );
+      if (!committedDiffStatResult.ok) {
+        warnings.push(
+          `Unable to inspect committed diffstat with \`git diff --stat ${storyStartCommit}..HEAD\`: ${committedDiffStatResult.error}`
+        );
+      } else {
+        committedDiffStat = committedDiffStatResult.stdout;
+      }
+    }
+  }
+  const uncommittedTrackedFiles = uncommittedChangedFilesResult.ok ? splitGitLines(uncommittedChangedFilesResult.stdout) : [];
+  const uncommittedStatusFiles = status.ok ? parseStatusChangedFiles(status.stdout) : [];
+  const uncommittedChangedFiles = uniqueFiles([
+    ...uncommittedTrackedFiles,
+    ...uncommittedStatusFiles
+  ]);
+  return {
+    storyStartCommit,
+    statusShort: status.ok ? status.stdout : void 0,
+    changedFiles: uniqueFiles([...committedChangedFiles, ...uncommittedChangedFiles]),
+    committedChangedFiles,
+    uncommittedChangedFiles,
+    committedDiffStat,
+    uncommittedDiffStat: uncommittedDiffStatResult.ok ? uncommittedDiffStatResult.stdout : void 0,
+    warnings
+  };
+}
+function splitGitLines(stdout) {
+  return stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function parseStatusChangedFiles(stdout) {
+  return splitGitLines(stdout).flatMap((line) => {
+    const path = line.slice(3).trim();
+    if (path.length === 0) {
+      return [];
+    }
+    const renamedPath = path.split(" -> ").at(-1)?.trim();
+    return renamedPath ? [renamedPath] : [];
+  });
+}
+function uniqueFiles(files) {
+  return Array.from(new Set(files));
+}
+
+// src/feature-implementation/validate-story/step.ts
+import { state as state5, step as step4 } from "@trailstep/authoring";
+
+// src/feature-implementation/review-story-implementation/step.ts
+import { state as state4, step as step3 } from "@trailstep/authoring";
+
+// src/feature-implementation/commit-reviewed-story/step.ts
+import { fail, state as state3, step as step2 } from "@trailstep/authoring";
+
+// src/feature-implementation/open-pull-request/step.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+import { done, state as state2, step } from "@trailstep/authoring";
+
+// src/feature-implementation/shared/input-schema.ts
+import { jsonSchema } from "@trailstep/authoring";
+var takeItAwayInput = jsonSchema({
+  type: "object",
+  properties: {
+    conversation: { type: "string" },
+    autoCommit: { type: "boolean" },
+    pullRequest: {
+      type: "object",
+      properties: {
+        enabled: { type: "boolean" },
+        base: { type: "string" },
+        remote: { type: "string" },
+        draft: { type: "boolean" },
+        title: { type: "string" },
+        body: { type: "string" }
+      },
+      additionalProperties: false
+    },
+    planningCheckpoint: {
+      type: "object",
+      properties: {
+        enabled: { type: "boolean" }
+      },
+      additionalProperties: false
+    }
+  },
+  required: ["conversation"],
+  additionalProperties: false
+});
+function defaultTakeItAwayWorkflowOptions() {
+  return {
+    autoCommit: true,
+    pullRequest: {
+      enabled: true,
+      base: "main",
+      remote: "origin",
+      draft: false
+    },
+    planningCheckpoint: {
+      enabled: false
+    }
+  };
+}
+function normalizeTakeItAwayWorkflowOptions(input) {
+  const defaults = defaultTakeItAwayWorkflowOptions();
+  const title = nonEmptyOptional(input.pullRequest?.title);
+  const body = nonEmptyOptional(input.pullRequest?.body);
+  return {
+    autoCommit: input.autoCommit ?? defaults.autoCommit,
+    pullRequest: {
+      enabled: input.pullRequest?.enabled ?? defaults.pullRequest.enabled,
+      base: nonEmptyOrDefault(input.pullRequest?.base, defaults.pullRequest.base),
+      remote: nonEmptyOrDefault(input.pullRequest?.remote, defaults.pullRequest.remote),
+      draft: input.pullRequest?.draft ?? defaults.pullRequest.draft,
+      ...title === void 0 ? {} : { title },
+      ...body === void 0 ? {} : { body }
+    },
+    planningCheckpoint: {
+      enabled: input.planningCheckpoint?.enabled ?? defaults.planningCheckpoint.enabled
+    }
+  };
+}
+function nonEmptyOrDefault(value, fallback) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : fallback;
+}
+function nonEmptyOptional(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+
+// src/feature-implementation/open-pull-request/step.ts
+var execFileAsync2 = promisify2(execFile2);
+var openPullRequestStep = step({ id: "open-pull-request" }).do(
+  async (output) => {
+    const pullRequest = await openPullRequest(output);
+    const warnings = await loadWorkflowWarnings();
+    const pullRequestWarning = pullRequest.warning;
+    const finalWarnings = pullRequestWarning === void 0 ? warnings : [...warnings, pullRequestWarning];
+    return done({
+      ...output,
+      ...finalWarnings.length === 0 ? {} : { warnings: finalWarnings },
+      pullRequest
+    });
+  }
+);
+async function openPullRequest(output) {
+  const options = await loadWorkflowOptions();
+  const prOptions = options.pullRequest;
+  if (!prOptions.enabled) {
+    return { status: "disabled" };
+  }
+  const cwd = state2.cwd;
+  if (!cwd) {
+    return skipped("Workflow cwd is unavailable, so TrailStep could not safely create a PR.", {
+      branch: "<branch>",
+      base: prOptions.base,
+      remote: prOptions.remote
+    });
+  }
+  const insideWorkTree = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (!insideWorkTree.ok || insideWorkTree.stdout !== "true") {
+    return skipped(
+      "The workflow cwd is not a git worktree, so TrailStep could not safely create a PR.",
+      { branch: "<branch>", base: prOptions.base, remote: prOptions.remote }
+    );
+  }
+  const branch = await currentBranch(cwd);
+  if (!branch.ok) {
+    return skipped(branch.warning, {
+      branch: "<branch>",
+      base: prOptions.base,
+      remote: prOptions.remote
+    });
+  }
+  const status = await runGit(["status", "--short"], cwd);
+  if (!status.ok) {
+    return skipped(
+      `TrailStep could not inspect \`git status --short\`, so it did not create a PR: ${status.error}`,
+      { branch: branch.name, base: prOptions.base, remote: prOptions.remote }
+    );
+  }
+  if (status.stdout.trim().length > 0) {
+    return skipped(
+      "The working tree is dirty, so TrailStep did not create a PR. Review and commit the remaining changes, then run the suggested commands.",
+      { branch: branch.name, base: prOptions.base, remote: prOptions.remote }
+    );
+  }
+  const remote = await runGit(["remote", "get-url", prOptions.remote], cwd);
+  if (!remote.ok) {
+    return skipped(
+      `Git remote \`${prOptions.remote}\` is not configured, so TrailStep could not push and create a PR: ${remote.error}`,
+      { branch: branch.name, base: prOptions.base, remote: prOptions.remote }
+    );
+  }
+  const existing = await existingPullRequest(cwd, branch.name);
+  if (existing.ok && existing.url) {
+    return { status: "existing", url: existing.url };
+  }
+  const push = await runGit(["push", "--set-upstream", prOptions.remote, branch.name], cwd);
+  if (!push.ok) {
+    return skipped(`TrailStep could not push \`${branch.name}\`: ${push.error}`, {
+      branch: branch.name,
+      base: prOptions.base,
+      remote: prOptions.remote
+    });
+  }
+  const title = prOptions.title ?? await defaultPullRequestTitle(output);
+  const body = prOptions.body ?? defaultPullRequestBody(output);
+  const createArgs = [
+    "pr",
+    "create",
+    "--base",
+    prOptions.base,
+    "--head",
+    branch.name,
+    "--title",
+    title,
+    "--body",
+    body
+  ];
+  if (prOptions.draft) {
+    createArgs.push("--draft");
+  }
+  const created = await runGh(createArgs, cwd);
+  if (!created.ok) {
+    return skipped(
+      `TrailStep pushed \`${branch.name}\` but could not create a PR: ${created.error}`,
+      {
+        branch: branch.name,
+        base: prOptions.base,
+        remote: prOptions.remote
+      }
+    );
+  }
+  return { status: "created", url: extractUrl(created.stdout) };
+}
+async function loadWorkflowOptions() {
+  return await state2.get(STORY_STATE_KEYS.workflowOptions) ?? defaultTakeItAwayWorkflowOptions();
+}
+async function loadWorkflowWarnings() {
+  return await state2.get(STORY_STATE_KEYS.workflowWarnings) ?? [];
+}
+async function currentBranch(cwd) {
+  const branch = await runGit(["branch", "--show-current"], cwd);
+  if (!branch.ok || branch.stdout.trim().length === 0) {
+    return {
+      ok: false,
+      warning: branch.ok ? "Git is in a detached HEAD state, so TrailStep could not safely create a PR." : `TrailStep could not determine the current branch: ${branch.error}`
+    };
+  }
+  return { ok: true, name: branch.stdout.trim() };
+}
+async function existingPullRequest(cwd, branch) {
+  const result = await runGh(
+    ["pr", "list", "--head", branch, "--state", "open", "--json", "url", "--jq", '.[0].url // ""'],
+    cwd
+  );
+  if (!result.ok) {
+    return { ok: false };
+  }
+  const url = extractUrl(result.stdout);
+  return url ? { ok: true, url } : { ok: true };
+}
+async function defaultPullRequestTitle(output) {
+  const featureDoc = await state2.get("featureDoc");
+  const featureTitle = extractHeading(featureDoc?.content ?? "");
+  if (featureTitle) {
+    return truncateTitle(featureTitle);
+  }
+  return truncateTitle(output.completedStories[0] ?? "TrailStep implementation");
+}
+function defaultPullRequestBody(output) {
+  return [
+    output.summary,
+    "",
+    "## TrailStep artifacts",
+    `- Feature doc: ${output.featureDocPath}`,
+    `- Implementation doc: ${output.implementationDocPath}`,
+    "",
+    "## Completed stories",
+    ...output.completedStories.map((story) => `- ${story}`)
+  ].join("\n");
+}
+function skipped(warning, options) {
+  return {
+    status: "skipped",
+    warning,
+    commands: suggestedCommands(options)
+  };
+}
+function suggestedCommands({
+  branch,
+  base,
+  remote
+}) {
+  return [
+    "git status --short",
+    'git add -A && git commit -m "trailstep: finalize reviewed changes"',
+    `git push --set-upstream ${shellQuote(remote)} ${shellQuote(branch)}`,
+    `gh pr create --fill --base ${shellQuote(base)} --head ${shellQuote(branch)}`
+  ];
+}
+async function runGh(args, cwd) {
+  try {
+    const { stdout } = await execFileAsync2("gh", [...args], {
+      cwd,
+      maxBuffer: 1024 * 1024 * 10
+    });
+    return { ok: true, stdout: stdout.trimEnd() };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { ok: false, error: message };
+  }
+}
+function extractHeading(content) {
+  return /^#{1,6}\s+(.+)$/m.exec(content)?.[1]?.trim();
+}
+function truncateTitle(title) {
+  return title.length <= 72 ? title : `${title.slice(0, 69)}...`;
+}
+function extractUrl(stdout) {
+  return /https?:\/\/\S+/u.exec(stdout)?.[0];
+}
+function shellQuote(value) {
+  if (/^[A-Za-z0-9_./:@-]+$/u.test(value)) {
+    return value;
+  }
+  return `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+
+// src/feature-implementation/shared/output-schema.ts
+import { jsonSchema as jsonSchema2 } from "@trailstep/authoring";
+var takeItAwayOutput = jsonSchema2({
+  type: "object",
+  properties: {
+    status: { type: "string", const: "implemented" },
+    featureDocPath: { type: "string" },
+    implementationDocPath: { type: "string" },
+    storyCount: { type: "number" },
+    completedStories: { type: "array", items: { type: "string" } },
+    summary: { type: "string" },
+    warnings: { type: "array", items: { type: "string" } },
+    pullRequest: {
+      type: "object",
+      properties: {
+        status: { type: "string", enum: ["created", "existing", "skipped", "disabled"] },
+        url: { type: "string" },
+        warning: { type: "string" },
+        commands: { type: "array", items: { type: "string" } }
+      },
+      required: ["status"],
+      additionalProperties: false
+    }
+  },
+  required: [
+    "status",
+    "featureDocPath",
+    "implementationDocPath",
+    "storyCount",
+    "completedStories",
+    "summary"
+  ],
+  additionalProperties: false
+});
+function extractStoryTitle(storyContent, fallbackIndex) {
+  const heading = /^#{1,6}\s+(.+)$/m.exec(storyContent);
+  return heading?.[1]?.trim() || `Story ${fallbackIndex}`;
+}
+
+// src/feature-implementation/commit-reviewed-story/step.ts
+var commitReviewedStoryStep = step2({ id: "commit-reviewed-story" }).do(
+  async (input) => {
+    const activeStory = input.currentStory;
+    if (!state3.isReplayingCompletedStep && await storyAutoCommitEnabled()) {
+      const commitResult = await commitReviewedStoryChanges(
+        activeStory,
+        input.implementationSummary
+      );
+      if (commitResult.ok) {
+        if (commitResult.warning) {
+          await appendWorkflowWarning(commitResult.warning);
+        }
+      } else {
+        const storyQueue = await state3.get(STORY_STATE_KEYS.storyQueue) ?? [];
+        if (storyQueue.length > 0) {
+          return fail({
+            code: commitResult.code,
+            message: commitResult.message,
+            details: commitResult.details
+          });
+        }
+        await appendWorkflowWarning(commitResult.message);
+      }
+    }
+    return completeReviewedStory(activeStory);
+  }
+);
+async function storyAutoCommitEnabled() {
+  const options = await state3.get(STORY_STATE_KEYS.workflowOptions) ?? defaultTakeItAwayWorkflowOptions();
+  return options.autoCommit;
+}
+async function commitReviewedStoryChanges(activeStory, implementationSummary) {
+  const cwd = state3.cwd;
+  if (!cwd) {
+    return {
+      ok: false,
+      code: "story_commit_missing_cwd",
+      message: "Cannot commit reviewed story because the TrailStep workflow cwd is unavailable.",
+      details: { storyPath: activeStory.path }
+    };
+  }
+  const insideWorkTree = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (!insideWorkTree.ok || insideWorkTree.stdout !== "true") {
+    return {
+      ok: false,
+      code: "story_commit_not_git_worktree",
+      message: "Cannot commit reviewed story because the workflow is not running inside a git worktree.",
+      details: {
+        storyPath: activeStory.path,
+        gitError: insideWorkTree.ok ? void 0 : insideWorkTree.error
+      }
+    };
+  }
+  const add = await runGit(["add", "-A"], cwd);
+  if (!add.ok) {
+    return {
+      ok: false,
+      code: "story_commit_stage_failed",
+      message: "Cannot commit reviewed story because `git add -A` failed.",
+      details: { storyPath: activeStory.path, gitError: add.error }
+    };
+  }
+  const staged = await runGit(["diff", "--cached", "--name-only"], cwd);
+  if (!staged.ok) {
+    return {
+      ok: false,
+      code: "story_commit_status_failed",
+      message: "Cannot commit reviewed story because staged changes could not be inspected.",
+      details: { storyPath: activeStory.path, gitError: staged.error }
+    };
+  }
+  const storyTitle = extractStoryTitle(activeStory.content, 1);
+  if (staged.stdout.trim().length === 0) {
+    const baseline = await state3.get(
+      STORY_STATE_KEYS.activeStoryStartCommit
+    );
+    const head = await runGit(["rev-parse", "HEAD"], cwd);
+    if (baseline?.commit && head.ok && head.stdout !== baseline.commit) {
+      return { ok: true };
+    }
+    const headSubject = await runGit(["log", "-1", "--format=%s"], cwd);
+    if (headSubject.ok && headSubject.stdout === truncateCommitSubject(`trailstep: ${storyTitle}`)) {
+      return { ok: true };
+    }
+    return {
+      ok: true,
+      warning: "The story passed review, but there were no staged or already-committed changes since the story baseline to commit."
+    };
+  }
+  const commit = await runGit(
+    [
+      "commit",
+      "-m",
+      truncateCommitSubject(`trailstep: ${storyTitle}`),
+      "-m",
+      commitBody(activeStory, implementationSummary, staged.stdout)
+    ],
+    cwd
+  );
+  if (!commit.ok) {
+    return {
+      ok: false,
+      code: "story_commit_failed",
+      message: "The story passed review, but TrailStep could not create the story commit.",
+      details: { storyPath: activeStory.path, gitError: commit.error }
+    };
+  }
+  return { ok: true };
+}
+async function completeReviewedStory(activeStory) {
+  const completed = await state3.get(STORY_STATE_KEYS.completedStories) ?? [];
+  const completedTitle = extractStoryTitle(activeStory.content, completed.length + 1);
+  const storyAlreadyCompleted = completed.includes(completedTitle);
+  const updatedCompleted = storyAlreadyCompleted ? completed : [...completed, completedTitle];
+  const persistedActiveStory = await state3.get(STORY_STATE_KEYS.activeStory);
+  const storyQueue = await state3.get(STORY_STATE_KEYS.storyQueue) ?? [];
+  const storyContextQueue = await state3.get(STORY_STATE_KEYS.storyContextQueue) ?? [];
+  const queuedStories = storyQueue.map((story, index) => ({ story, context: storyContextQueue[index] ?? "" })).filter(({ story }) => !documentsMatch(story, activeStory));
+  const persistedStoryAlreadyAdvanced = persistedActiveStory && !documentsMatch(persistedActiveStory, activeStory);
+  const persistedQueuedIndex = persistedStoryAlreadyAdvanced ? queuedStories.findIndex(({ story }) => documentsMatch(story, persistedActiveStory)) : -1;
+  const activeStoryContext = persistedStoryAlreadyAdvanced && persistedQueuedIndex < 0 ? await state3.get(
+    STORY_STATE_KEYS.activeStoryContext
+  ) ?? "" : void 0;
+  const nextStory = persistedStoryAlreadyAdvanced ? persistedActiveStory : queuedStories[0]?.story;
+  const nextStoryContext = persistedStoryAlreadyAdvanced ? persistedQueuedIndex >= 0 ? queuedStories[persistedQueuedIndex]?.context ?? "" : activeStoryContext : queuedStories[0]?.context ?? "";
+  const remainingStoryEntries = persistedStoryAlreadyAdvanced ? queuedStories.filter(({ story }) => !documentsMatch(story, persistedActiveStory)) : queuedStories.slice(1);
+  if (!nextStory) {
+    await state3.set(STORY_STATE_KEYS.completedStories, updatedCompleted);
+    await state3.set(STORY_STATE_KEYS.activeStory, null);
+    await state3.set(STORY_STATE_KEYS.activeStoryContext, null);
+    await state3.set(STORY_STATE_KEYS.storyContextQueue, []);
+    await resetActiveStoryStartCommit();
+    const featureDoc = await state3.get("featureDoc");
+    const implementationDoc = await state3.get("implementationDoc");
+    const output = {
+      status: "implemented",
+      featureDocPath: featureDoc?.path ?? "",
+      implementationDocPath: implementationDoc?.path ?? "",
+      storyCount: updatedCompleted.length,
+      completedStories: updatedCompleted,
+      summary: `Implemented and reviewed ${updatedCompleted.length} ${updatedCompleted.length === 1 ? "story" : "stories"}.`
+    };
+    return openPullRequestStep(output);
+  }
+  if (!state3.isReplayingCompletedStep && !await storyAutoCommitEnabled()) {
+    const cleanBoundary = await verifyCleanBoundaryBeforeNextStory(activeStory);
+    if (!cleanBoundary.ok) {
+      return fail({
+        code: cleanBoundary.code,
+        message: cleanBoundary.message,
+        details: cleanBoundary.details
+      });
+    }
+  }
+  await resetStoryLocalStateForNextStory();
+  await state3.set(STORY_STATE_KEYS.completedStories, updatedCompleted);
+  await state3.set(
+    STORY_STATE_KEYS.storyQueue,
+    remainingStoryEntries.map(({ story }) => story)
+  );
+  await state3.set(
+    STORY_STATE_KEYS.storyContextQueue,
+    remainingStoryEntries.map(({ context }) => context)
+  );
+  await state3.set(STORY_STATE_KEYS.activeStory, nextStory);
+  await state3.set(STORY_STATE_KEYS.activeStoryContext, nextStoryContext);
+  const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+  return storyRouterStep2({ reason: "story-completed", currentStory: nextStory });
+}
+function documentsMatch(left, right) {
+  return left.path === right.path && left.content === right.content;
+}
+async function appendWorkflowWarning(warning) {
+  const warnings = await state3.get(STORY_STATE_KEYS.workflowWarnings) ?? [];
+  await state3.set(STORY_STATE_KEYS.workflowWarnings, [...warnings, warning]);
+}
+async function verifyCleanBoundaryBeforeNextStory(activeStory) {
+  const cwd = state3.cwd;
+  if (!cwd) {
+    return {
+      ok: false,
+      code: "story_boundary_missing_cwd",
+      message: "Cannot advance to the next story because the workflow cwd is unavailable. Commit or restore a clean story boundary from a valid checkout, then retry.",
+      details: { storyPath: activeStory.path }
+    };
+  }
+  const status = await runGit(["status", "--short"], cwd);
+  if (!status.ok) {
+    return {
+      ok: false,
+      code: "story_boundary_status_failed",
+      message: "Cannot advance to the next story because TrailStep could not inspect `git status --short`. Fix git status inspection, commit or restore a clean story boundary, then retry.",
+      details: { storyPath: activeStory.path, cwd, gitError: status.error }
+    };
+  }
+  if (status.stdout.trim().length > 0) {
+    return {
+      ok: false,
+      code: "story_boundary_dirty_without_auto_commit",
+      message: "Cannot advance to the next story because auto-commit is disabled and the reviewed story left uncommitted changes. Commit, stash, or otherwise restore a clean story boundary, then retry the workflow.",
+      details: { storyPath: activeStory.path, cwd, statusShort: status.stdout }
+    };
+  }
+  return { ok: true };
+}
+function truncateCommitSubject(subject) {
+  return subject.length <= 72 ? subject : `${subject.slice(0, 69)}...`;
+}
+function commitBody(activeStory, implementationSummary, stagedFiles) {
+  return [
+    "Committed automatically by TrailStep after a passing story review.",
+    "",
+    `Story artifact: ${activeStory.path}`,
+    "",
+    "Implementer summary:",
+    implementationSummary?.trim() || "Not provided.",
+    "",
+    "Staged files:",
+    stagedFiles.split("\n").filter((file) => file.length > 0).map((file) => `- ${file}`).join("\n")
+  ].join("\n");
+}
+
+// src/feature-implementation/shared/review-schema.ts
+import { jsonSchema as jsonSchema3 } from "@trailstep/authoring";
+
+// src/feature-implementation/shared/constants.ts
+var STORY_BOUNDARY = "<!-- trailstep-story-boundary -->";
+var STORY_CONTEXT_START = "<context>";
+var STORY_CONTEXT_END = "</context>";
+var REVIEW_PASS_THRESHOLD = 4;
+var MAX_IMPLEMENTATION_DOC_REVIEW_ATTEMPTS = 5;
+var MAX_STORY_REVIEW_ATTEMPTS = 3;
+var MAX_STORY_VALIDATION_ATTEMPTS = 3;
+var STORY_DOCTOR_VALIDATION_FAILURE_THRESHOLD = 2;
+
+// src/feature-implementation/shared/review-schema.ts
+var RATING_SCHEMA = { type: "integer", minimum: 1, maximum: 5 };
+var reviewOutput = jsonSchema3({
+  type: "object",
+  properties: {
+    score: RATING_SCHEMA,
+    summary: { type: "string" },
+    methodologyRatings: {
+      type: "object",
+      properties: {
+        tdd: RATING_SCHEMA,
+        verticalSlicing: RATING_SCHEMA,
+        tracerBullet: RATING_SCHEMA,
+        dependencies: RATING_SCHEMA,
+        architecture: RATING_SCHEMA
+      },
+      required: ["tdd", "verticalSlicing", "tracerBullet", "dependencies", "architecture"],
+      additionalProperties: false
+    },
+    requiredImprovements: { type: "array", items: { type: "string" } }
+  },
+  required: ["score", "summary", "methodologyRatings", "requiredImprovements"],
+  additionalProperties: false
+});
+function reviewPasses(review) {
+  return review.score >= REVIEW_PASS_THRESHOLD;
+}
+
+// src/feature-implementation/review-story-implementation/prompt.ts
+import { promptSections, section } from "@trailstep/authoring";
+
+// src/feature-implementation/shared/story-view.ts
+var STORY_SECTION_TITLES = [
+  "Dependencies",
+  "Goal",
+  "User-Visible / Integration-Visible Slice",
+  "Acceptance Criteria",
+  "Red Phase",
+  "Green Phase",
+  "Refactor Phase",
+  "Validation Commands",
+  "Notes for Implementer"
+];
+var KNOWN_SECTION_TITLES = new Set(STORY_SECTION_TITLES.map(normalizeHeading));
+function storyViewForTestWriter(storyContent) {
+  return storyView(storyContent, [
+    "Dependencies",
+    "Goal",
+    "User-Visible / Integration-Visible Slice",
+    "Acceptance Criteria",
+    "Red Phase",
+    "Validation Commands"
+  ]);
+}
+function storyViewForImplementer(storyContent) {
+  return storyView(storyContent, [
+    "Dependencies",
+    "Goal",
+    "User-Visible / Integration-Visible Slice",
+    "Acceptance Criteria",
+    "Green Phase",
+    "Refactor Phase",
+    "Notes for Implementer"
+  ]);
+}
+function storyViewForReviewer(storyContent) {
+  return storyView(storyContent, [
+    "Dependencies",
+    "Goal",
+    "User-Visible / Integration-Visible Slice",
+    "Acceptance Criteria",
+    "Red Phase",
+    "Green Phase",
+    "Refactor Phase",
+    "Validation Commands",
+    "Notes for Implementer"
+  ]);
+}
+function storyView(storyContent, visibleSections) {
+  const parsed = parseStorySections(storyContent);
+  const selected = visibleSections.flatMap((title) => {
+    const section5 = parsed.sections.get(normalizeHeading(title));
+    return section5 ? [section5] : [];
+  });
+  return [parsed.preamble, ...selected].map((part) => part.trim()).filter((part) => part.length > 0).join("\n\n");
+}
+function parseStorySections(storyContent) {
+  const normalized = storyContent.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  const sections = /* @__PURE__ */ new Map();
+  const preambleLines = [];
+  let activeSectionTitle;
+  let activeSectionLines = [];
+  for (const line of lines) {
+    const heading = parseKnownSectionHeading(line);
+    if (heading) {
+      flushActiveSection();
+      activeSectionTitle = heading.normalizedTitle;
+      activeSectionLines = [line];
+      continue;
+    }
+    if (activeSectionTitle) {
+      activeSectionLines.push(line);
+    } else {
+      preambleLines.push(line);
+    }
+  }
+  flushActiveSection();
+  return {
+    preamble: preambleLines.join("\n"),
+    sections
+  };
+  function flushActiveSection() {
+    if (!activeSectionTitle) {
+      return;
+    }
+    sections.set(activeSectionTitle, activeSectionLines.join("\n"));
+    activeSectionTitle = void 0;
+    activeSectionLines = [];
+  }
+}
+function parseKnownSectionHeading(line) {
+  const match = /^(#{2,6})\s+(.+?)\s*$/u.exec(line.trim());
+  if (!match) {
+    return void 0;
+  }
+  const normalizedTitle = normalizeHeading(match[2] ?? "");
+  return KNOWN_SECTION_TITLES.has(normalizedTitle) ? { normalizedTitle } : void 0;
+}
+function normalizeHeading(value) {
+  return value.trim().replace(/\s+/g, " ").toLowerCase();
+}
+
+// src/feature-implementation/review-story-implementation/prompt.ts
+var REVIEW_RUBRIC = [
+  "Score 4-5 only when the active story is complete, well-tested, scoped, and integrated with local conventions.",
+  "Score below 4 for missing acceptance criteria, weak/missing behavioral-red evidence, unsafe diff isolation, broken validation, broad unrelated changes, or poor integration.",
+  "Scores below 4 must include specific requiredImprovements for the next retry."
+].join("\n");
+function reviewStoryImplementationPrompt({
+  input
+}) {
+  const baseline = input.gitContext.storyStartCommit ?? "MISSING";
+  const committedDiffCommand = input.gitContext.storyStartCommit ? `git diff ${input.gitContext.storyStartCommit}..HEAD` : "git diff <missing-story-start-commit>..HEAD";
+  return promptSections(
+    section(
+      "Role",
+      "You are the story reviewer: inspect only the isolated active-story change set. This is a read-only review; do not edit, do not stage, do not commit, do not clean, and do not run tests."
+    ),
+    section("Review rubric", REVIEW_RUBRIC),
+    section("Story review view", storyViewForReviewer(input.currentStory.content)),
+    section("Implementation context", input.implementationContext),
+    section("Exploration summary", input.explorationSummary ?? "Not provided."),
+    section("Red-test summary", input.redTestSummary ?? "Not provided."),
+    section("Red-test evidence", input.redEvidence ?? "Not provided."),
+    section("Implementer summary", input.implementationSummary ?? "Not provided."),
+    section("Validation summary", input.validationSummary ?? "Not provided."),
+    section("Validation commands/results", formatCommandResults(input.validationCommands ?? [])),
+    section(
+      "Story review git metadata",
+      [
+        `Recorded story start commit: ${baseline}`,
+        "",
+        "Changed files:",
+        formatList(input.gitContext.changedFiles),
+        "",
+        "Committed changed files:",
+        formatList(input.gitContext.committedChangedFiles),
+        "",
+        "Uncommitted changed files:",
+        formatList(input.gitContext.uncommittedChangedFiles),
+        "",
+        "Committed diffstat (`git diff --stat <storyStartCommit>..HEAD`):",
+        input.gitContext.committedDiffStat || "Not available.",
+        "",
+        "Uncommitted diffstat (`git diff --stat`):",
+        input.gitContext.uncommittedDiffStat || "Not available.",
+        "",
+        "Working tree status (`git status --short`):",
+        input.gitContext.statusShort || "Not available.",
+        input.gitContext.warnings.length > 0 ? [
+          "",
+          "Warnings / blocked context:",
+          ...input.gitContext.warnings.map((warning) => `- ${warning}`)
+        ].join("\n") : ""
+      ].filter((line) => line.length > 0).join("\n")
+    ),
+    section(
+      "Read-only local inspection commands",
+      [
+        "Run only read-only inspection commands if local verification is needed; inspect only, and do not edit, do not stage, do not commit, do not clean, and do not run tests:",
+        "- `git status --short`",
+        `- \`${committedDiffCommand}\``,
+        "- `git diff`",
+        "Use the captured validation commands/results above; do not run tests yourself."
+      ].join("\n")
+    ),
+    section(
+      "Task",
+      "Review only the active story slice represented by the recorded story start commit through HEAD, plus the current uncommitted working tree changes, against the story above and the phase summaries. Use the metadata above first; if you need to inspect locally, use read-only commands only (`git status --short`, the listed committed `git diff <storyStartCommit>..HEAD`, and `git diff`) \u2014 do not run tests, do not edit code, do not stage files, do not commit files, do not revert files, do not clean files, and do not try to isolate the diff by changing the repository. If unrelated dirty files, a missing/invalid baseline, or ambiguous context prevents a trustworthy review, say so in the structured review and require the implementer/workflow to fix the isolation; never remove changes yourself. Respond only with the structured review."
+    )
+  );
+}
+function formatList(items) {
+  if (items.length === 0) {
+    return "- None";
+  }
+  return items.map((item) => `- ${item}`).join("\n");
+}
+function formatCommandResults(commands) {
+  if (commands.length === 0) {
+    return "- Not provided.";
+  }
+  return commands.map((item) => `- \`${item.command}\`: ${item.result}`).join("\n");
+}
+
+// src/feature-implementation/review-story-implementation/step.ts
+var reviewStoryImplementationStep = step3({ id: "review-story-implementation" }).prompt(reviewStoryImplementationPrompt, {
+  agent: "storyReviewer",
+  output: reviewOutput
+}).do(async (review, input) => {
+  await state4.set(STORY_STATE_KEYS.latestReviewResult, review);
+  if (!reviewPasses(review)) {
+    const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+    return storyRouterStep2({ reason: "failed-review", currentStory: input.currentStory });
+  }
+  return commitReviewedStoryStep({
+    currentStory: input.currentStory,
+    implementationSummary: input.implementationSummary
+  });
+});
+
+// src/feature-implementation/validate-story/validation-runner.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+var execFileAsync3 = promisify3(execFile3);
+var MAX_COMMANDS = 5;
+var COMMAND_TIMEOUT_MS = 12e4;
+var OUTPUT_LIMIT = 4e3;
+var MAX_BUFFER = 256 * 1024;
+var ALLOWED_COMMANDS = /* @__PURE__ */ new Set(["pnpm", "npm", "node", "git", "./trailstep-dev.sh"]);
+var BROAD_PACKAGE_MANAGER_SCRIPTS = /* @__PURE__ */ new Set(["test", "typecheck", "lint", "build"]);
+var SHELL_META_CHARS = /* @__PURE__ */ new Set(["|", "&", ";", "<", ">", "(", ")"]);
+async function runFocusedStoryValidation(input) {
+  const commands = collectValidationCommands(input.validationInput, input.implementationContext);
+  if (commands.length === 0) {
+    return {
+      blocked: true,
+      blockedReason: "No focused validation commands were found in the story or exploration context.",
+      summary: "Validation blocked: no focused validation commands were found.",
+      commands: [],
+      validationPassed: false
+    };
+  }
+  const results = [];
+  for (const command of commands.slice(0, MAX_COMMANDS)) {
+    results.push(await runValidationCommand(command, input.cwd));
+  }
+  const skipped2 = results.filter((result) => isSkippedResult(result.result));
+  const failed = results.filter((result) => isFailedResult(result.result));
+  const passed = results.filter((result) => isPassedResult(result.result));
+  const validationPassed = failed.length === 0 && passed.length > 0;
+  const blocked = passed.length === 0 && skipped2.length === results.length;
+  return {
+    blocked,
+    blockedReason: blocked ? "All focused validation commands were rejected or skipped." : void 0,
+    summary: summarizeValidationResults({ passed, failed, skipped: skipped2, total: results.length }),
+    commands: results,
+    validationPassed
+  };
+}
+function collectValidationCommands(input, implementationContext) {
+  return uniqueCommands([
+    ...extractValidationCommandLines(input.currentStory.content),
+    ...extractValidationCommandLines(implementationContext ?? ""),
+    ...input.explorationBrief?.recommendedValidationCommands ?? []
+  ]);
+}
+async function runValidationCommand(command, cwd) {
+  const parsed = parseCommand(command);
+  if (parsed.ok === false) {
+    return { command, result: `skipped: ${parsed.reason}` };
+  }
+  const allowed = validateAllowedCommand(parsed.argv);
+  if (allowed.ok === false) {
+    return { command, result: `skipped: ${allowed.reason}` };
+  }
+  if (!cwd) {
+    return { command, result: "skipped: workflow cwd is unavailable" };
+  }
+  try {
+    const executable = executableForPlatform(parsed.argv[0] ?? "");
+    const { stdout, stderr } = await execFileAsync3(executable, parsed.argv.slice(1), {
+      cwd,
+      timeout: COMMAND_TIMEOUT_MS,
+      maxBuffer: MAX_BUFFER,
+      shell: requiresWindowsCommandShell(executable),
+      windowsHide: true
+    });
+    const output = formatCommandOutput(stdout, stderr);
+    return { command, result: `passed${output ? `: ${output}` : ""}` };
+  } catch (error) {
+    return { command, result: `failed: ${formatExecutionError(error)}` };
+  }
+}
+function executableForPlatform(executable) {
+  if (process.platform !== "win32") {
+    return executable;
+  }
+  if (executable === "pnpm" || executable === "npm") {
+    return `${executable}.cmd`;
+  }
+  return executable;
+}
+function requiresWindowsCommandShell(executable) {
+  return process.platform === "win32" && executable.toLowerCase().endsWith(".cmd");
+}
+function extractValidationCommandLines(content) {
+  const normalized = content.replace(/\r\n?/g, "\n");
+  const lines = normalized.split("\n");
+  const commands = [];
+  let inValidationSection = false;
+  for (const line of lines) {
+    if (/^#{2,6}\s+Validation Commands\s*$/iu.test(line.trim())) {
+      inValidationSection = true;
+      continue;
+    }
+    if (inValidationSection && /^#{2,6}\s+/u.test(line.trim())) {
+      break;
+    }
+    if (!inValidationSection) {
+      continue;
+    }
+    const command = normalizeCommandLine(line);
+    if (command) {
+      commands.push(command);
+    }
+  }
+  return commands;
+}
+function normalizeCommandLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed === "Not provided.") {
+    return null;
+  }
+  const withoutFence = trimmed.replace(/^```(?:sh|bash|shell)?\s*/iu, "").replace(/```$/u, "");
+  const listMatch = /^(?:[-*+]\s+|\d+[.)]\s+)?(?:`([^`]+)`|(.+))$/u.exec(withoutFence.trim());
+  const command = (listMatch?.[1] ?? listMatch?.[2] ?? withoutFence).trim();
+  return command.length > 0 ? command : null;
+}
+function parseCommand(command) {
+  const argv = [];
+  let current = "";
+  let quote = null;
+  for (let index = 0; index < command.length; index += 1) {
+    const char = command[index] ?? "";
+    if (!quote && SHELL_META_CHARS.has(char)) {
+      return { ok: false, reason: `shell metacharacter '${char}' is not allowlisted` };
+    }
+    if (!quote && char === "$" && command[index + 1] === "(") {
+      return { ok: false, reason: "command substitution is not allowlisted" };
+    }
+    if (char === "`") {
+      return { ok: false, reason: "backtick command substitution is not allowlisted" };
+    }
+    if (quote) {
+      if (char === quote) {
+        quote = null;
+      } else {
+        current += char;
+      }
+      continue;
+    }
+    if (char === "'" || char === '"') {
+      quote = char;
+      continue;
+    }
+    if (/\s/u.test(char)) {
+      if (current.length > 0) {
+        argv.push(current);
+        current = "";
+      }
+      continue;
+    }
+    current += char;
+  }
+  if (quote) {
+    return { ok: false, reason: "unterminated quoted argument" };
+  }
+  if (current.length > 0) {
+    argv.push(current);
+  }
+  if (argv.length === 0) {
+    return { ok: false, reason: "empty command" };
+  }
+  return { ok: true, argv };
+}
+function validateAllowedCommand(argv) {
+  const executable = argv[0] ?? "";
+  if (!ALLOWED_COMMANDS.has(executable)) {
+    return { ok: false, reason: `command '${executable}' is not allowlisted` };
+  }
+  if (executable === "git") {
+    return validateGitCommand(argv);
+  }
+  if ((executable === "pnpm" || executable === "npm") && isBroadPackageManagerCommand(argv)) {
+    return {
+      ok: false,
+      reason: "broad package validation belongs to final validation; add --filter, a package path, or a specific test file for story validation"
+    };
+  }
+  return { ok: true };
+}
+function validateGitCommand(argv) {
+  const subcommand = argv[1];
+  if (subcommand === "status" || subcommand === "diff" || subcommand === "rev-parse") {
+    return { ok: true };
+  }
+  return { ok: false, reason: `git subcommand '${subcommand ?? ""}' is not allowlisted` };
+}
+function isBroadPackageManagerCommand(argv) {
+  const scriptIndex = firstPackageManagerScriptIndex(argv);
+  if (scriptIndex < 0) {
+    return false;
+  }
+  const script = argv[scriptIndex];
+  if (!script || !BROAD_PACKAGE_MANAGER_SCRIPTS.has(script)) {
+    return false;
+  }
+  const args = argv.slice(1);
+  if (args.includes("--filter") || args.includes("-F") || args.some((arg) => arg.startsWith("--filter="))) {
+    return false;
+  }
+  const trailing = argv.slice(scriptIndex + 1);
+  return !trailing.some(isFocusedValidationArgument);
+}
+function firstPackageManagerScriptIndex(argv) {
+  const runIndex = argv.indexOf("run");
+  if (runIndex >= 0) {
+    return runIndex + 1;
+  }
+  return argv.findIndex((arg, index) => index > 0 && BROAD_PACKAGE_MANAGER_SCRIPTS.has(arg));
+}
+function isFocusedValidationArgument(arg) {
+  return arg.includes("/") || arg.includes("\\") || /\.(?:test|spec)\.[cm]?[tj]sx?$/u.test(arg) || arg.endsWith(".ts") || arg.endsWith(".tsx") || arg.startsWith("--testNamePattern") || arg.startsWith("-t");
+}
+function uniqueCommands(commands) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = [];
+  for (const command of commands.map((item) => normalizeCommandLine(item) ?? "")) {
+    if (command && !seen.has(command)) {
+      seen.add(command);
+      unique.push(command);
+    }
+  }
+  return unique;
+}
+function formatCommandOutput(stdout, stderr) {
+  return truncate([stdout.trim(), stderr.trim()].filter(Boolean).join("\n"));
+}
+function formatExecutionError(error) {
+  if (typeof error !== "object" || error === null) {
+    return truncate(String(error));
+  }
+  const maybeError = error;
+  const prefix = maybeError.killed ? `timed out after ${COMMAND_TIMEOUT_MS}ms` : `exit ${maybeError.code ?? maybeError.signal ?? "unknown"}`;
+  const output = formatCommandOutput(maybeError.stdout ?? "", maybeError.stderr ?? "");
+  return truncate(
+    output ? `${prefix}; ${output}` : `${prefix}; ${maybeError.message ?? "command failed"}`
+  );
+}
+function summarizeValidationResults(input) {
+  if (input.failed.length > 0) {
+    return `Focused validation failed: ${input.failed.length}/${input.total} command(s) failed, ${input.passed.length} passed, ${input.skipped.length} skipped.`;
+  }
+  if (input.passed.length > 0) {
+    return `Focused validation passed: ${input.passed.length}/${input.total} command(s) passed, ${input.skipped.length} skipped.`;
+  }
+  return `Focused validation skipped: ${input.skipped.length}/${input.total} command(s) were rejected or skipped.`;
+}
+function isPassedResult(result) {
+  return result.startsWith("passed");
+}
+function isFailedResult(result) {
+  return result.startsWith("failed");
+}
+function isSkippedResult(result) {
+  return result.startsWith("skipped");
+}
+function truncate(value) {
+  return value.length > OUTPUT_LIMIT ? `${value.slice(0, OUTPUT_LIMIT)}\u2026 [truncated]` : value;
+}
+
+// src/feature-implementation/validate-story/step.ts
+var validateStoryStep = step4({ id: "validate-story" }).do(
+  async (input) => {
+    const promptOutput = await runFocusedStoryValidation({
+      validationInput: input,
+      cwd: state5.cwd,
+      implementationContext: await loadStoryPhaseContext("validate-story")
+    });
+    await state5.set(STORY_STATE_KEYS.latestValidationSummary, promptOutput);
+    if (promptOutput.blocked) {
+      await state5.set(
+        STORY_STATE_KEYS.blockedReason,
+        promptOutput.blockedReason ?? "Story validation reported a blocked state."
+      );
+      const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+      return storyRouterStep2({
+        reason: {
+          type: "blocked",
+          sourceReason: "failed-validation",
+          blockedPhase: "validate-story",
+          blockedReason: promptOutput.blockedReason ?? "Story validation reported a blocked state.",
+          code: "story_validation_blocked",
+          metadata: { validation: promptOutput }
+        },
+        currentStory: input.currentStory
+      });
+    }
+    if (!promptOutput.validationPassed) {
+      const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+      return storyRouterStep2({ reason: "failed-validation", currentStory: input.currentStory });
+    }
+    await state5.set(STORY_STATE_KEYS.activePhase, "review-story-implementation");
+    await incrementStoryPhaseAttempt("review-story-implementation");
+    return reviewStoryImplementationStep({
+      currentStory: input.currentStory,
+      attempt: input.attempt,
+      implementationContext: await loadStoryPhaseContext("review-story-implementation"),
+      implementationSummary: input.implementationSummary?.summary,
+      explorationSummary: input.explorationBrief?.summary,
+      redTestSummary: input.redTestSummary?.summary,
+      redEvidence: input.redTestSummary?.redEvidence,
+      validationSummary: promptOutput.summary,
+      validationCommands: promptOutput.commands,
+      gitContext: await loadStoryReviewGitContext()
+    });
+  }
+);
+
+// src/feature-implementation/implement-green/prompt.ts
+import { jsonSchema as jsonSchema4, promptSections as promptSections2, section as section2 } from "@trailstep/authoring";
+var implementGreenOutput = jsonSchema4({
+  type: "object",
+  properties: {
+    blocked: { type: "boolean" },
+    blockedReason: { type: "string" },
+    summary: { type: "string" },
+    changedFiles: { type: "array", items: { type: "string" } }
+  },
+  required: ["blocked", "summary", "changedFiles"],
+  additionalProperties: false
+});
+function implementGreenPrompt({ input }) {
+  const validationCommandEvidence = (input.failedValidationCommands ?? []).map(({ command, result }) => `- ${command}: ${result}`).join("\n");
+  return promptSections2(
+    section2(
+      "Role",
+      "You are the green implementer. Make the smallest production change that satisfies the focused red test; do not broaden scope."
+    ),
+    section2(
+      "Active story implementation view",
+      storyViewForImplementer(input.currentStory.content)
+    ),
+    section2("Implementation context", input.implementationContext),
+    section2("Exploration summary", input.explorationBrief?.summary ?? "Not provided."),
+    section2("Red-test summary", input.redTestSummary?.summary ?? "Not provided."),
+    section2("Red evidence", input.redTestSummary?.redEvidence ?? "Not provided."),
+    input.previousReviewSummary ? section2(
+      "Previous review summary",
+      `${input.previousReviewSummary}
+
+Required improvements:
+${(input.requiredImprovements ?? []).map((item) => `- ${item}`).join("\n") || "- None"}`
+    ) : "",
+    input.failedValidationSummary ? section2(
+      "Previous validation failure",
+      `${input.failedValidationSummary}
+
+Command evidence:
+${validationCommandEvidence || "- Not provided."}`
+    ) : "",
+    section2(
+      "Task",
+      [
+        "Implement the smallest production-code slice needed to make the focused behavioral red test pass.",
+        "Preserve the red test and avoid broad refactoring until the focused behavior is green.",
+        "Do not write new unrelated stories, broad polish, or accumulated-diff cleanup.",
+        "Run the focused green test when feasible and summarize files changed plus concise evidence.",
+        "When this prompt includes a previous validation failure, treat that failure as the primary task: fix the root cause and rerun the failing command when feasible before returning.",
+        "Do not claim the story is complete if focused validation is still red; either keep fixing it or set `blocked: true` with a concrete reason.",
+        "If implementation is unsafe or ambiguous, set `blocked: true` and explain why."
+      ].join("\n")
+    )
+  );
+}
+
+// src/feature-implementation/implement-green/step.ts
+var implementGreenStep = step5({ id: "implement-green" }).prompt(implementGreenPrompt, {
+  agent: "storyImplementer",
+  output: implementGreenOutput
+}).do(async (promptOutput, input) => {
+  if (promptOutput.blocked) {
+    await state6.set(
+      STORY_STATE_KEYS.blockedReason,
+      promptOutput.blockedReason ?? "Green implementation reported a blocked state."
+    );
+    const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+    return storyRouterStep2({
+      reason: {
+        type: "blocked",
+        sourceReason: "failed-implementation",
+        blockedPhase: "implement-green",
+        blockedReason: promptOutput.blockedReason ?? "Green implementation reported a blocked state.",
+        code: "story_green_blocked"
+      },
+      currentStory: input.currentStory
+    });
+  }
+  await state6.set(STORY_STATE_KEYS.latestImplementationSummary, promptOutput);
+  await state6.set(STORY_STATE_KEYS.activePhase, "validate-story");
+  const attempt = await incrementStoryPhaseAttempt("validate-story");
+  return validateStoryStep({
+    currentStory: input.currentStory,
+    explorationBrief: input.explorationBrief,
+    redTestSummary: input.redTestSummary,
+    implementationSummary: promptOutput,
+    attempt,
+    implementationContext: await loadStoryPhaseContext("validate-story")
+  });
+});
+
+// src/feature-implementation/story-doctor/step.ts
+import { state as state7, step as step6 } from "@trailstep/authoring";
+
+// src/feature-implementation/story-doctor/prompt.ts
+import { jsonSchema as jsonSchema5, promptSections as promptSections3, section as section3 } from "@trailstep/authoring";
+var storyDoctorOutput = jsonSchema5({
+  type: "object",
+  properties: {
+    blocked: { type: "boolean" },
+    blockedReason: { type: "string" },
+    summary: { type: "string" },
+    changedFiles: { type: "array", items: { type: "string" } }
+  },
+  required: ["blocked", "summary", "changedFiles"],
+  additionalProperties: false
+});
+function storyDoctorPrompt({ input }) {
+  const commandEvidence = input.failedValidationCommands.map(({ command, result }) => `- ${command}: ${result}`).join("\n");
+  return promptSections3(
+    section3(
+      "Role",
+      "You are the story doctor: a senior recovery agent invoked only after repeated validation failures. Diagnose the actual failing behavior, repair the active story implementation, and do not broaden scope."
+    ),
+    section3(
+      "Active story implementation view",
+      storyViewForImplementer(input.currentStory.content)
+    ),
+    section3("Exploration summary", input.explorationBrief?.summary ?? "Not provided."),
+    section3("Red-test summary", input.redTestSummary?.summary ?? "Not provided."),
+    section3("Red evidence", input.redTestSummary?.redEvidence ?? "Not provided."),
+    section3(
+      "Latest implementation summary",
+      input.implementationSummary?.summary ?? "Not provided."
+    ),
+    section3(
+      "Repeated validation failure",
+      [
+        `Validation failure count consumed by the router: ${input.validationRetryCount}/${input.retryLimit}.`,
+        input.failedValidationSummary,
+        "",
+        "Command evidence:",
+        commandEvidence || "- Not provided."
+      ].join("\n")
+    ),
+    section3(
+      "Task",
+      [
+        "Find and fix the root cause of the repeated validation failure for this active story only.",
+        "Run the focused failing validation command when feasible before returning.",
+        "Do not claim success unless the focused validation is green or you clearly explain why it cannot be made green.",
+        "If the story is unsafe, ambiguous, or cannot be repaired without unrelated redesign, set `blocked: true` with a concrete `blockedReason`.",
+        "Return a concise summary, changed files, and no full logs or diff hunks."
+      ].join("\n")
+    )
+  );
+}
+
+// src/feature-implementation/story-doctor/step.ts
+var storyDoctorStep = step6({ id: "story-doctor" }).prompt(storyDoctorPrompt, {
+  agent: "storyDoctor",
+  output: storyDoctorOutput
+}).do(async (promptOutput, input) => {
+  if (promptOutput.blocked) {
+    await state7.set(
+      STORY_STATE_KEYS.blockedReason,
+      promptOutput.blockedReason ?? "Story doctor reported a blocked state."
+    );
+    const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+    return storyRouterStep2({
+      reason: {
+        type: "blocked",
+        sourceReason: "failed-implementation",
+        blockedPhase: "implement-green",
+        blockedReason: promptOutput.blockedReason ?? "Story doctor reported a blocked state.",
+        code: "story_doctor_blocked"
+      },
+      currentStory: input.currentStory
+    });
+  }
+  await state7.set(STORY_STATE_KEYS.latestImplementationSummary, promptOutput);
+  await state7.set(STORY_STATE_KEYS.latestStoryRouterState, null);
+  await state7.set(STORY_STATE_KEYS.activePhase, "validate-story");
+  const attempt = await incrementStoryPhaseAttempt("validate-story");
+  return validateStoryStep({
+    currentStory: input.currentStory,
+    explorationBrief: input.explorationBrief,
+    redTestSummary: input.redTestSummary,
+    implementationSummary: promptOutput,
+    attempt
+  });
+});
+
+// src/feature-implementation/story-isolation-preflight/step.ts
+import { fail as fail2, state as state10, step as step9 } from "@trailstep/authoring";
+
+// src/feature-implementation/deterministic-context-preflight/step.ts
+import { access, readFile } from "fs/promises";
+import { isAbsolute, join, relative } from "path";
+import { state as state9, step as step8 } from "@trailstep/authoring";
+
+// src/feature-implementation/write-red-tests/step.ts
+import { state as state8, step as step7 } from "@trailstep/authoring";
+
+// src/feature-implementation/write-red-tests/prompt.ts
+import { jsonSchema as jsonSchema6, promptSections as promptSections4, section as section4 } from "@trailstep/authoring";
+var writeRedTestsOutput = jsonSchema6({
+  type: "object",
+  properties: {
+    blocked: { type: "boolean" },
+    blockedReason: { type: "string" },
+    summary: { type: "string" },
+    redEvidence: { type: "string" },
+    changedFiles: { type: "array", items: { type: "string" } }
+  },
+  required: ["blocked", "summary", "redEvidence", "changedFiles"],
+  additionalProperties: false
+});
+function writeRedTestsPrompt({ input }) {
+  return promptSections4(
+    section4(
+      "Role",
+      "You are the red-test writer. Create focused behavioral failing tests; do not implement production behavior or review the story."
+    ),
+    section4("Active story test view", storyViewForTestWriter(input.currentStory.content)),
+    section4("Implementation context", input.implementationContext),
+    section4("Exploration summary", input.explorationBrief?.summary ?? "Not provided."),
+    section4(
+      "Exploration test seams",
+      input.explorationBrief?.testSeams?.map((item) => `- ${item}`).join("\n") ?? "Not provided."
+    ),
+    section4(
+      "Task",
+      [
+        "Write or update the focused behavioral red test for only this active story.",
+        "The test must fail for the intended product/integration behavior before green implementation.",
+        "Do not implement production code except the absolute minimum needed to compile the red test harness.",
+        "Run the focused red test when feasible and report only the command plus concise failing evidence in `redEvidence`.",
+        "Do not include unrelated stories, green implementation work, or review scoring.",
+        "If a safe red test cannot be written, set `blocked: true` and explain why."
+      ].join("\n")
+    )
+  );
+}
+
+// src/feature-implementation/write-red-tests/step.ts
+var writeRedTestsStep = step7({ id: "write-red-tests" }).prompt(writeRedTestsPrompt, {
+  agent: "testWriter",
+  output: writeRedTestsOutput
+}).do(async (promptOutput, input) => {
+  if (promptOutput.blocked) {
+    await state8.set(
+      STORY_STATE_KEYS.blockedReason,
+      promptOutput.blockedReason ?? "Red-test phase reported a blocked state."
+    );
+    const { storyRouterStep: storyRouterStep2 } = await import("./step-ZAE3Y7FI.js");
+    return storyRouterStep2({
+      reason: {
+        type: "blocked",
+        sourceReason: "failed-red-tests",
+        blockedPhase: "write-red-tests",
+        blockedReason: promptOutput.blockedReason ?? "Red-test phase reported a blocked state.",
+        code: "story_red_tests_blocked"
+      },
+      currentStory: input.currentStory
+    });
+  }
+  await state8.set(STORY_STATE_KEYS.latestRedTestSummary, promptOutput);
+  await state8.set(STORY_STATE_KEYS.activePhase, "implement-green");
+  const attempt = await incrementStoryPhaseAttempt("implement-green");
+  return implementGreenStep({
+    currentStory: input.currentStory,
+    explorationBrief: input.explorationBrief,
+    redTestSummary: promptOutput,
+    attempt,
+    implementationContext: await loadStoryPhaseContext("implement-green")
+  });
+});
+
+// src/feature-implementation/deterministic-context-preflight/step.ts
+var DEFAULT_VALIDATION_COMMANDS = ["pnpm test", "pnpm typecheck", "pnpm lint"];
+var MAX_ITEMS = 12;
+var deterministicContextPreflightStep = step8({ id: "deterministic-context-preflight" }).do(
+  async ({
+    currentStory,
+    implementationContext
+  }) => {
+    await state9.set(STORY_STATE_KEYS.activePhase, "deterministic-context-preflight");
+    await incrementStoryPhaseAttempt("deterministic-context-preflight");
+    const brief = await buildDeterministicContextPreflightBrief({
+      currentStory,
+      implementationContext,
+      cwd: state9.cwd
+    });
+    await state9.set(STORY_STATE_KEYS.latestExplorationBrief, brief);
+    await state9.set(STORY_STATE_KEYS.activePhase, "write-red-tests");
+    const attempt = await incrementStoryPhaseAttempt("write-red-tests");
+    return writeRedTestsStep({
+      currentStory,
+      explorationBrief: brief,
+      attempt,
+      implementationContext: await loadStoryPhaseContext("write-red-tests")
+    });
+  }
+);
+async function buildDeterministicContextPreflightBrief({
+  currentStory,
+  implementationContext,
+  cwd
+}) {
+  const sourceText = [currentStory.path, currentStory.content, implementationContext].filter(Boolean).join("\n");
+  const relevantFiles = uniqueBounded([
+    normalizeFileHint(currentStory.path, cwd),
+    ...extractPathHints(sourceText),
+    ...extractPathHints(implementationContext ?? "")
+  ]);
+  const packageHints = uniqueBounded(await packageHintsForFiles(relevantFiles, cwd));
+  const symbols = uniqueBounded(extractSymbolHints(sourceText));
+  const searchHints = uniqueBounded([
+    ...symbols.slice(0, 6).map((symbol) => `rg ${shellQuote2(symbol)}`),
+    relevantFiles.length === 0 && symbols.length === 0 ? "rg focused story keywords from the Goal and Acceptance Criteria" : void 0
+  ]);
+  const explicitValidationCommands = extractValidationCommands(sourceText);
+  const focusedValidationHints = uniqueBounded([
+    ...explicitValidationCommands,
+    ...packageHints.flatMap((filter) => [
+      `pnpm --filter ${filter} test`,
+      `pnpm --filter ${filter} typecheck`,
+      `pnpm --filter ${filter} lint`
+    ]),
+    ...packageHints.length === 0 ? DEFAULT_VALIDATION_COMMANDS : []
+  ]);
+  const graphifyHint = cwd ? await graphifyAvailable(cwd) : false;
+  const relevantFileText = relevantFiles.length > 0 ? relevantFiles.join(", ") : "none detected";
+  const packageText = packageHints.length > 0 ? packageHints.join(", ") : "none detected";
+  const symbolText = symbols.length > 0 ? symbols.join(", ") : "none detected";
+  const contextHints = uniqueBounded(extractContextHints(implementationContext ?? ""), 4);
+  const contextText = contextHints.length > 0 ? ` Context hints: ${contextHints.join("; ")}.` : "";
+  const graphText = graphifyHint ? "graphify appears available; use graphify query before broad grep for structural questions." : "graphify availability was not detected; use focused rg hints if more context is needed.";
+  return {
+    blocked: false,
+    summary: `Deterministic context preflight completed without blocking. Likely files: ${relevantFileText}. Package/filter hints: ${packageText}. Symbols: ${symbolText}.${contextText} ${graphText}`,
+    relevantFiles,
+    testSeams: uniqueBounded([
+      ...extractSectionBullets(sourceText, [
+        "red phase",
+        "acceptance criteria",
+        "validation commands"
+      ]),
+      ...symbols.map((symbol) => `Behavior around ${symbol}`),
+      ...searchHints
+    ]),
+    recommendedValidationCommands: focusedValidationHints,
+    packageHints,
+    symbols,
+    searchHints: uniqueBounded([
+      ...graphifyHint ? [
+        `graphify query ${shellQuote2(`Where is ${symbols[0] ?? currentStory.path} implemented or tested?`)}`
+      ] : [],
+      ...searchHints
+    ]),
+    focusedValidationHints
+  };
+}
+function extractPathHints(text) {
+  const candidates = [];
+  const pathPattern = /(?:^|[\s('"`])((?:\.{1,2}\/)?(?:packages|src|docs|scripts|test|tests|\.github|\.pi)\/[A-Za-z0-9_./-]+|[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|json|md|mjs|cjs|svelte|css|yml|yaml))/gmu;
+  for (const match of text.matchAll(pathPattern)) {
+    const candidate = sanitizePathCandidate(match[1]);
+    if (candidate) {
+      candidates.push(candidate);
+    }
+  }
+  return candidates;
+}
+function sanitizePathCandidate(candidate) {
+  const cleaned = candidate?.trim().replace(/[),.;:]+$/u, "").replace(/^`|`$/gu, "");
+  if (!cleaned || cleaned.includes("://") || cleaned.includes("../") || /^[A-Za-z]:/u.test(cleaned)) {
+    return void 0;
+  }
+  return cleaned.replace(/\\/gu, "/");
+}
+function normalizeFileHint(path, cwd) {
+  const normalizedPath = path.replace(/\\/gu, "/");
+  if (!cwd || !isAbsolute(path)) {
+    return normalizedPath;
+  }
+  const relativePath = relative(cwd, path).replace(/\\/gu, "/");
+  return relativePath.length > 0 && !relativePath.startsWith("../") ? relativePath : normalizedPath;
+}
+function extractSymbolHints(text) {
+  const symbols = [];
+  for (const match of text.matchAll(/`([^`\n]{3,80})`/gmu)) {
+    const token = match[1]?.trim();
+    if (token && !token.includes(" ") && !token.includes("/")) {
+      symbols.push(token);
+    }
+  }
+  for (const match of text.matchAll(/\b[A-Z][A-Za-z0-9]*(?:[A-Z][A-Za-z0-9]*)+\b/gmu)) {
+    if (match[0].length <= 80) {
+      symbols.push(match[0]);
+    }
+  }
+  return symbols;
+}
+function extractContextHints(text) {
+  return text.split(/\r?\n/u).map((line) => line.replace(/^\s*[-*]\s*/u, "").trim()).filter((line) => line.length > 0 && !/^[A-Za-z-]+:\s*/u.test(line));
+}
+function extractValidationCommands(text) {
+  return uniqueBounded(
+    text.split(/\r?\n/u).map((line) => line.replace(/^\s*[-*]\s*/u, "").trim()).filter((line) => /\b(pnpm|npm|yarn|vitest|tsc|biome|node)\b/u.test(line)).map((line) => line.replace(/^`|`$/gu, ""))
+  );
+}
+function extractSectionBullets(text, sectionTitles) {
+  const normalizedTitles = new Set(sectionTitles.map((title) => title.toLowerCase()));
+  const lines = text.replace(/\r\n?/gu, "\n").split("\n");
+  const bullets = [];
+  let active = false;
+  for (const line of lines) {
+    const heading = /^#{2,6}\s+(.+?)\s*$/u.exec(line.trim());
+    if (heading) {
+      active = normalizedTitles.has((heading[1] ?? "").trim().toLowerCase());
+      continue;
+    }
+    if (!active) {
+      continue;
+    }
+    const bullet = /^\s*[-*]\s+(.+)$/u.exec(line);
+    if (bullet?.[1]) {
+      bullets.push(bullet[1].trim());
+    }
+  }
+  return bullets;
+}
+async function packageHintsForFiles(files, cwd) {
+  const packageDirs = uniqueBounded(
+    files.flatMap((file) => {
+      const normalizedFile = file.replace(/\\/gu, "/");
+      const match = /^packages\/([^/]+)/u.exec(normalizedFile);
+      return match?.[1] ? [`packages/${match[1]}`] : [];
+    })
+  );
+  const hints = [];
+  for (const packageDir of packageDirs) {
+    const packageJsonPath = cwd ? join(cwd, packageDir, "package.json") : void 0;
+    const packageName = packageJsonPath ? await readPackageName(packageJsonPath) : void 0;
+    hints.push(packageName ?? packageDir);
+  }
+  return hints;
+}
+async function readPackageName(packageJsonPath) {
+  try {
+    const parsed = JSON.parse(await readFile(packageJsonPath, "utf8"));
+    return typeof parsed.name === "string" ? parsed.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+async function graphifyAvailable(cwd) {
+  try {
+    await access(join(cwd, "graphify-out", "graph.json"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+function uniqueBounded(items, max = MAX_ITEMS) {
+  const values = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of items) {
+    if (item === void 0 || item === null) {
+      continue;
+    }
+    const key = String(item);
+    if (key.length === 0 || seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    values.push(item);
+    if (values.length >= max) {
+      break;
+    }
+  }
+  return values;
+}
+function shellQuote2(value) {
+  return JSON.stringify(value);
+}
+
+// src/feature-implementation/story-isolation-preflight/step.ts
+var storyIsolationPreflightStep = step9({ id: "story-isolation-preflight" }).do(
+  async ({ currentStory }) => {
+    const result = await runStoryIsolationPreflight(currentStory);
+    if (!result.ok) {
+      return result.failure;
+    }
+    const implementationContext = await loadStoryPhaseContext("deterministic-context-preflight");
+    return deterministicContextPreflightStep({ currentStory, implementationContext });
+  }
+);
+async function runStoryIsolationPreflight(currentStory) {
+  const completedReplay = await loadCompletedReplayPreflightState(currentStory);
+  if (completedReplay) {
+    await state10.set(STORY_STATE_KEYS.activePhase, "story-isolation-preflight");
+    await state10.set(STORY_STATE_KEYS.storyBaseline, completedReplay.baseline);
+    await state10.set(STORY_STATE_KEYS.activeStoryStartCommit, { commit: completedReplay.baseline });
+    await state10.set(STORY_STATE_KEYS.latestPreflightStatus, {
+      ok: true,
+      code: "story_preflight_replayed",
+      message: "Completed story isolation preflight was replayed from durable state.",
+      baseline: completedReplay.baseline
+    });
+    return { ok: true, baseline: completedReplay.baseline };
+  }
+  await state10.set(STORY_STATE_KEYS.activePhase, "story-isolation-preflight");
+  await incrementStoryPhaseAttempt("story-isolation-preflight");
+  const blockedReplay = await loadBlockedReplayPreflightState(currentStory);
+  if (blockedReplay) {
+    await state10.set(STORY_STATE_KEYS.storyBaseline, blockedReplay.baseline);
+    await state10.set(STORY_STATE_KEYS.activeStoryStartCommit, { commit: blockedReplay.baseline });
+    await state10.set(STORY_STATE_KEYS.latestPreflightStatus, {
+      ok: true,
+      code: "story_preflight_passed",
+      message: "Story isolation preflight passed.",
+      baseline: blockedReplay.baseline
+    });
+    return { ok: true, baseline: blockedReplay.baseline };
+  }
+  const cwd = state10.cwd;
+  if (!cwd) {
+    return preflightFailure(
+      "story_preflight_missing_cwd",
+      "Cannot start story implementation because the TrailStep workflow cwd is unavailable. Retry from a valid project checkout so TrailStep can record a git story baseline.",
+      { storyPath: currentStory.path }
+    );
+  }
+  const insideWorkTree = await runGit(["rev-parse", "--is-inside-work-tree"], cwd);
+  if (!insideWorkTree.ok || insideWorkTree.stdout !== "true") {
+    return preflightFailure(
+      "story_preflight_not_git_worktree",
+      "Cannot start story implementation because the workflow cwd is not a valid git worktree. Run take-it-away/grill-it-away from a git repository with a clean story boundary.",
+      {
+        storyPath: currentStory.path,
+        cwd,
+        gitError: insideWorkTree.ok ? void 0 : insideWorkTree.error
+      }
+    );
+  }
+  const head = await runGit(["rev-parse", "HEAD"], cwd);
+  if (!head.ok || head.stdout.length === 0) {
+    return preflightFailure(
+      "story_preflight_missing_head",
+      "Cannot start story implementation because `git rev-parse HEAD` did not produce a usable baseline commit. Create an initial commit or fix the git repository, then retry.",
+      {
+        storyPath: currentStory.path,
+        cwd,
+        gitError: head.ok ? "No commit was returned." : head.error
+      }
+    );
+  }
+  const existingBaseline = await state10.get(STORY_STATE_KEYS.storyBaseline);
+  const baseline = existingBaseline ?? head.stdout;
+  const reachable = await runGit(["cat-file", "-e", `${baseline}^{commit}`], cwd);
+  if (!reachable.ok) {
+    return preflightFailure(
+      "story_preflight_unreachable_baseline",
+      `Cannot start story implementation because the recorded story baseline \`${baseline}\` is missing or unreachable. Fix the checkout or retry after restoring a valid story boundary.`,
+      { storyPath: currentStory.path, cwd, baseline, gitError: reachable.error }
+    );
+  }
+  const status = await runGit(["status", "--short"], cwd);
+  if (!status.ok) {
+    return preflightFailure(
+      "story_preflight_status_failed",
+      "Cannot start story implementation because TrailStep could not inspect `git status --short`. Fix git status inspection and retry.",
+      { storyPath: currentStory.path, cwd, baseline, gitError: status.error }
+    );
+  }
+  if (status.stdout.trim().length > 0) {
+    return preflightFailure(
+      "story_preflight_dirty_worktree",
+      "Cannot start story implementation because the working tree is dirty before the story begins. Commit, stash, or otherwise restore a clean story boundary, then retry.",
+      { storyPath: currentStory.path, cwd, baseline, statusShort: status.stdout }
+    );
+  }
+  await state10.set(STORY_STATE_KEYS.storyBaseline, baseline);
+  await state10.set(STORY_STATE_KEYS.activeStoryStartCommit, { commit: baseline });
+  await state10.set(STORY_STATE_KEYS.latestPreflightStatus, {
+    ok: true,
+    code: "story_preflight_passed",
+    message: "Story isolation preflight passed.",
+    baseline
+  });
+  return { ok: true, baseline };
+}
+async function loadCompletedReplayPreflightState(currentStory) {
+  if (!state10.isReplayingCompletedStep) {
+    return null;
+  }
+  const activeStory = await state10.getPersisted(STORY_STATE_KEYS.activeStory);
+  const baseline = await loadPersistedRecordedBaseline();
+  if (!activeStory || documentsMatch2(activeStory, currentStory)) {
+    return baseline ? { baseline } : { baseline: "replayed-completed-step" };
+  }
+  return { baseline: "replayed-completed-step" };
+}
+async function loadBlockedReplayPreflightState(currentStory) {
+  const routerState = await state10.get(
+    STORY_STATE_KEYS.latestStoryRouterState
+  );
+  if (routerState?.route !== "blocked" || routerState.activeStory.path !== currentStory.path || routerState.activeStory.content !== currentStory.content) {
+    return null;
+  }
+  const baseline = await loadRecordedBaseline();
+  return baseline ? { baseline } : null;
+}
+async function loadRecordedBaseline() {
+  return await state10.get(STORY_STATE_KEYS.storyBaseline) ?? (await state10.get(STORY_STATE_KEYS.activeStoryStartCommit))?.commit ?? null;
+}
+async function loadPersistedRecordedBaseline() {
+  return await state10.getPersisted(STORY_STATE_KEYS.storyBaseline) ?? (await state10.getPersisted(
+    STORY_STATE_KEYS.activeStoryStartCommit
+  ))?.commit ?? null;
+}
+function documentsMatch2(left, right) {
+  return left.path === right.path && left.content === right.content;
+}
+async function preflightFailure(code, message, details) {
+  await state10.set(STORY_STATE_KEYS.latestPreflightStatus, {
+    ok: false,
+    code,
+    message,
+    baseline: typeof details.baseline === "string" ? details.baseline : void 0
+  });
+  return { ok: false, failure: fail2({ code, message, details }) };
+}
+
+// src/feature-implementation/story-router/step.ts
+var StoryRouterFailureError = class extends Error {
+  failure;
+  constructor(failure) {
+    super(failure.message);
+    this.name = "StoryRouterFailureError";
+    this.failure = failure;
+  }
+};
+var storyRouterStep = step10({ id: "story-router" }).do(
+  async ({ currentStory, reason }) => {
+    const previousActivePhase = await state11.get(STORY_STATE_KEYS.activePhase);
+    await state11.set(STORY_STATE_KEYS.activePhase, "story-router");
+    await incrementStoryPhaseAttempt("story-router");
+    if (reason === "failed-review") {
+      const replayedRoute = await replayPersistedRetryRoute(
+        reason,
+        currentStory,
+        previousActivePhase
+      );
+      if (replayedRoute) {
+        return replayedRoute;
+      }
+      return routeFailedReview(currentStory);
+    }
+    if (reason === "failed-validation") {
+      const replayedRoute = await replayPersistedRetryRoute(
+        reason,
+        currentStory,
+        previousActivePhase
+      );
+      if (replayedRoute) {
+        return replayedRoute;
+      }
+      return routeFailedValidation(currentStory);
+    }
+    if (typeof reason === "object" && reason.type === "blocked") {
+      const blockedReplay = await replayBlockedStoryRoute();
+      if (blockedReplay) {
+        return blockedReplay;
+      }
+      return routeBlockedStory(currentStory, reason);
+    }
+    if (reason === "story-completed") {
+      const repairFailure = await repairStaleStoryCompletion(currentStory);
+      if (repairFailure) {
+        return fail3(repairFailure);
+      }
+    }
+    const activeStory = currentStory ?? await state11.get(STORY_STATE_KEYS.activeStory);
+    if (!activeStory) {
+      const [nextStory, ...remaining] = await state11.get(STORY_STATE_KEYS.storyQueue) ?? [];
+      if (!nextStory) {
+        return fail3({
+          code: "story_router_no_active_story",
+          message: "Cannot route story implementation because no active story or queued story is available."
+        });
+      }
+      const [nextStoryContext = "", ...remainingStoryContexts] = await state11.get(STORY_STATE_KEYS.storyContextQueue) ?? [];
+      await state11.set(STORY_STATE_KEYS.storyQueue, remaining);
+      await state11.set(STORY_STATE_KEYS.storyContextQueue, remainingStoryContexts);
+      await state11.set(STORY_STATE_KEYS.activeStory, nextStory);
+      await state11.set(STORY_STATE_KEYS.activeStoryContext, nextStoryContext);
+      return routeStoryAfterPreflight(nextStory);
+    }
+    await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+    return routeStoryAfterPreflight(activeStory);
+  }
+);
+async function routeFailedReview(currentStory) {
+  const activeStory = await state11.get(STORY_STATE_KEYS.activeStory) ?? currentStory;
+  if (!activeStory) {
+    return fail3({
+      code: "story_router_no_active_story",
+      message: "Cannot route failed story review because no active story is available for retry."
+    });
+  }
+  const review = await state11.get(STORY_STATE_KEYS.latestReviewResult);
+  if (!review) {
+    return fail3({
+      code: "story_router_missing_review_result",
+      message: "Cannot route failed story review because no latest review result is available.",
+      details: { storyPath: activeStory.path }
+    });
+  }
+  if (reviewPasses(review)) {
+    return fail3({
+      code: "story_router_review_already_passed",
+      message: "Cannot route failed story review because the latest review already passes.",
+      details: { review, storyPath: activeStory.path }
+    });
+  }
+  const previousCounts = await loadRouterRetryCounts({
+    reviewPhaseFallback: "review-story-implementation"
+  });
+  const reviewRetryCount = previousCounts.reviewRetryCount + 1;
+  const nextCounts = { ...previousCounts, reviewRetryCount };
+  if (reviewRetryCount >= MAX_STORY_REVIEW_ATTEMPTS) {
+    const routerState = await persistRetryRouterState({
+      activeStory,
+      route: "exhausted",
+      sourceReason: "failed-review",
+      code: "story_review_exhausted",
+      counts: nextCounts,
+      retryLimit: MAX_STORY_REVIEW_ATTEMPTS,
+      exhaustedReason: "review",
+      review
+    });
+    return fail3({
+      code: "story_review_exhausted",
+      message: `Story failed review ${reviewRetryCount} times; retry limit is ${MAX_STORY_REVIEW_ATTEMPTS} (last score ${review.score}/5).`,
+      details: {
+        review,
+        storyPath: activeStory.path,
+        reviewRetryCount,
+        retryLimit: MAX_STORY_REVIEW_ATTEMPTS,
+        routerState
+      }
+    });
+  }
+  await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+  await state11.set(STORY_STATE_KEYS.activePhase, "implement-green");
+  await persistRetryRouterState({
+    activeStory,
+    route: "retrying",
+    targetPhase: "implement-green",
+    sourceReason: "failed-review",
+    code: "story_review_retry",
+    counts: nextCounts,
+    retryLimit: MAX_STORY_REVIEW_ATTEMPTS,
+    review
+  });
+  const attempt = await incrementStoryPhaseAttempt("implement-green");
+  return implementGreenStep({
+    currentStory: activeStory,
+    explorationBrief: await state11.get(STORY_STATE_KEYS.latestExplorationBrief) ?? void 0,
+    redTestSummary: await state11.get(STORY_STATE_KEYS.latestRedTestSummary) ?? void 0,
+    attempt,
+    previousReviewSummary: review.summary,
+    requiredImprovements: review.requiredImprovements,
+    implementationContext: await loadStoryPhaseContext("implement-green")
+  });
+}
+async function routeFailedValidation(currentStory) {
+  const activeStory = await state11.get(STORY_STATE_KEYS.activeStory) ?? currentStory;
+  if (!activeStory) {
+    return fail3({
+      code: "story_router_no_active_story",
+      message: "Cannot route failed story validation because no active story is available for retry."
+    });
+  }
+  const validation = await state11.get(
+    STORY_STATE_KEYS.latestValidationSummary
+  );
+  if (!validation) {
+    return fail3({
+      code: "story_router_missing_validation_result",
+      message: "Cannot route failed story validation because no latest validation result is available.",
+      details: { storyPath: activeStory.path }
+    });
+  }
+  if (validation.blocked) {
+    return routeBlockedStory(activeStory, {
+      type: "blocked",
+      sourceReason: "failed-validation",
+      blockedPhase: "validate-story",
+      blockedReason: validation.blockedReason ?? "Story validation reported a blocked state.",
+      code: "story_validation_blocked",
+      metadata: { validation }
+    });
+  }
+  if (validation.validationPassed) {
+    return fail3({
+      code: "story_router_validation_already_passed",
+      message: "Cannot route failed story validation because the latest validation already passes.",
+      details: { storyPath: activeStory.path, validation }
+    });
+  }
+  const previousCounts = await loadRouterRetryCounts({
+    validationPhaseFallback: "validate-story"
+  });
+  const validationRetryCount = previousCounts.validationRetryCount + 1;
+  const nextCounts = { ...previousCounts, validationRetryCount };
+  if (validationRetryCount >= MAX_STORY_VALIDATION_ATTEMPTS) {
+    const routerState = await persistRetryRouterState({
+      activeStory,
+      route: "exhausted",
+      sourceReason: "failed-validation",
+      code: "story_validation_exhausted",
+      counts: nextCounts,
+      retryLimit: MAX_STORY_VALIDATION_ATTEMPTS,
+      exhaustedReason: "validation",
+      validation
+    });
+    return fail3({
+      code: "story_validation_exhausted",
+      message: `Story failed validation ${validationRetryCount} times; retry limit is ${MAX_STORY_VALIDATION_ATTEMPTS}.`,
+      details: {
+        storyPath: activeStory.path,
+        validation,
+        validationRetryCount,
+        retryLimit: MAX_STORY_VALIDATION_ATTEMPTS,
+        routerState
+      }
+    });
+  }
+  const route = validationRetryCount >= STORY_DOCTOR_VALIDATION_FAILURE_THRESHOLD ? "doctoring" : "retrying";
+  const targetPhase = route === "doctoring" ? "story-doctor" : "implement-green";
+  await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+  await state11.set(STORY_STATE_KEYS.activePhase, targetPhase);
+  await persistRetryRouterState({
+    activeStory,
+    route,
+    targetPhase,
+    sourceReason: "failed-validation",
+    code: route === "doctoring" ? "story_validation_doctor" : "story_validation_retry",
+    counts: nextCounts,
+    retryLimit: MAX_STORY_VALIDATION_ATTEMPTS,
+    validation
+  });
+  if (route === "doctoring") {
+    await incrementStoryPhaseAttempt("story-doctor");
+    return storyDoctorStep({
+      currentStory: activeStory,
+      explorationBrief: await state11.get(STORY_STATE_KEYS.latestExplorationBrief) ?? void 0,
+      redTestSummary: await state11.get(STORY_STATE_KEYS.latestRedTestSummary) ?? void 0,
+      implementationSummary: await state11.get(STORY_STATE_KEYS.latestImplementationSummary) ?? void 0,
+      failedValidationSummary: validation.summary,
+      failedValidationCommands: validation.commands,
+      validationRetryCount,
+      retryLimit: MAX_STORY_VALIDATION_ATTEMPTS
+    });
+  }
+  const attempt = await incrementStoryPhaseAttempt("implement-green");
+  return implementGreenStep({
+    currentStory: activeStory,
+    explorationBrief: await state11.get(STORY_STATE_KEYS.latestExplorationBrief) ?? void 0,
+    redTestSummary: await state11.get(STORY_STATE_KEYS.latestRedTestSummary) ?? void 0,
+    attempt,
+    failedValidationSummary: validation.summary,
+    failedValidationCommands: validation.commands,
+    implementationContext: await loadStoryPhaseContext("implement-green")
+  });
+}
+async function routeBlockedStory(currentStory, blockedRoute) {
+  const activeStory = await state11.get(STORY_STATE_KEYS.activeStory) ?? currentStory;
+  if (!activeStory) {
+    return fail3({
+      code: "story_router_no_active_story",
+      message: "Cannot route blocked story because no active story is available."
+    });
+  }
+  const counts = await loadRouterRetryCounts({});
+  const routerState = {
+    route: "blocked",
+    activeStory,
+    reviewRetryCount: counts.reviewRetryCount,
+    validationRetryCount: counts.validationRetryCount,
+    blockedPhase: blockedRoute.blockedPhase,
+    blockedReason: blockedRoute.blockedReason,
+    source: {
+      reason: blockedRoute.sourceReason,
+      blocked: true,
+      code: blockedRoute.code,
+      metadata: blockedRoute.metadata
+    }
+  };
+  await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+  await state11.set(STORY_STATE_KEYS.latestStoryRouterState, routerState);
+  await state11.set(STORY_STATE_KEYS.blockedReason, blockedRoute.blockedReason);
+  return fail3(formatBlockedRouteFailure(routerState));
+}
+async function replayBlockedStoryRoute() {
+  const routerState = await state11.get(
+    STORY_STATE_KEYS.latestStoryRouterState
+  );
+  if (routerState?.route !== "blocked") {
+    return null;
+  }
+  const activeStory = await state11.get(STORY_STATE_KEYS.activeStory);
+  if (!activeStory) {
+    return fail3({
+      code: "story_router_no_active_story",
+      message: "Cannot replay blocked story routing because durable router state exists but no active story is available.",
+      details: { routerState }
+    });
+  }
+  if (!storiesMatch(routerState.activeStory, activeStory)) {
+    return fail3({
+      code: "story_router_blocked_state_mismatch",
+      message: "Cannot replay blocked story routing because durable router state does not match the active story.",
+      details: { storyPath: activeStory.path, routerState }
+    });
+  }
+  await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+  await state11.set(STORY_STATE_KEYS.blockedReason, routerState.blockedReason ?? null);
+  return fail3(formatBlockedRouteFailure(routerState));
+}
+async function replayPersistedRetryRoute(reason, currentStory, previousActivePhase) {
+  const routerState = state11.isReplayingCompletedStep ? await state11.getPersisted(
+    STORY_STATE_KEYS.latestStoryRouterState
+  ) : await state11.get(STORY_STATE_KEYS.latestStoryRouterState);
+  if (!routerState || !isPersistedRetryRoute(routerState.route)) {
+    return null;
+  }
+  if (routerState.source?.reason !== reason) {
+    return null;
+  }
+  const activeStory = await state11.get(STORY_STATE_KEYS.activeStory) ?? currentStory;
+  if (!activeStory) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because no active story is available.",
+      { routerState }
+    );
+  }
+  if (!routerState.activeStory) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because the durable router state is missing its active story.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (!storiesMatch(routerState.activeStory, activeStory)) {
+    return retryStateMismatch(routerState, activeStory);
+  }
+  const shapeFailure = validatePersistedRetryRouteShape(routerState, reason, activeStory);
+  if (shapeFailure) {
+    return shapeFailure;
+  }
+  if (routerState.route === "exhausted") {
+    return fail3(formatExhaustedRetryRouteFailure(routerState, activeStory));
+  }
+  if (!state11.isReplayingCompletedStep && routerState.route !== "doctoring" && routerState.targetPhase !== previousActivePhase && previousActivePhase !== "story-router") {
+    return null;
+  }
+  if (!await persistedRetryEvidenceMatches(reason, routerState)) {
+    return null;
+  }
+  if (routerState.route === "retrying") {
+    await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+    await state11.set(STORY_STATE_KEYS.activePhase, "implement-green");
+    const attempt = await incrementStoryPhaseAttempt("implement-green");
+    return implementGreenStep({
+      currentStory: activeStory,
+      explorationBrief: await state11.get(STORY_STATE_KEYS.latestExplorationBrief) ?? void 0,
+      redTestSummary: await state11.get(STORY_STATE_KEYS.latestRedTestSummary) ?? void 0,
+      attempt,
+      previousReviewSummary: reason === "failed-review" ? routerState.latestReview?.summary : void 0,
+      requiredImprovements: reason === "failed-review" ? routerState.latestReview?.requiredImprovements : void 0,
+      failedValidationSummary: reason === "failed-validation" ? routerState.latestValidation?.summary : void 0,
+      failedValidationCommands: reason === "failed-validation" ? routerState.latestValidation?.commands : void 0,
+      implementationContext: await loadStoryPhaseContext("implement-green")
+    });
+  }
+  if (routerState.route === "doctoring") {
+    await state11.set(STORY_STATE_KEYS.activeStory, activeStory);
+    await state11.set(STORY_STATE_KEYS.activePhase, "story-doctor");
+    await incrementStoryPhaseAttempt("story-doctor");
+    return storyDoctorStep({
+      currentStory: activeStory,
+      explorationBrief: await state11.get(STORY_STATE_KEYS.latestExplorationBrief) ?? void 0,
+      redTestSummary: await state11.get(STORY_STATE_KEYS.latestRedTestSummary) ?? void 0,
+      implementationSummary: await state11.get(STORY_STATE_KEYS.latestImplementationSummary) ?? void 0,
+      failedValidationSummary: routerState.latestValidation?.summary ?? "",
+      failedValidationCommands: routerState.latestValidation?.commands ?? [],
+      validationRetryCount: routerState.validationRetryCount ?? 0,
+      retryLimit: routerState.retryLimit ?? MAX_STORY_VALIDATION_ATTEMPTS
+    });
+  }
+  return inconsistentRetryState(
+    "Cannot replay persisted story retry route with an unknown route.",
+    {
+      storyPath: activeStory.path,
+      routerState
+    }
+  );
+}
+function isPersistedRetryRoute(route) {
+  return route === "retrying" || route === "doctoring" || route === "exhausted";
+}
+function validatePersistedRetryRouteShape(routerState, reason, activeStory) {
+  if (typeof routerState.source?.code !== "string" || routerState.source.code.length === 0) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because the durable router state is missing its source code.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (!isNonNegativeInteger(routerState.reviewRetryCount)) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because the review retry count is missing or invalid.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (!isNonNegativeInteger(routerState.validationRetryCount)) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because the validation retry count is missing or invalid.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (!isPositiveInteger(routerState.retryLimit)) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because the retry limit is missing or invalid.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (routerState.route === "retrying" && routerState.targetPhase !== "implement-green") {
+    return inconsistentRetryState(
+      "Cannot replay persisted story retry route because retrying routes must target implement-green.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (routerState.route === "doctoring" && routerState.targetPhase !== "story-doctor") {
+    return inconsistentRetryState(
+      "Cannot replay persisted story doctor route because doctoring routes must target story-doctor.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (reason === "failed-review" && !hasReviewMetadata(routerState.latestReview)) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story review retry route because latest review evidence is missing or invalid.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  if (reason === "failed-validation" && !hasValidationMetadata(routerState.latestValidation)) {
+    return inconsistentRetryState(
+      "Cannot replay persisted story validation retry route because latest validation evidence is missing or invalid.",
+      { storyPath: activeStory.path, routerState }
+    );
+  }
+  return null;
+}
+async function persistedRetryEvidenceMatches(reason, routerState) {
+  if (routerState.source?.reason !== reason) {
+    return false;
+  }
+  if (state11.isReplayingCompletedStep) {
+    return true;
+  }
+  return routerStateEvidenceMatchesLatest(routerState);
+}
+async function routerStateEvidenceMatchesLatest(routerState) {
+  if (routerState.source?.reason === "failed-review") {
+    if (!hasReviewMetadata(routerState.latestReview)) {
+      return false;
+    }
+    const review = await state11.get(STORY_STATE_KEYS.latestReviewResult);
+    return !!review && routerState.latestReview.score === review.score && routerState.latestReview.summary === review.summary && stringArraysEqual(routerState.latestReview.requiredImprovements, review.requiredImprovements);
+  }
+  if (routerState.source?.reason === "failed-validation") {
+    if (!hasValidationMetadata(routerState.latestValidation)) {
+      return false;
+    }
+    const validation = await state11.get(
+      STORY_STATE_KEYS.latestValidationSummary
+    );
+    return !!validation && routerState.latestValidation.summary === validation.summary && validationCommandArraysEqual(routerState.latestValidation.commands, validation.commands);
+  }
+  return true;
+}
+function hasReviewMetadata(value) {
+  return typeof value === "object" && value !== null && "score" in value && typeof value.score === "number" && "summary" in value && typeof value.summary === "string" && "requiredImprovements" in value && Array.isArray(value.requiredImprovements) && value.requiredImprovements.every((item) => typeof item === "string");
+}
+function hasValidationMetadata(value) {
+  return typeof value === "object" && value !== null && "summary" in value && typeof value.summary === "string" && "commands" in value && Array.isArray(value.commands) && value.commands.every(
+    (item) => typeof item === "object" && item !== null && "command" in item && typeof item.command === "string" && "result" in item && typeof item.result === "string"
+  );
+}
+function storiesMatch(left, right) {
+  return left.path === right.path && left.content === right.content;
+}
+function stringArraysEqual(left, right) {
+  return left.length === right.length && left.every((item, index) => item === right[index]);
+}
+function validationCommandArraysEqual(left, right) {
+  return left.length === right.length && left.every(
+    (item, index) => item.command === right[index]?.command && item.result === right[index]?.result
+  );
+}
+function isNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPositiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function retryStateMismatch(routerState, activeStory) {
+  throw new StoryRouterFailureError({
+    code: "story_router_retry_state_mismatch",
+    message: "Cannot replay persisted story retry route because durable router state does not match the active story.",
+    details: { storyPath: activeStory.path, routerState }
+  });
+}
+function inconsistentRetryState(message, details) {
+  throw new StoryRouterFailureError({
+    code: "story_router_inconsistent_retry_state",
+    message,
+    details
+  });
+}
+function formatExhaustedRetryRouteFailure(routerState, activeStory) {
+  const exhaustedReason = routerState.exhaustedReason ?? reasonForSource(routerState.source?.reason);
+  const retryCount = exhaustedReason === "review" ? routerState.reviewRetryCount : routerState.validationRetryCount;
+  return {
+    code: routerState.source?.code ?? `story_${exhaustedReason}_exhausted`,
+    message: `Story ${exhaustedReason} retry route is already exhausted (${retryCount}/${routerState.retryLimit}).`,
+    details: { storyPath: activeStory.path, routerState }
+  };
+}
+function reasonForSource(reason) {
+  return reason === "failed-review" ? "review" : "validation";
+}
+async function persistRetryRouterState(input) {
+  const routerState = {
+    route: input.route,
+    activeStory: input.activeStory,
+    targetPhase: input.targetPhase,
+    reviewRetryCount: input.counts.reviewRetryCount,
+    validationRetryCount: input.counts.validationRetryCount,
+    retryLimit: input.retryLimit,
+    exhaustedReason: input.exhaustedReason,
+    latestReview: input.review ? {
+      score: input.review.score,
+      summary: input.review.summary,
+      requiredImprovements: input.review.requiredImprovements
+    } : void 0,
+    latestValidation: input.validation ? {
+      summary: input.validation.summary,
+      commands: input.validation.commands
+    } : void 0,
+    source: {
+      reason: input.sourceReason,
+      code: input.code
+    }
+  };
+  await state11.set(STORY_STATE_KEYS.latestStoryRouterState, routerState);
+  return routerState;
+}
+async function loadRouterRetryCounts(input) {
+  const activeStory = await state11.get(STORY_STATE_KEYS.activeStory);
+  const routerState = await state11.get(
+    STORY_STATE_KEYS.latestStoryRouterState
+  );
+  const attemptsByPhase = await state11.get(STORY_STATE_KEYS.attemptsByPhase) ?? {};
+  const routerStateMatchesActiveStory = activeStory && routerState?.activeStory?.path === activeStory.path && routerState.activeStory.content === activeStory.content;
+  if (routerStateMatchesActiveStory) {
+    const fallbackCounts = {
+      reviewRetryCount: phaseAttemptFallback(attemptsByPhase, input.reviewPhaseFallback),
+      validationRetryCount: phaseAttemptFallback(attemptsByPhase, input.validationPhaseFallback)
+    };
+    const replayingSameReviewEvidence = input.reviewPhaseFallback && routerState.source?.reason === "failed-review";
+    const replayingSameValidationEvidence = input.validationPhaseFallback && routerState.source?.reason === "failed-validation";
+    if ((replayingSameReviewEvidence || replayingSameValidationEvidence) && !await routerStateEvidenceMatchesLatest(routerState)) {
+      return fallbackCounts;
+    }
+    return {
+      reviewRetryCount: normalizeRetryCount(routerState.reviewRetryCount),
+      validationRetryCount: normalizeRetryCount(routerState.validationRetryCount)
+    };
+  }
+  if (routerState?.activeStory) {
+    return {
+      reviewRetryCount: 0,
+      validationRetryCount: 0
+    };
+  }
+  return {
+    reviewRetryCount: phaseAttemptFallback(attemptsByPhase, input.reviewPhaseFallback),
+    validationRetryCount: phaseAttemptFallback(attemptsByPhase, input.validationPhaseFallback)
+  };
+}
+function phaseAttemptFallback(attemptsByPhase, phase) {
+  if (!phase) {
+    return 0;
+  }
+  return Math.max(0, normalizeRetryCount(attemptsByPhase[phase]) - 1);
+}
+function normalizeRetryCount(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : 0;
+}
+function formatBlockedRouteFailure(routerState) {
+  return {
+    code: routerState.source.code,
+    message: routerState.blockedReason ?? "Story routing is blocked.",
+    details: {
+      storyPath: routerState.activeStory.path,
+      routerState,
+      ...formatBlockedRouteFailureDetails(
+        routerState.blockedPhase ?? "validate-story",
+        routerState.source.metadata
+      )
+    }
+  };
+}
+function formatBlockedRouteFailureDetails(blockedPhase, metadata) {
+  return {
+    blockedPhase,
+    ...metadata ? metadata : {}
+  };
+}
+async function repairStaleStoryCompletion(currentStory) {
+  if (!currentStory) {
+    return void 0;
+  }
+  const persistedActiveStory = await state11.get(STORY_STATE_KEYS.activeStory);
+  if (!persistedActiveStory || storiesMatch(persistedActiveStory, currentStory)) {
+    return void 0;
+  }
+  const storyQueue = await state11.get(STORY_STATE_KEYS.storyQueue) ?? [];
+  const queuedCurrentStoryIndex = storyQueue.findIndex(
+    (story) => storiesMatch(story, currentStory)
+  );
+  if (queuedCurrentStoryIndex !== 0) {
+    return {
+      code: "story_router_stale_completion_mismatch",
+      message: "Cannot repair stale story completion state because the routed next story is not the immediate queued successor.",
+      details: {
+        persistedActiveStoryPath: persistedActiveStory.path,
+        currentStoryPath: currentStory.path,
+        queuedCurrentStoryIndex,
+        queuedStoryPaths: storyQueue.map((story) => story.path)
+      }
+    };
+  }
+  const completed = await state11.get(STORY_STATE_KEYS.completedStories) ?? [];
+  const completedTitle = extractStoryTitle(persistedActiveStory.content, completed.length + 1);
+  await resetStoryLocalStateForNextStory();
+  await state11.set(
+    STORY_STATE_KEYS.completedStories,
+    completed.includes(completedTitle) ? completed : [...completed, completedTitle]
+  );
+  await state11.set(STORY_STATE_KEYS.storyQueue, storyQueue.slice(1));
+  const storyContextQueue = await state11.get(STORY_STATE_KEYS.storyContextQueue) ?? [];
+  await state11.set(STORY_STATE_KEYS.storyContextQueue, storyContextQueue.slice(1));
+  await state11.set(STORY_STATE_KEYS.activeStory, currentStory);
+  await state11.set(STORY_STATE_KEYS.activeStoryContext, storyContextQueue[0] ?? "");
+  return void 0;
+}
+async function routeStoryAfterPreflight(activeStory) {
+  return storyIsolationPreflightStep({ currentStory: activeStory });
+}
+
+export {
+  takeItAwayOutput,
+  STORY_BOUNDARY,
+  STORY_CONTEXT_START,
+  STORY_CONTEXT_END,
+  MAX_IMPLEMENTATION_DOC_REVIEW_ATTEMPTS,
+  reviewOutput,
+  reviewPasses,
+  STORY_STATE_KEYS,
+  resetStoryLocalState,
+  takeItAwayInput,
+  normalizeTakeItAwayWorkflowOptions,
+  storyRouterStep
+};
+//# sourceMappingURL=chunk-RF3PMHPX.js.map