sb-codex-tool 0.1.0

package/dist/cli.js

@@ -0,0 +1,3583 @@
+// src/lib/assignment.ts
+import path5 from "node:path";
+
+// src/lib/cycle.ts
+import path2 from "node:path";
+
+// src/lib/fs.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+function ensureDir(directory) {
+  mkdirSync(directory, { recursive: true });
+}
+function readTextIfPresent(filePath) {
+  if (!existsSync(filePath)) {
+    return null;
+  }
+  return readFileSync(filePath, "utf8");
+}
+function readJsonIfPresent(filePath) {
+  const text = readTextIfPresent(filePath);
+  if (text === null) {
+    return null;
+  }
+  return JSON.parse(text);
+}
+function writeFileIfMissing(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  if (existsSync(filePath)) {
+    return "kept";
+  }
+  writeFileSync(filePath, content, "utf8");
+  return "created";
+}
+function writeFileIfChanged(filePath, content) {
+  ensureDir(path.dirname(filePath));
+  if (!existsSync(filePath)) {
+    writeFileSync(filePath, content, "utf8");
+    return "created";
+  }
+  const current = readFileSync(filePath, "utf8");
+  if (current === content) {
+    return "unchanged";
+  }
+  writeFileSync(filePath, content, "utf8");
+  return "updated";
+}
+function ensureLines(filePath, lines, header) {
+  ensureDir(path.dirname(filePath));
+  if (!existsSync(filePath)) {
+    const content = `${header}
+
+${lines.join("\n")}
+`;
+    writeFileSync(filePath, content, "utf8");
+    return { created: true, added: [...lines] };
+  }
+  const current = readFileSync(filePath, "utf8");
+  const missing = lines.filter((line) => !current.includes(line));
+  if (missing.length === 0) {
+    return { created: false, added: [] };
+  }
+  const next = current.includes(header) ? `${current.trimEnd()}
+${missing.join("\n")}
+` : `${current.trimEnd()}
+
+${header}
+
+${missing.join("\n")}
+`;
+  writeFileSync(filePath, next, "utf8");
+  return { created: false, added: missing };
+}
+
+// src/lib/cycle.ts
+function formatDateStamp(date = /* @__PURE__ */ new Date()) {
+  const year = String(date.getFullYear());
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  return `${year}-${month}-${day}`;
+}
+function normalizeSlug(input) {
+  return input.trim().toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function humanizeSlug(slug) {
+  return slug.split("-").filter((part) => part.length > 0).map((part) => part[0].toUpperCase() + part.slice(1)).join(" ");
+}
+function parseCycleDescriptor(planPath) {
+  const match = planPath.match(
+    /^\.sb-codex-tool\/plans\/(\d{4}-\d{2}-\d{2})-(.+)-approved\.md$/
+  );
+  if (match === null) {
+    throw new Error(`Unable to derive cycle metadata from ${planPath}.`);
+  }
+  return {
+    dateStamp: match[1],
+    slug: match[2]
+  };
+}
+function readCycleTitle(root, planPath, fallbackSlug) {
+  const text = readTextIfPresent(path2.join(root, planPath));
+  const heading = text?.match(/^# Approved Plan: (.+)$/m)?.[1];
+  if (heading !== void 0) {
+    return heading.trim();
+  }
+  return humanizeSlug(fallbackSlug);
+}
+
+// src/lib/paths.ts
+import { existsSync as existsSync2 } from "node:fs";
+import path3 from "node:path";
+var STATE_ROOT_NAME = ".sb-codex-tool";
+var WORKFLOW_NAMES = [
+  "clarify",
+  "plan",
+  "execute",
+  "refactor",
+  "verify"
+];
+var REQUIRED_DIRECTORIES = [
+  STATE_ROOT_NAME,
+  `${STATE_ROOT_NAME}/plans`,
+  `${STATE_ROOT_NAME}/runs`,
+  `${STATE_ROOT_NAME}/summaries`,
+  `${STATE_ROOT_NAME}/handoffs`,
+  `${STATE_ROOT_NAME}/guides`,
+  `${STATE_ROOT_NAME}/index`,
+  `${STATE_ROOT_NAME}/reviews`,
+  `${STATE_ROOT_NAME}/logs`,
+  `${STATE_ROOT_NAME}/logs/work-journal`,
+  `${STATE_ROOT_NAME}/ignore`,
+  `${STATE_ROOT_NAME}/workflows`
+];
+var REQUIRED_FILES = [
+  `${STATE_ROOT_NAME}/project.md`,
+  `${STATE_ROOT_NAME}/state.md`,
+  `${STATE_ROOT_NAME}/guides/read-this-first.md`,
+  `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+  `${STATE_ROOT_NAME}/index/current.json`,
+  `${STATE_ROOT_NAME}/index/README.md`,
+  `${STATE_ROOT_NAME}/plans/README.md`,
+  `${STATE_ROOT_NAME}/runs/README.md`,
+  `${STATE_ROOT_NAME}/summaries/README.md`,
+  `${STATE_ROOT_NAME}/handoffs/README.md`,
+  `${STATE_ROOT_NAME}/reviews/README.md`,
+  `${STATE_ROOT_NAME}/logs/work-journal/README.md`,
+  `${STATE_ROOT_NAME}/ignore/base.ignore`,
+  "AGENTS.md",
+  ".gitignore",
+  ".ignore",
+  ".rgignore"
+];
+var REQUIRED_WORKFLOW_FILES = WORKFLOW_NAMES.map(
+  (name) => `${STATE_ROOT_NAME}/workflows/${name}.md`
+);
+var ROOT_MARKERS = [
+  "package.json",
+  `${STATE_ROOT_NAME}/state.md`,
+  "docs/menu/implementation.md",
+  ".git"
+];
+function hasRootMarker(directory) {
+  return ROOT_MARKERS.some((marker) => existsSync2(path3.join(directory, marker)));
+}
+function resolveProjectRoot(start = process.cwd()) {
+  let current = path3.resolve(start);
+  while (true) {
+    if (hasRootMarker(current)) {
+      return current;
+    }
+    const parent = path3.dirname(current);
+    if (parent === current) {
+      return path3.resolve(start);
+    }
+    current = parent;
+  }
+}
+function statePath(root, ...segments) {
+  return path3.join(root, STATE_ROOT_NAME, ...segments);
+}
+
+// src/lib/current-state.ts
+function renderBulletList(items) {
+  if (items.length === 0) {
+    return "- none";
+  }
+  return items.map((item) => `- ${item}`).join("\n");
+}
+function renderReference(label, value) {
+  return `- ${label}: ${value ?? "none yet"}`;
+}
+function renderHotPath(hotPath) {
+  return hotPath.map((file, index) => `${index + 1}. ${file}`).join("\n");
+}
+function renderCurrentCycle(current) {
+  return [
+    `- Current stage: ${current.currentStage}`,
+    `- Latest approved plan: ${current.latestApprovedPlan ?? "none yet"}`,
+    `- Latest relevant summary: ${current.latestRelevantSummary ?? "none yet"}`,
+    `- Latest lifecycle run: ${current.latestRun ?? "none yet"}`,
+    `- Latest consistency review: ${current.latestConsistencyReview ?? "none yet"}`,
+    `- Latest assignment lifecycle: ${current.latestAssignmentLifecycle ?? "none yet"}`,
+    `- Current task guide: ${current.currentGuide ?? "none yet"}`,
+    `- Current handoff: ${current.currentHandoff ?? "none yet"}`,
+    `- Current review: ${current.currentReview ?? "none yet"}`
+  ].join("\n");
+}
+function renderAssignmentGuides(assignmentGuides) {
+  const entries = Object.entries(assignmentGuides);
+  if (entries.length === 0) {
+    return "- none";
+  }
+  return entries.sort(([left], [right]) => left.localeCompare(right)).map(([agent, guidePath]) => `- ${agent}: ${guidePath}`).join("\n");
+}
+function renderImplementationReference(implementationMenuPath) {
+  if (implementationMenuPath === null) {
+    return "- If this repo has implementation contracts, add them here.\n";
+  }
+  return `- ${implementationMenuPath}
+`;
+}
+function createInitialCurrentIndex() {
+  return {
+    version: 2,
+    currentStage: "clarify",
+    nextAction: "Review AGENTS.md and customize .sb-codex-tool/project.md.",
+    latestApprovedPlan: null,
+    latestRelevantSummary: null,
+    latestRun: null,
+    latestConsistencyReview: null,
+    latestAssignmentLifecycle: null,
+    currentGuide: null,
+    currentHandoff: null,
+    currentReview: null,
+    currentFocusModules: [
+      "AGENTS.md",
+      `${STATE_ROOT_NAME}/project.md`,
+      `${STATE_ROOT_NAME}/state.md`,
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`
+    ],
+    hotPath: [
+      `${STATE_ROOT_NAME}/project.md`,
+      `${STATE_ROOT_NAME}/state.md`,
+      `${STATE_ROOT_NAME}/guides/read-this-first.md`,
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`
+    ],
+    activeAgents: {
+      main: "unassigned",
+      subagents: [],
+      verification: null,
+      consistency: null
+    },
+    assignmentGuides: {},
+    notes: [
+      "Keep this file current enough for a fresh agent to start from the hot path."
+    ]
+  };
+}
+function normalizeCurrentIndex(current) {
+  const initial = createInitialCurrentIndex();
+  return {
+    ...initial,
+    ...current,
+    version: Math.max(current?.version ?? 0, initial.version),
+    currentFocusModules: current?.currentFocusModules ?? initial.currentFocusModules,
+    hotPath: current?.hotPath ?? initial.hotPath,
+    activeAgents: {
+      ...initial.activeAgents,
+      ...current?.activeAgents,
+      subagents: current?.activeAgents?.subagents ?? initial.activeAgents.subagents
+    },
+    assignmentGuides: current?.assignmentGuides ?? initial.assignmentGuides,
+    notes: current?.notes ?? initial.notes
+  };
+}
+function renderStateMarkdown(current) {
+  return `# Current State
+
+## Current Workflow Stage
+
+- ${current.currentStage}
+
+## One Next Action
+
+- ${current.nextAction}
+
+## Current Focus Modules
+
+${renderBulletList(current.currentFocusModules)}
+
+## References
+
+${renderReference("Latest approved plan", current.latestApprovedPlan)}
+${renderReference("Latest relevant summary", current.latestRelevantSummary)}
+${renderReference("Latest lifecycle run", current.latestRun)}
+${renderReference("Latest consistency review", current.latestConsistencyReview)}
+${renderReference("Latest assignment lifecycle", current.latestAssignmentLifecycle)}
+${renderReference("Current task guide", current.currentGuide)}
+${renderReference("Current handoff", current.currentHandoff)}
+${renderReference("Current review", current.currentReview)}
+
+## Active Agent Map
+
+- Main agent: ${current.activeAgents.main ?? "none"}
+- Execution subagents: ${current.activeAgents.subagents.length > 0 ? current.activeAgents.subagents.join(", ") : "none"}
+- Verification agent: ${current.activeAgents.verification ?? "none"}
+- Code consistency agent: ${current.activeAgents.consistency ?? "none"}
+
+## Active Assignment Guides
+
+${renderAssignmentGuides(current.assignmentGuides)}
+
+## Notes
+
+${renderBulletList(current.notes)}
+`;
+}
+function renderReadThisFirstMarkdown(current, implementationMenuPath) {
+  return `# Read This First
+
+## Hot Path
+
+Read in this order before implementation or verification:
+
+${renderHotPath(current.hotPath)}
+
+## Additional Repo Docs
+
+${renderImplementationReference(implementationMenuPath)}
+- docs/implementation/verification-contract.md
+- docs/implementation/acceptance-checklist.md
+
+## Current Cycle
+
+${renderCurrentCycle(current)}
+
+## Default Ignore Guidance
+
+- Ignore build outputs, caches, and bulky generated artifacts by default.
+- Keep ${STATE_ROOT_NAME}/logs/work-journal/ out of the default hot path.
+- Do not ignore AGENTS.md, guide files, state files, or current summaries.
+`;
+}
+function readCurrentIndex(root) {
+  const current = readJsonIfPresent(statePath(root, "index", "current.json"));
+  if (current === null) {
+    return null;
+  }
+  return normalizeCurrentIndex(current);
+}
+function writeCurrentIndex(root, current) {
+  return writeFileIfChanged(
+    statePath(root, "index", "current.json"),
+    JSON.stringify(current, null, 2) + "\n"
+  );
+}
+function writeCurrentState(root, current) {
+  return writeFileIfChanged(
+    statePath(root, "state.md"),
+    renderStateMarkdown(current)
+  );
+}
+function writeCurrentArtifacts(root, current, implementationMenuPath) {
+  return {
+    index: writeCurrentIndex(root, current),
+    state: writeCurrentState(root, current),
+    readThisFirst: writeFileIfChanged(
+      statePath(root, "guides", "read-this-first.md"),
+      renderReadThisFirstMarkdown(current, implementationMenuPath)
+    )
+  };
+}
+
+// src/lib/markdown-sections.ts
+function readSectionBody(content, heading) {
+  const escapedHeading = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const section = content.match(
+    new RegExp(`## ${escapedHeading}\\s+([\\s\\S]*?)(?=\\n## |$)`)
+  );
+  return section?.[1] ?? null;
+}
+function collectBulletItems(sectionBody) {
+  const items = [];
+  let currentItem = [];
+  const flushCurrentItem = () => {
+    if (currentItem.length === 0) {
+      return;
+    }
+    items.push(currentItem.join("\n"));
+    currentItem = [];
+  };
+  const lines = sectionBody.trim().split("\n").map((line) => line.replace(/\s+$/u, ""));
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    if (trimmed.startsWith("- ")) {
+      flushCurrentItem();
+      currentItem = [trimmed];
+      continue;
+    }
+    if (currentItem.length > 0) {
+      currentItem.push(`  ${trimmed}`);
+    }
+  }
+  flushCurrentItem();
+  return items;
+}
+function extractSectionLines(content, heading) {
+  const sectionBody = readSectionBody(content, heading);
+  if (sectionBody === null) {
+    return [];
+  }
+  return collectBulletItems(sectionBody);
+}
+function stripBulletPrefix(lines) {
+  return lines.map(
+    (line) => line.split("\n").map(
+      (segment, index) => index === 0 ? segment.replace(/^- /u, "") : segment.replace(/^\s+/u, "")
+    ).join("\n")
+  );
+}
+
+// src/lib/templates/context.ts
+import { existsSync as existsSync3 } from "node:fs";
+import path4 from "node:path";
+function buildTemplateContext(root) {
+  const implementationMenu = path4.join(root, "docs/menu/implementation.md");
+  return {
+    root,
+    projectName: path4.basename(root),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    implementationMenuPath: existsSync3(implementationMenu) ? "docs/menu/implementation.md" : null
+  };
+}
+
+// src/lib/templates/shared.ts
+function alwaysReadList(context) {
+  const items = [
+    "- AGENTS.md",
+    `- ${STATE_ROOT_NAME}/project.md`,
+    `- ${STATE_ROOT_NAME}/state.md`,
+    `- ${STATE_ROOT_NAME}/guides/read-this-first.md`,
+    `- ${STATE_ROOT_NAME}/guides/code-consistency.md`
+  ];
+  if (context.implementationMenuPath !== null) {
+    items.push(`- ${context.implementationMenuPath}`);
+  }
+  return items.join("\n");
+}
+function dirReadmeTemplate(title, purpose) {
+  return `# ${title}
+
+${purpose}
+`;
+}
+function workflowTemplate(name, purpose, outputs) {
+  return `# $${name}
+
+## Purpose
+
+${purpose}
+
+## Required Outputs
+
+${outputs}
+
+## Completion Rule
+
+- This stage is complete only when its required outputs are written clearly
+  enough for a fresh agent to inspect.
+
+## Failure Conditions
+
+- Required outputs are missing
+- The stage overlaps ambiguously with another stage
+- The next agent cannot tell what happened or what to do next
+
+## Related State Files
+
+- ${STATE_ROOT_NAME}/state.md
+- ${STATE_ROOT_NAME}/plans/
+- ${STATE_ROOT_NAME}/summaries/
+- ${STATE_ROOT_NAME}/guides/
+`;
+}
+
+// src/lib/templates/repo-documents.ts
+function agentsTemplate(context) {
+  return `# AGENTS.md
+
+## Purpose
+
+This repository uses \`sb-codex-tool\` as its workflow and runtime scaffold.
+
+Use the toolkit state and guide files to keep work inspectable, compact, and
+verification-friendly.
+
+## Required Workflow
+
+1. Non-trivial work starts with an approved plan.
+2. Each task defines \`files\`, \`action\`, \`verify\`, and \`done\`.
+3. Non-trivial work proceeds through \`execute -> refactor -> verify\`.
+4. Final verification is always performed by a fresh agent.
+5. Verification is a closure step, not test-only behavior.
+
+## Agent Roles
+
+- The main agent owns orchestration and user communication.
+- Main-agent progress updates to the user are always in Korean.
+- Subagents are bounded workers and must be reset or replaced after completion.
+- Every new implementation agent reads \`${STATE_ROOT_NAME}/guides/code-consistency.md\` first.
+- The main agent references \`${STATE_ROOT_NAME}/guides/code-consistency.md\` before assigning new work.
+
+## Code Quality Rules
+
+- Prefer reuse before adding parallel duplicate implementations.
+- Keep files short and single-purpose.
+- Keep functions short and single-purpose.
+- Prefer simple top-down control flow.
+- Avoid clever abstractions and speculative generalization.
+- Keep naming predictable and module boundaries explicit.
+- Write code that a fresh agent can read quickly.
+
+## Verification Rules
+
+- Final verification must be performed by a fresh agent.
+- Verification compares plan vs actual and records deferred issues.
+- Verification checks next-agent guidance and readability, not only tests.
+- Keep work journal updates outside the default hot path.
+
+## State and Guide Rules
+
+- Hot path starts with \`${STATE_ROOT_NAME}/project.md\` and \`${STATE_ROOT_NAME}/state.md\`.
+- Update next-agent guidance after non-trivial code changes.
+- If new conventions are introduced, update \`${STATE_ROOT_NAME}/guides/code-consistency.md\`.
+
+## Work Journal Rules
+
+- After verified completion, update the human work journal under
+  \`${STATE_ROOT_NAME}/logs/work-journal/\`.
+- The work journal is for people, not for agent continuity state.
+
+## Git Rules
+
+- Use git as context support only.
+- Keep changed-file scope visible when available.
+- Do not rely on destructive git automation.
+
+## Repo Entry Points
+
+${alwaysReadList(context)}
+`;
+}
+function projectTemplate(context) {
+  return `# Project Brief
+
+## Purpose
+
+- Project name: ${context.projectName}
+- Replace this section with the actual project purpose.
+- Keep this file short and update it when the architecture truth changes.
+
+## Core Constraints
+
+- Follow the workflow defined in AGENTS.md.
+- Keep state inspectable through ${STATE_ROOT_NAME}/.
+- Optimize for reuse, readability, and low complexity.
+
+## Important Entrypoints
+
+- AGENTS.md
+- ${STATE_ROOT_NAME}/state.md
+- ${STATE_ROOT_NAME}/guides/read-this-first.md
+- ${STATE_ROOT_NAME}/guides/code-consistency.md
+
+## Always-Read Docs or Files
+
+${alwaysReadList(context)}
+
+## Architecture Truth
+
+- Replace with a short summary of the current architecture.
+- Keep module boundaries explicit.
+- Prefer top-down, easy-to-modify flows.
+`;
+}
+function codeConsistencyTemplate() {
+  return `# Code Consistency Guide
+
+## Purpose
+
+This file defines the structural consistency rules every new agent reads before
+implementation.
+
+## Architecture Style Summary
+
+- Prefer small modules with single responsibilities.
+- Keep orchestration code separate from filesystem, git, and template logic.
+- Favor simple top-down flow over clever abstraction chains.
+
+## Naming Rules
+
+- Use direct names that reveal responsibility quickly.
+- Keep command names aligned with workflow stages.
+- Keep template and state file names predictable.
+
+## Module Boundary Rules
+
+- CLI parsing stays separate from command logic.
+- Command logic stays separate from state persistence.
+- Template generation stays separate from command output.
+- Verification logic stays separate from execution logic.
+
+## Reuse Rules
+
+- Reuse existing helpers before creating parallel implementations.
+- Extract shared logic only when reuse is current and obvious.
+- Do not over-generalize for hypothetical future use.
+
+## Readability Rules
+
+- Keep files short and focused.
+- Keep functions short and focused.
+- Prefer explicit data flow over hidden side effects.
+- Add short comments only when the control flow is not self-evident.
+
+## Anti-Patterns
+
+- Clever abstractions that hide simple behavior
+- Overlong files and functions
+- Mixed responsibilities in one module
+- Vague naming
+- Hidden state transitions
+
+## Reference Files To Read First
+
+- AGENTS.md
+- ${STATE_ROOT_NAME}/project.md
+- ${STATE_ROOT_NAME}/state.md
+- ${STATE_ROOT_NAME}/guides/read-this-first.md
+
+## Known Consistency Debt
+
+- Fill this section with real debt as the project evolves.
+`;
+}
+function buildRepoDocumentFiles(context) {
+  return [
+    { path: "AGENTS.md", content: agentsTemplate(context) },
+    { path: `${STATE_ROOT_NAME}/project.md`, content: projectTemplate(context) },
+    {
+      path: `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      content: codeConsistencyTemplate()
+    }
+  ];
+}
+
+// src/lib/templates/state-documents.ts
+function stateTemplate() {
+  return renderStateMarkdown(createInitialCurrentIndex());
+}
+function readThisFirstTemplate(context) {
+  return renderReadThisFirstMarkdown(
+    createInitialCurrentIndex(),
+    context.implementationMenuPath
+  );
+}
+function workJournalTemplate() {
+  return `# Work Journal
+
+Daily human-readable logs live in this directory.
+
+Recommended filename pattern:
+
+- YYYY-MM-DD.md
+
+Required sections for each entry:
+
+- Date
+- Summary
+- Completed
+- Changed Areas
+- Verification
+- Open Issues
+- Next
+`;
+}
+function indexReadmeTemplate() {
+  return `# Index
+
+This directory stores compact navigational artifacts and structured current
+state references used by status and verification helpers.
+`;
+}
+function currentIndexTemplate() {
+  return JSON.stringify(createInitialCurrentIndex(), null, 2) + "\n";
+}
+function buildStateDocumentFiles(context) {
+  return [
+    { path: `${STATE_ROOT_NAME}/state.md`, content: stateTemplate() },
+    {
+      path: `${STATE_ROOT_NAME}/guides/read-this-first.md`,
+      content: readThisFirstTemplate(context)
+    },
+    {
+      path: `${STATE_ROOT_NAME}/plans/README.md`,
+      content: dirReadmeTemplate("Plans", "Store draft and approved plans here.")
+    },
+    {
+      path: `${STATE_ROOT_NAME}/runs/README.md`,
+      content: dirReadmeTemplate("Runs", "Store launch and run metadata here.")
+    },
+    {
+      path: `${STATE_ROOT_NAME}/summaries/README.md`,
+      content: dirReadmeTemplate(
+        "Summaries",
+        "Store execution, verification, and reconciliation summaries here."
+      )
+    },
+    {
+      path: `${STATE_ROOT_NAME}/handoffs/README.md`,
+      content: dirReadmeTemplate(
+        "Handoffs",
+        "Store next-agent guidance and interrupted-work handoffs here."
+      )
+    },
+    {
+      path: `${STATE_ROOT_NAME}/reviews/README.md`,
+      content: dirReadmeTemplate(
+        "Reviews",
+        "Store consistency, verification, and acceptance review artifacts here."
+      )
+    },
+    {
+      path: `${STATE_ROOT_NAME}/logs/work-journal/README.md`,
+      content: workJournalTemplate()
+    },
+    {
+      path: `${STATE_ROOT_NAME}/index/README.md`,
+      content: indexReadmeTemplate()
+    },
+    {
+      path: `${STATE_ROOT_NAME}/index/current.json`,
+      content: currentIndexTemplate()
+    }
+  ];
+}
+
+// src/lib/templates/documents.ts
+function buildDocumentFiles(context) {
+  return [
+    ...buildRepoDocumentFiles(context),
+    ...buildStateDocumentFiles(context)
+  ];
+}
+
+// src/lib/templates/ignore.ts
+var SHARED_IGNORE_LINES = [
+  "node_modules/",
+  "dist/",
+  "build/",
+  "coverage/",
+  ".DS_Store"
+];
+function buildBaseIgnoreTemplate() {
+  return `# sb-codex-tool default agent-ignore patterns
+${SHARED_IGNORE_LINES.join("\n")}
+${STATE_ROOT_NAME}/logs/work-journal/
+`;
+}
+function getGitIgnoreLines() {
+  return [...SHARED_IGNORE_LINES];
+}
+function getSearchIgnoreLines() {
+  return [
+    ...SHARED_IGNORE_LINES,
+    `${STATE_ROOT_NAME}/logs/work-journal/`
+  ];
+}
+
+// src/lib/templates/workflows.ts
+function buildWorkflowFile(name, purpose, outputs) {
+  return {
+    path: `${STATE_ROOT_NAME}/workflows/${name}.md`,
+    content: workflowTemplate(name, purpose, outputs.join("\n"))
+  };
+}
+function buildWorkflowFiles() {
+  return [
+    buildWorkflowFile(
+      "clarify",
+      "Turn an ambiguous request into a compact brief with clear acceptance criteria and boundaries.",
+      [
+        "- compact brief",
+        "- acceptance criteria",
+        "- boundaries",
+        "- assumptions",
+        "- non-goals"
+      ]
+    ),
+    buildWorkflowFile(
+      "plan",
+      "Create a decision-complete plan with executable tasks and explicit verification criteria.",
+      [
+        "- objective",
+        "- acceptance criteria",
+        "- boundaries",
+        "- task list with files/action/verify/done"
+      ]
+    ),
+    buildWorkflowFile(
+      "execute",
+      "Advance work task by task while keeping scope, blockers, and status explicit.",
+      [
+        "- task progression",
+        "- status updates",
+        "- blocker notes",
+        "- changed-file scope"
+      ]
+    ),
+    buildWorkflowFile(
+      "refactor",
+      "Reduce complexity and improve reuse, readability, and maintainability before closure.",
+      [
+        "- simplification notes",
+        "- reuse decisions",
+        "- readability improvements",
+        "- complexity reductions"
+      ]
+    ),
+    buildWorkflowFile(
+      "verify",
+      "Perform fresh-agent closure after refactor with evidence, reconciliation, and next-agent checks.",
+      [
+        "- fresh-agent verification result",
+        "- plan-vs-actual reconciliation",
+        "- deferred issues",
+        "- next-agent guidance check",
+        "- work journal precondition"
+      ]
+    )
+  ];
+}
+
+// src/lib/templates/generated-files.ts
+function buildGeneratedFiles(context) {
+  return [
+    ...buildDocumentFiles(context),
+    ...buildWorkflowFiles(),
+    {
+      path: `${STATE_ROOT_NAME}/ignore/base.ignore`,
+      content: buildBaseIgnoreTemplate()
+    }
+  ];
+}
+
+// src/lib/assignment.ts
+function readAllowedFileScope(root, guidePath) {
+  if (guidePath === null) {
+    return [];
+  }
+  const text = readTextIfPresent(path5.join(root, guidePath));
+  if (text === null) {
+    return [];
+  }
+  return extractSectionLines(text, "Allowed File Scope");
+}
+function buildAssignmentGuide(agentName, title, current, assignmentSlug, allowedFileScope) {
+  const fileScope = allowedFileScope.length > 0 ? allowedFileScope.join("\n") : "- Replace with the bounded file scope for this assignment.";
+  return `# Assignment Guide: ${title}
+
+## Assigned Agent
+
+- ${agentName}
+
+## Assignment Slug
+
+- ${assignmentSlug}
+
+## Objective
+
+- Replace with the bounded objective for ${agentName}.
+
+## Current Cycle References
+
+- Current plan: ${current.latestApprovedPlan ?? "none yet"}
+- Latest summary: ${current.latestRelevantSummary ?? "none yet"}
+- Current guide: ${current.currentGuide ?? "none yet"}
+- Latest lifecycle run: ${current.latestRun ?? "none yet"}
+
+## Allowed File Scope
+
+${fileScope}
+
+## Required References
+
+- AGENTS.md
+- ${STATE_ROOT_NAME}/guides/code-consistency.md
+- ${current.latestApprovedPlan ?? `${STATE_ROOT_NAME}/plans/README.md`}
+- ${current.latestRelevantSummary ?? `${STATE_ROOT_NAME}/summaries/README.md`}
+- ${current.currentGuide ?? `${STATE_ROOT_NAME}/guides/read-this-first.md`}
+
+## Consistency Expectations
+
+- Read ${STATE_ROOT_NAME}/guides/code-consistency.md before implementation.
+- Reuse existing helpers before adding parallel implementations.
+- Keep files and functions short, simple, and readable.
+- Keep module boundaries explicit and avoid clever abstractions.
+
+## Verification Expectations
+
+- Keep the work bounded to the allowed file scope unless the main agent expands it.
+- Report any blocker or scope mismatch back to the main agent immediately.
+- Do not self-approve final completion; final verification stays fresh-agent-only.
+
+## Completion Rule
+
+- When the bounded task is complete, the main agent must either close and replace this subagent or clear its context before same-role reuse.
+`;
+}
+function createAssignmentGuide(start, agentName, requestedSlug, requestedTitle) {
+  const root = resolveProjectRoot(start);
+  const current = normalizeCurrentIndex(readCurrentIndex(root));
+  if (current.latestApprovedPlan === null) {
+    throw new Error("assign requires a current approved plan.");
+  }
+  if (current.latestRelevantSummary === null) {
+    throw new Error("assign requires a current summary.");
+  }
+  if (current.currentGuide === null) {
+    throw new Error("assign requires a current task guide.");
+  }
+  const assignmentSlug = normalizeSlug(requestedSlug);
+  if (assignmentSlug.length === 0) {
+    throw new Error("Assignment slug must contain at least one alphanumeric character.");
+  }
+  const agentSlug = normalizeSlug(agentName);
+  if (agentSlug.length === 0) {
+    throw new Error("Agent name must contain at least one alphanumeric character.");
+  }
+  const title = requestedTitle?.trim().length ? requestedTitle.trim() : humanizeSlug(assignmentSlug);
+  const { dateStamp } = parseCycleDescriptor(current.latestApprovedPlan);
+  const assignmentPath = `${STATE_ROOT_NAME}/guides/${dateStamp}-${agentSlug}-${assignmentSlug}-assignment.md`;
+  const allowedFileScope = readAllowedFileScope(root, current.currentGuide);
+  const writeResult = writeFileIfMissing(
+    path5.join(root, assignmentPath),
+    buildAssignmentGuide(agentName, title, current, assignmentSlug, allowedFileScope)
+  );
+  const createdFiles = [];
+  const keptFiles = [];
+  if (writeResult === "created") {
+    createdFiles.push(assignmentPath);
+  } else {
+    keptFiles.push(assignmentPath);
+  }
+  const nextSubagents = current.activeAgents.subagents.includes(agentName) ? current.activeAgents.subagents : [...current.activeAgents.subagents, agentName];
+  const nextFocusModules = current.currentFocusModules.includes(assignmentPath) ? current.currentFocusModules : [...current.currentFocusModules, assignmentPath];
+  const nextCurrent = normalizeCurrentIndex({
+    ...current,
+    currentFocusModules: nextFocusModules,
+    activeAgents: {
+      ...current.activeAgents,
+      subagents: nextSubagents
+    },
+    assignmentGuides: {
+      ...current.assignmentGuides,
+      [agentName]: assignmentPath
+    },
+    notes: [
+      `Current work cycle: ${humanizeSlug(parseCycleDescriptor(current.latestApprovedPlan).slug)}.`,
+      `Prepared assignment guide for ${agentName}: ${assignmentPath}.`,
+      `Previous relevant summary: ${current.latestRelevantSummary}`
+    ]
+  });
+  const updatedFiles = [];
+  const currentWrites = writeCurrentArtifacts(
+    root,
+    nextCurrent,
+    buildTemplateContext(root).implementationMenuPath
+  );
+  if (currentWrites.index !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/index/current.json`);
+  }
+  if (currentWrites.state !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/state.md`);
+  }
+  if (currentWrites.readThisFirst !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/guides/read-this-first.md`);
+  }
+  return {
+    root,
+    agentName,
+    title,
+    assignmentPath,
+    createdFiles,
+    keptFiles,
+    updatedFiles
+  };
+}
+
+// src/commands/assign.ts
+function runAssign(args) {
+  const [agentName, slug, ...titleParts] = args;
+  if (agentName === void 0 || slug === void 0) {
+    console.error("Usage: sb-codex-tool assign <agent-name> <slug> [title words]");
+    return 1;
+  }
+  const title = titleParts.length > 0 ? titleParts.join(" ") : void 0;
+  const result = createAssignmentGuide(process.cwd(), agentName, slug, title);
+  console.log(`Project root: ${result.root}`);
+  console.log(`Assigned agent: ${result.agentName}`);
+  console.log(`Assignment: ${result.title}`);
+  console.log("");
+  console.log("Artifacts:");
+  console.log(`- assignment guide: ${result.assignmentPath}`);
+  console.log("");
+  console.log(`Created files: ${result.createdFiles.length}`);
+  for (const file of result.createdFiles) {
+    console.log(`- ${file}`);
+  }
+  if (result.updatedFiles.length > 0) {
+    console.log("");
+    console.log("Updated state:");
+    for (const file of result.updatedFiles) {
+      console.log(`- ${file}`);
+    }
+  }
+  return 0;
+}
+
+// src/lib/work-cycle.ts
+import path7 from "node:path";
+
+// src/lib/git.ts
+import { spawnSync } from "node:child_process";
+function runGit(root, args) {
+  const result = spawnSync("git", args, {
+    cwd: root,
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "ignore"]
+  });
+  if (result.status !== 0) {
+    return null;
+  }
+  return result.stdout.trim();
+}
+function getGitContext(root) {
+  const insideWorkTree = runGit(root, ["rev-parse", "--is-inside-work-tree"]);
+  if (insideWorkTree !== "true") {
+    return {
+      available: false,
+      branch: null,
+      dirty: false,
+      changedFiles: []
+    };
+  }
+  const branch = runGit(root, ["branch", "--show-current"]);
+  const status = runGit(root, ["status", "--porcelain"]) ?? "";
+  const changedFiles = status.split("\n").map((line) => line.trim()).filter((line) => line.length > 0).map((line) => line.slice(3));
+  return {
+    available: true,
+    branch,
+    dirty: changedFiles.length > 0,
+    changedFiles
+  };
+}
+
+// src/lib/run-records.ts
+import path6 from "node:path";
+function readLifecycleRunRecord(root, relativePath) {
+  if (relativePath === null) {
+    return null;
+  }
+  return readJsonIfPresent(path6.join(root, relativePath));
+}
+function lifecycleRunPath(dateStamp, slug) {
+  return `${STATE_ROOT_NAME}/runs/${dateStamp}-${slug}-run.json`;
+}
+function renderGitContextSection(runPath, git) {
+  const lines = [
+    "## Git Context",
+    "",
+    `- Run artifact: ${runPath}`,
+    `- Git available: ${git.available ? "yes" : "no"}`,
+    `- Branch: ${git.available ? git.branch ?? "detached" : "unavailable"}`,
+    `- Dirty: ${git.available ? git.dirty ? "yes" : "no" : "unavailable"}`
+  ];
+  if (!git.available) {
+    lines.push("- Changed files: unavailable outside a Git repository");
+    return `${lines.join("\n")}
+`;
+  }
+  if (git.changedFiles.length === 0) {
+    lines.push("- Changed files: none");
+    return `${lines.join("\n")}
+`;
+  }
+  lines.push("- Changed files:");
+  for (const file of git.changedFiles) {
+    lines.push(`  - ${file}`);
+  }
+  return `${lines.join("\n")}
+`;
+}
+function writeLifecycleRunRecord(root, options) {
+  const now = (options.now ?? /* @__PURE__ */ new Date()).toISOString();
+  const relativePath = lifecycleRunPath(options.dateStamp, options.slug);
+  const absolutePath = path6.join(root, relativePath);
+  const previous = readJsonIfPresent(absolutePath);
+  const record = {
+    version: 1,
+    cycleId: `${options.dateStamp}-${options.slug}`,
+    dateStamp: options.dateStamp,
+    slug: options.slug,
+    title: options.title,
+    phase: options.phase,
+    stage: options.stage,
+    verdict: options.verdict,
+    git: options.git,
+    paths: options.paths,
+    startedAt: previous?.startedAt ?? now,
+    updatedAt: now,
+    closedAt: options.verdict === "pass" || options.verdict === "pass_with_concerns" ? now : previous?.closedAt ?? null
+  };
+  return {
+    path: relativePath,
+    writeResult: writeFileIfChanged(
+      absolutePath,
+      JSON.stringify(record, null, 2) + "\n"
+    ),
+    record
+  };
+}
+
+// src/lib/work-cycle.ts
+function planTemplate(title) {
+  return `# Approved Plan: ${title}
+
+## Objective
+
+- Replace with the concrete objective for this work cycle.
+
+## Acceptance Criteria
+
+- Replace with the acceptance criteria that define completion.
+
+## Boundaries
+
+- Replace with in-scope and out-of-scope notes.
+
+## Tasks
+
+### Task 1
+
+- files: \`fill-in-file-scope\`
+- action: describe the concrete implementation task
+- verify: describe how this task will be checked
+- done: no
+`;
+}
+function executionSummaryTemplate(title, guidePath, planPath) {
+  return `# Execution Summary: ${title}
+
+## Purpose
+
+- Capture implementation progress for the current work cycle before fresh verification.
+
+## Scope
+
+- Replace with the actual implementation scope.
+
+## Implemented Surface
+
+- not started yet
+
+## Checks Run
+
+- none yet
+
+## Plan vs Actual
+
+- Update this section as implementation progresses.
+
+## Refactor Notes
+
+- Update this section after refactor.
+
+## Deferred Issues
+
+- Add deferred issues if they exist.
+
+## Next-Agent Guidance
+
+- Start from this execution summary as the latest relevant summary.
+- Then review \`${planPath}\`.
+- Then review \`${guidePath}\`.
+`;
+}
+function handoffTemplate(title, guidePath, planPath, summaryPath, gitContextSection) {
+  return `# Handoff: ${title}
+
+## Goal
+
+- Enable the next fresh agent to continue this work cycle without hidden context.
+
+## Read In This Order
+
+1. AGENTS.md
+2. ${STATE_ROOT_NAME}/project.md
+3. ${STATE_ROOT_NAME}/state.md
+4. ${STATE_ROOT_NAME}/guides/read-this-first.md
+5. ${STATE_ROOT_NAME}/guides/code-consistency.md
+6. ${summaryPath}
+7. ${planPath}
+8. ${guidePath}
+
+## Current Status
+
+- Replace with the current implementation status.
+
+${gitContextSection}
+
+## Expected Verification Checks
+
+- Replace with the checks relevant to this work cycle.
+
+## Open Risks
+
+- Replace with the current blocker or risk list.
+`;
+}
+function reviewTemplate(title) {
+  return `# Fresh Verification Review: ${title}
+
+## Verification Target
+
+- ${title}
+
+## Verdict
+
+- pending
+
+## Required Checks
+
+- Contract reading order completed
+- Acceptance criteria reviewed
+- State and guide artifacts inspected
+- Relevant code and tests inspected
+- Required checks run
+
+## Checks Run
+
+- Add the checks run during the fresh verification pass.
+
+## Findings
+
+- Add findings here in severity order.
+
+## Concerns
+
+- Add non-blocking concerns here.
+
+## Missing Evidence
+
+- Add any blocked evidence here.
+
+## Work Journal Decision
+
+- Record whether verified closure is complete enough to update the work journal.
+`;
+}
+function scopeGuideTemplate(title, planPath, previousSummary) {
+  return `# Scope Guide: ${title}
+
+## Purpose
+
+- Narrow the current work cycle to a bounded file scope and clear verification expectations.
+
+## Working Goal
+
+- Replace with the concrete goal for this cycle.
+
+## Primary Plan
+
+- ${planPath}
+
+## Allowed File Scope
+
+- Replace with the files or modules that should be touched.
+
+## Recommended References
+
+- AGENTS.md
+- ${STATE_ROOT_NAME}/project.md
+- ${STATE_ROOT_NAME}/state.md
+- ${STATE_ROOT_NAME}/guides/code-consistency.md
+${previousSummary === null ? "" : `- ${previousSummary}
+`}
+## Verification Expectations
+
+- Replace with the checks and verdict expectations for this cycle.
+`;
+}
+function beginWorkCycle(start, requestedSlug, requestedTitle) {
+  const root = resolveProjectRoot(start);
+  const slug = normalizeSlug(requestedSlug);
+  if (slug.length === 0) {
+    throw new Error("Work-cycle slug must contain at least one alphanumeric character.");
+  }
+  const title = requestedTitle?.trim().length ? requestedTitle.trim() : humanizeSlug(slug);
+  const dateStamp = formatDateStamp();
+  const current = normalizeCurrentIndex(readCurrentIndex(root));
+  const previousSummary = current.latestRelevantSummary;
+  const planPath = `${STATE_ROOT_NAME}/plans/${dateStamp}-${slug}-approved.md`;
+  const summaryPath = `${STATE_ROOT_NAME}/summaries/${dateStamp}-${slug}-execution-summary.md`;
+  const handoffPath = `${STATE_ROOT_NAME}/handoffs/${dateStamp}-${slug}-to-verification.md`;
+  const reviewPath = `${STATE_ROOT_NAME}/reviews/${dateStamp}-${slug}-fresh-verification.md`;
+  const guidePath = `${STATE_ROOT_NAME}/guides/${dateStamp}-${slug}-scope.md`;
+  const runPath = lifecycleRunPath(dateStamp, slug);
+  const sameCycle = current.latestApprovedPlan === planPath;
+  const generatedFiles = [
+    { path: planPath, content: planTemplate(title) },
+    { path: summaryPath, content: executionSummaryTemplate(title, guidePath, planPath) },
+    { path: reviewPath, content: reviewTemplate(title) },
+    { path: guidePath, content: scopeGuideTemplate(title, planPath, previousSummary) }
+  ];
+  const createdFiles = [];
+  const keptFiles = [];
+  for (const file of generatedFiles) {
+    const result = writeFileIfMissing(path7.join(root, file.path), file.content);
+    if (result === "created") {
+      createdFiles.push(file.path);
+    } else {
+      keptFiles.push(file.path);
+    }
+  }
+  const latestSummary = sameCycle ? current.latestRelevantSummary ?? summaryPath : summaryPath;
+  const git = getGitContext(root);
+  const handoffContent = handoffTemplate(
+    title,
+    guidePath,
+    planPath,
+    summaryPath,
+    renderGitContextSection(runPath, git)
+  );
+  const handoffWrite = writeFileIfMissing(path7.join(root, handoffPath), handoffContent);
+  if (handoffWrite === "created") {
+    createdFiles.push(handoffPath);
+  } else {
+    keptFiles.push(handoffPath);
+  }
+  const currentGuide = sameCycle ? current.currentGuide ?? guidePath : guidePath;
+  const currentHandoff = sameCycle ? current.currentHandoff ?? handoffPath : handoffPath;
+  const currentReview = sameCycle ? current.currentReview ?? reviewPath : reviewPath;
+  const latestRun = sameCycle ? current.latestRun ?? runPath : runPath;
+  const updatedFiles = [];
+  const runWrite = writeLifecycleRunRecord(root, {
+    dateStamp,
+    slug,
+    title,
+    phase: "begin",
+    stage: sameCycle ? current.currentStage : "clarify",
+    verdict: "pending",
+    git,
+    paths: {
+      planPath,
+      executionSummaryPath: summaryPath,
+      handoffPath: currentHandoff,
+      reviewPath: currentReview,
+      guidePath: currentGuide,
+      verificationSummaryPath: null,
+      journalPath: null
+    }
+  });
+  if (runWrite.writeResult === "created") {
+    createdFiles.push(runWrite.path);
+  } else if (runWrite.writeResult === "updated") {
+    updatedFiles.push(runWrite.path);
+  }
+  const nextCurrent = normalizeCurrentIndex({
+    ...current,
+    currentStage: sameCycle ? current.currentStage : "clarify",
+    nextAction: sameCycle ? current.nextAction : `Fill in ${planPath} and narrow ${guidePath} before implementation starts.`,
+    latestApprovedPlan: planPath,
+    latestRelevantSummary: latestSummary,
+    latestRun,
+    currentGuide,
+    currentHandoff,
+    currentReview,
+    currentFocusModules: [
+      "AGENTS.md",
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      latestRun,
+      latestSummary,
+      planPath,
+      currentGuide,
+      currentHandoff,
+      currentReview
+    ],
+    hotPath: [
+      `${STATE_ROOT_NAME}/project.md`,
+      `${STATE_ROOT_NAME}/state.md`,
+      `${STATE_ROOT_NAME}/guides/read-this-first.md`,
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      latestSummary,
+      planPath,
+      currentGuide
+    ],
+    activeAgents: sameCycle ? current.activeAgents : {
+      main: "current main session",
+      subagents: [],
+      verification: null,
+      consistency: null
+    },
+    notes: sameCycle ? current.notes : [
+      `Current work cycle: ${title}.`,
+      `Fill in the approved plan and scope guide before implementation starts.`,
+      previousSummary === null ? "No previous summary was recorded." : `Previous relevant summary: ${previousSummary}`
+    ]
+  });
+  const currentWrites = writeCurrentArtifacts(
+    root,
+    nextCurrent,
+    buildTemplateContext(root).implementationMenuPath
+  );
+  if (currentWrites.index !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/index/current.json`);
+  }
+  if (currentWrites.state !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/state.md`);
+  }
+  if (currentWrites.readThisFirst !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/guides/read-this-first.md`);
+  }
+  return {
+    root,
+    slug,
+    title,
+    createdFiles,
+    keptFiles,
+    updatedFiles,
+    planPath,
+    summaryPath,
+    runPath: runWrite.path,
+    handoffPath,
+    reviewPath,
+    guidePath
+  };
+}
+
+// src/commands/begin.ts
+function runBegin(args) {
+  const [slug, ...titleParts] = args;
+  if (slug === void 0) {
+    console.error("Usage: sb-codex-tool begin <slug> [title words]");
+    return 1;
+  }
+  const title = titleParts.length > 0 ? titleParts.join(" ") : void 0;
+  const result = beginWorkCycle(process.cwd(), slug, title);
+  console.log(`Project root: ${result.root}`);
+  console.log(`Work cycle: ${result.title}`);
+  console.log("");
+  console.log("Artifacts:");
+  console.log(`- plan: ${result.planPath}`);
+  console.log(`- summary: ${result.summaryPath}`);
+  console.log(`- run: ${result.runPath}`);
+  console.log(`- handoff: ${result.handoffPath}`);
+  console.log(`- review: ${result.reviewPath}`);
+  console.log(`- guide: ${result.guidePath}`);
+  console.log("");
+  console.log(`Created files: ${result.createdFiles.length}`);
+  for (const file of result.createdFiles) {
+    console.log(`- ${file}`);
+  }
+  if (result.updatedFiles.length > 0) {
+    console.log("");
+    console.log("Updated state:");
+    for (const file of result.updatedFiles) {
+      console.log(`- ${file}`);
+    }
+  }
+  return 0;
+}
+
+// src/lib/close-cycle.ts
+import path9 from "node:path";
+
+// src/lib/work-journal.ts
+import path8 from "node:path";
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeList(items, fallback) {
+  const unique = items.filter((item, index) => items.indexOf(item) === index);
+  return unique.length > 0 ? unique : [fallback];
+}
+function renderBullet(item) {
+  return item.split("\n").map((line, index) => index === 0 ? `- ${line}` : `  ${line}`).join("\n");
+}
+function renderBulletList2(items) {
+  return normalizeList(items, "None.").map((item) => renderBullet(item)).join("\n");
+}
+function buildEntry(input) {
+  return `## Entry: ${input.title}
+
+### Date
+
+- ${input.dateStamp}
+
+### Summary
+
+${renderBulletList2(input.summaryLines)}
+
+### Completed
+
+${renderBulletList2(input.completedLines)}
+
+### Changed Areas
+
+${renderBulletList2(input.changedAreas)}
+
+### Verification
+
+- Fresh verification verdict: \`${input.verdict}\`
+- Verification summary: \`${input.verificationSummaryPath}\`
+
+### Open Issues
+
+${renderBulletList2(input.openIssues)}
+
+### Next
+
+- ${input.nextAction}
+`;
+}
+function getWorkJournalPath(root, dateStamp) {
+  return path8.join(root, STATE_ROOT_NAME, "logs", "work-journal", `${dateStamp}.md`);
+}
+function writeWorkJournalEntry(root, input) {
+  const journalPath = getWorkJournalPath(root, input.dateStamp);
+  const current = readTextIfPresent(journalPath);
+  const entry = buildEntry(input).trimEnd();
+  if (current === null) {
+    return writeFileIfChanged(
+      journalPath,
+      `# ${input.dateStamp}
+
+${entry}
+`
+    );
+  }
+  const marker = `## Entry: ${input.title}`;
+  const pattern = new RegExp(
+    `${escapeRegExp(marker)}[\\s\\S]*?(?=\\n## Entry: |$)`,
+    "m"
+  );
+  const next = pattern.test(current) ? current.replace(pattern, entry) : `${current.trimEnd()}
+
+${entry}
+`;
+  return writeFileIfChanged(journalPath, next.endsWith("\n") ? next : `${next}
+`);
+}
+
+// src/lib/close-cycle.ts
+var VERDICTS = ["pass", "pass_with_concerns", "fail", "blocked"];
+var REVIEW_PLACEHOLDERS = {
+  findings: [
+    "- Add findings here in severity order.",
+    "- None."
+  ],
+  concerns: [
+    "- Add non-blocking concerns here.",
+    "- None."
+  ],
+  missingEvidence: [
+    "- Add any blocked evidence here.",
+    "- None."
+  ]
+};
+function isClosingVerdict(verdict) {
+  return verdict === "pass" || verdict === "pass_with_concerns";
+}
+function extractVerdict(content) {
+  const verdict = extractSectionLines(content, "Verdict")[0]?.replace(/^- /, "");
+  if (verdict === void 0 || !VERDICTS.includes(verdict)) {
+    throw new Error("close requires the current review to contain a final verification verdict.");
+  }
+  return verdict;
+}
+function sectionContainsPlaceholder(lines, placeholders) {
+  return lines.some((line) => placeholders.includes(line));
+}
+function sectionHasExplicitDetail(lines, placeholders) {
+  return lines.some((line) => !placeholders.includes(line));
+}
+function parseReview(content) {
+  const review = {
+    verdict: extractVerdict(content),
+    findings: extractSectionLines(content, "Findings"),
+    concerns: extractSectionLines(content, "Concerns"),
+    missingEvidence: extractSectionLines(content, "Missing Evidence"),
+    checksRun: extractSectionLines(content, "Checks Run")
+  };
+  if (review.verdict === "pass_with_concerns" && (sectionContainsPlaceholder(review.concerns, REVIEW_PLACEHOLDERS.concerns) || !sectionHasExplicitDetail(review.concerns, REVIEW_PLACEHOLDERS.concerns))) {
+    throw new Error(
+      "close requires explicit concerns in the review before pass_with_concerns can close the cycle."
+    );
+  }
+  if (review.verdict === "fail" && (sectionContainsPlaceholder(review.findings, REVIEW_PLACEHOLDERS.findings) || !sectionHasExplicitDetail(review.findings, REVIEW_PLACEHOLDERS.findings))) {
+    throw new Error(
+      "close requires explicit findings in the review before fail can be recorded."
+    );
+  }
+  if (review.verdict === "blocked" && (sectionContainsPlaceholder(
+    review.missingEvidence,
+    REVIEW_PLACEHOLDERS.missingEvidence
+  ) || !sectionHasExplicitDetail(
+    review.missingEvidence,
+    REVIEW_PLACEHOLDERS.missingEvidence
+  ))) {
+    throw new Error(
+      "close requires explicit missing evidence details before blocked can be recorded."
+    );
+  }
+  return review;
+}
+function updateWorkJournalDecision(content, verdict) {
+  const decision = isClosingVerdict(verdict) ? "Verified closure is complete enough to update the work journal." : "Do not update the work journal as verified completion yet.";
+  return content.replace(
+    /(## Work Journal Decision\n\n)- .*?(\n)/,
+    `$1- ${decision}$2`
+  );
+}
+function readChecksRun(root, summaryPath) {
+  const text = readTextIfPresent(path9.join(root, summaryPath));
+  if (text === null) {
+    return ["- none recorded"];
+  }
+  const section = text.match(/## Checks Run\s+([\s\S]*?)\n## /);
+  if (section === null) {
+    return ["- none recorded"];
+  }
+  const lines = section[1].trim().split("\n").map((line) => line.trim()).filter((line) => line.startsWith("- "));
+  return lines.length > 0 ? lines : ["- none recorded"];
+}
+function readSummaryContext(root, summaryPath) {
+  const text = readTextIfPresent(path9.join(root, summaryPath));
+  if (text === null) {
+    return {
+      scope: [],
+      implementedSurface: [],
+      nextAgentGuidance: []
+    };
+  }
+  return {
+    scope: extractSectionLines(text, "Scope"),
+    implementedSurface: extractSectionLines(text, "Implemented Surface"),
+    nextAgentGuidance: extractSectionLines(text, "Next-Agent Guidance")
+  };
+}
+function readAllowedFileScope2(root, guidePath) {
+  if (guidePath === null) {
+    return [];
+  }
+  const text = readTextIfPresent(path9.join(root, guidePath));
+  if (text === null) {
+    return [];
+  }
+  return extractSectionLines(text, "Allowed File Scope");
+}
+function buildVerificationSummary(title, review, planPath, executionSummaryPath, reviewPath, runPath, gitContextSection, guidePath, checksRun) {
+  const closureComplete = isClosingVerdict(review.verdict);
+  const effectiveChecks = review.checksRun.length > 0 ? review.checksRun : checksRun;
+  return `# Verification Summary: ${title}
+
+## Verdict
+
+- ${review.verdict}
+
+## Verification Scope
+
+- ${title}
+- ${planPath}
+- ${executionSummaryPath}
+- ${reviewPath}
+${guidePath === null ? "" : `- ${guidePath}
+`}
+${gitContextSection}
+## Checks Run
+
+${effectiveChecks.join("\n")}
+
+## Evidence
+
+- The fresh verification verdict is recorded in \`${reviewPath}\`.
+- Current-state artifacts can be updated from one shared writer after the
+  review result is already present.
+- The latest verification summary is available for the next-agent hot path.
+${closureComplete ? "- Verified closure is complete enough to update the work journal." : "- Verified closure is not complete enough to update the work journal yet."}
+
+## Plan vs Actual
+
+- Planned: record the fresh verification result for the current cycle
+- Actual: the close flow reads the review artifact and records the result
+- Planned: keep current-state artifacts aligned after closure
+- Actual: the close flow updates the latest summary and hot-path references together
+
+## Findings
+
+${review.findings.length > 0 ? review.findings.join("\n") : "- None."}
+
+## Concerns
+
+${review.concerns.length > 0 ? review.concerns.join("\n") : "- None."}
+
+## Missing Evidence
+
+${review.missingEvidence.length > 0 ? review.missingEvidence.join("\n") : "- None."}
+
+## Closure Decision
+
+- ${closureComplete ? "Verified closure is complete." : "Verified closure is not complete; keep the cycle in verify."}
+
+## Related Review Artifact
+
+- ${reviewPath}
+`;
+}
+function closeCurrentCycle(start) {
+  const root = resolveProjectRoot(start);
+  const current = normalizeCurrentIndex(readCurrentIndex(root));
+  if (current.currentStage !== "verify") {
+    throw new Error("close requires the current stage to be verify.");
+  }
+  if (current.latestApprovedPlan === null) {
+    throw new Error("close requires a current approved plan.");
+  }
+  if (current.latestRelevantSummary === null) {
+    throw new Error("close requires a current execution summary.");
+  }
+  if (current.currentReview === null) {
+    throw new Error("close requires a current review artifact.");
+  }
+  const { dateStamp, slug } = parseCycleDescriptor(current.latestApprovedPlan);
+  const title = readCycleTitle(root, current.latestApprovedPlan, slug);
+  const runPath = lifecycleRunPath(dateStamp, slug);
+  const verificationSummaryPath = `${STATE_ROOT_NAME}/summaries/${dateStamp}-${slug}-verification-summary.md`;
+  const reviewAbsolutePath = path9.join(root, current.currentReview);
+  const reviewBefore = readTextIfPresent(reviewAbsolutePath);
+  if (reviewBefore === null) {
+    throw new Error(`close requires the review artifact ${current.currentReview}.`);
+  }
+  const review = parseReview(reviewBefore);
+  const createdFiles = [];
+  const updatedFiles = [];
+  const closingSummaryContext = isClosingVerdict(review.verdict) ? readSummaryContext(root, current.latestRelevantSummary) : null;
+  const git = getGitContext(root);
+  if (closingSummaryContext !== null && closingSummaryContext.nextAgentGuidance.length === 0) {
+    throw new Error(
+      "close requires the current execution summary to include explicit Next-Agent Guidance before verified closure."
+    );
+  }
+  const reviewWrite = writeFileIfChanged(
+    reviewAbsolutePath,
+    updateWorkJournalDecision(reviewBefore, review.verdict)
+  );
+  if (reviewWrite === "updated") {
+    updatedFiles.push(current.currentReview);
+  }
+  const checksRun = readChecksRun(root, current.latestRelevantSummary);
+  const journalPath = isClosingVerdict(review.verdict) ? `${STATE_ROOT_NAME}/logs/work-journal/${dateStamp}.md` : null;
+  const nextStage = isClosingVerdict(review.verdict) ? "clarify" : "verify";
+  const runWrite = writeLifecycleRunRecord(root, {
+    dateStamp,
+    slug,
+    title,
+    phase: "close",
+    stage: nextStage,
+    verdict: review.verdict,
+    git,
+    paths: {
+      planPath: current.latestApprovedPlan,
+      executionSummaryPath: current.latestRelevantSummary,
+      handoffPath: current.currentHandoff,
+      reviewPath: current.currentReview,
+      guidePath: current.currentGuide,
+      verificationSummaryPath,
+      journalPath
+    }
+  });
+  if (runWrite.writeResult === "created") {
+    createdFiles.push(runWrite.path);
+  } else if (runWrite.writeResult === "updated") {
+    updatedFiles.push(runWrite.path);
+  }
+  const verificationSummary = buildVerificationSummary(
+    title,
+    review,
+    current.latestApprovedPlan,
+    current.latestRelevantSummary,
+    current.currentReview,
+    runWrite.path,
+    renderGitContextSection(runWrite.path, git),
+    current.currentGuide,
+    checksRun
+  );
+  const verificationWrite = writeFileIfChanged(
+    path9.join(root, verificationSummaryPath),
+    verificationSummary
+  );
+  if (verificationWrite === "created") {
+    createdFiles.push(verificationSummaryPath);
+  } else if (verificationWrite === "updated") {
+    updatedFiles.push(verificationSummaryPath);
+  }
+  const nextAction = isClosingVerdict(review.verdict) ? "Start the next implementation increment from a new approved plan." : `Address the latest ${review.verdict} verification result for ${title} and rerun fresh verification.`;
+  if (isClosingVerdict(review.verdict)) {
+    const allowedFileScope = readAllowedFileScope2(root, current.currentGuide);
+    const journalWrite = writeWorkJournalEntry(root, {
+      dateStamp,
+      title,
+      verdict: review.verdict,
+      summaryLines: [
+        `Closed the ${title} increment with verdict \`${review.verdict}\`.`,
+        ...stripBulletPrefix(closingSummaryContext.scope)
+      ],
+      completedLines: [
+        ...stripBulletPrefix(closingSummaryContext.implementedSurface),
+        `Recorded the fresh verification verdict in \`${current.currentReview}\`.`,
+        `Wrote \`${verificationSummaryPath}\`.`,
+        "Updated current-state artifacts for the next step."
+      ],
+      reviewPath: current.currentReview,
+      verificationSummaryPath,
+      changedAreas: stripBulletPrefix(allowedFileScope).length > 0 ? stripBulletPrefix(allowedFileScope) : [
+        current.currentReview,
+        verificationSummaryPath,
+        current.latestApprovedPlan,
+        current.currentGuide ?? "no current guide recorded",
+        `${STATE_ROOT_NAME}/state.md`,
+        `${STATE_ROOT_NAME}/index/current.json`,
+        `${STATE_ROOT_NAME}/guides/read-this-first.md`
+      ],
+      openIssues: review.verdict === "pass" ? ["None."] : review.concerns.map((line) => line.replace(/^- /, "")),
+      nextAction
+    });
+    if (journalWrite === "created") {
+      createdFiles.push(journalPath);
+    } else if (journalWrite === "updated") {
+      updatedFiles.push(journalPath);
+    }
+  }
+  const nextCurrent = normalizeCurrentIndex({
+    ...current,
+    currentStage: nextStage,
+    nextAction,
+    latestRelevantSummary: verificationSummaryPath,
+    latestRun: runWrite.path,
+    currentFocusModules: [
+      "AGENTS.md",
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      verificationSummaryPath,
+      runWrite.path,
+      current.currentReview,
+      current.latestApprovedPlan,
+      current.currentGuide ?? `${STATE_ROOT_NAME}/guides/read-this-first.md`
+    ],
+    hotPath: [
+      `${STATE_ROOT_NAME}/project.md`,
+      `${STATE_ROOT_NAME}/state.md`,
+      `${STATE_ROOT_NAME}/guides/read-this-first.md`,
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      verificationSummaryPath,
+      current.latestApprovedPlan,
+      current.currentGuide ?? `${STATE_ROOT_NAME}/guides/read-this-first.md`
+    ],
+    activeAgents: {
+      ...current.activeAgents,
+      verification: null
+    },
+    notes: isClosingVerdict(review.verdict) ? [
+      `Current work cycle: ${title}.`,
+      `The increment is closed with verdict ${review.verdict}.`,
+      "The next increment can start from a new approved plan.",
+      `Previous relevant summary: ${current.latestRelevantSummary}`
+    ] : [
+      `Current work cycle: ${title}.`,
+      `The latest fresh verification verdict is ${review.verdict}.`,
+      "Address the verification result before attempting closure again.",
+      `Previous relevant summary: ${current.latestRelevantSummary}`
+    ]
+  });
+  const currentWrites = writeCurrentArtifacts(
+    root,
+    nextCurrent,
+    buildTemplateContext(root).implementationMenuPath
+  );
+  if (currentWrites.index !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/index/current.json`);
+  }
+  if (currentWrites.state !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/state.md`);
+  }
+  if (currentWrites.readThisFirst !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/guides/read-this-first.md`);
+  }
+  return {
+    root,
+    title,
+    verdict: review.verdict,
+    reviewPath: current.currentReview,
+    verificationSummaryPath,
+    runPath: runWrite.path,
+    journalPath,
+    createdFiles,
+    updatedFiles
+  };
+}
+
+// src/commands/close.ts
+function runClose(args) {
+  if (args.length > 0) {
+    console.error("Usage: sb-codex-tool close");
+    return 1;
+  }
+  const result = closeCurrentCycle(process.cwd());
+  console.log(`Project root: ${result.root}`);
+  console.log(`Work cycle: ${result.title}`);
+  console.log(`Verdict: ${result.verdict}`);
+  console.log("");
+  console.log("Closure artifacts:");
+  console.log(`- review: ${result.reviewPath}`);
+  console.log(`- verification summary: ${result.verificationSummaryPath}`);
+  console.log(`- run: ${result.runPath}`);
+  console.log(`- work journal: ${result.journalPath ?? "not updated for this verdict"}`);
+  console.log("");
+  console.log(`Created files: ${result.createdFiles.length}`);
+  for (const file of result.createdFiles) {
+    console.log(`- ${file}`);
+  }
+  if (result.updatedFiles.length > 0) {
+    console.log("");
+    console.log("Updated files:");
+    for (const file of result.updatedFiles) {
+      console.log(`- ${file}`);
+    }
+  }
+  return 0;
+}
+
+// src/lib/assignment-lifecycle.ts
+import path10 from "node:path";
+var ASSIGNMENT_LIFECYCLE_ACTIONS = ["close", "clear", "replace"];
+function buildLifecycleArtifact(agentName, title, action, assignmentPath, replacementAssignmentPath) {
+  return `# Assignment Lifecycle: ${title}
+
+## Agent
+
+- ${agentName}
+
+## Decision
+
+- ${action}
+
+## Completed Assignment Guide
+
+- ${assignmentPath}
+
+## Lifecycle Rule Applied
+
+- Default rule is close and replace.
+- Clear is allowed only for the same narrow role after context reset.
+- Final verification remains fresh-agent-only.
+
+## Replacement Assignment
+
+- ${replacementAssignmentPath ?? "none"}
+
+## Next Main-Agent Action
+
+- ${replacementAssignmentPath === null ? "Keep the agent inactive until a new bounded assignment is created." : `Continue with the replacement assignment guide at \`${replacementAssignmentPath}\`.`}
+`;
+}
+function findAssignmentGuide(current, agentName) {
+  const fromMap = current.assignmentGuides[agentName];
+  if (fromMap !== void 0) {
+    return fromMap;
+  }
+  if (current.latestApprovedPlan === null) {
+    return null;
+  }
+  const { dateStamp } = parseCycleDescriptor(current.latestApprovedPlan);
+  const agentSlug = normalizeSlug(agentName);
+  return current.currentFocusModules.find(
+    (entry) => entry.startsWith(`${STATE_ROOT_NAME}/guides/${dateStamp}-${agentSlug}-`) && entry.endsWith("-assignment.md")
+  ) ?? null;
+}
+function removeAssignmentGuide(assignmentGuides, agentName) {
+  const next = { ...assignmentGuides };
+  delete next[agentName];
+  return next;
+}
+function withoutItem(items, target) {
+  return items.filter((item) => item !== target);
+}
+function ensureFocusModules(currentFocusModules, items) {
+  const next = [...currentFocusModules];
+  for (const item of items) {
+    if (item !== null && !next.includes(item)) {
+      next.push(item);
+    }
+  }
+  return next;
+}
+function readAssignmentTitle(root, assignmentPath) {
+  const text = readTextIfPresent(path10.join(root, assignmentPath));
+  const match = text?.match(/^# Assignment Guide: (.+)$/m);
+  return match?.[1]?.trim() ?? humanizeSlug(normalizeSlug(agentNameFromPath(assignmentPath)));
+}
+function agentNameFromPath(assignmentPath) {
+  const fileName = path10.basename(assignmentPath, ".md");
+  return fileName;
+}
+function completeAssignment(start, agentName, action, replacement) {
+  const root = resolveProjectRoot(start);
+  const current = normalizeCurrentIndex(readCurrentIndex(root));
+  if (current.latestApprovedPlan === null) {
+    throw new Error("complete-assignment requires a current approved plan.");
+  }
+  if (!current.activeAgents.subagents.includes(agentName)) {
+    throw new Error(`complete-assignment requires ${agentName} to be an active subagent.`);
+  }
+  const assignmentPath = findAssignmentGuide(current, agentName);
+  if (assignmentPath === null) {
+    throw new Error(`complete-assignment requires an active assignment guide for ${agentName}.`);
+  }
+  if (action === "replace" && replacement === void 0) {
+    throw new Error("complete-assignment replace requires a replacement agent and slug.");
+  }
+  const createdFiles = [];
+  const updatedFiles = [];
+  let replacementAssignmentPath = null;
+  let latestCurrent = current;
+  if (action === "replace" && replacement !== void 0) {
+    const replacementResult = createAssignmentGuide(
+      root,
+      replacement.agentName,
+      replacement.slug,
+      replacement.title
+    );
+    replacementAssignmentPath = replacementResult.assignmentPath;
+    createdFiles.push(...replacementResult.createdFiles);
+    updatedFiles.push(...replacementResult.updatedFiles);
+    latestCurrent = normalizeCurrentIndex(readCurrentIndex(root));
+  }
+  const { dateStamp, slug } = parseCycleDescriptor(latestCurrent.latestApprovedPlan ?? current.latestApprovedPlan);
+  const agentSlug = normalizeSlug(agentName);
+  const lifecyclePath = `${STATE_ROOT_NAME}/handoffs/${dateStamp}-${slug}-${agentSlug}-assignment-lifecycle.md`;
+  const assignmentTitle = readAssignmentTitle(root, assignmentPath);
+  const lifecycleWrite = writeFileIfChanged(
+    path10.join(root, lifecyclePath),
+    buildLifecycleArtifact(
+      agentName,
+      assignmentTitle,
+      action,
+      assignmentPath,
+      replacementAssignmentPath
+    )
+  );
+  if (lifecycleWrite === "created") {
+    createdFiles.push(lifecyclePath);
+  } else if (lifecycleWrite === "updated") {
+    updatedFiles.push(lifecyclePath);
+  }
+  const nextSubagents = withoutItem(latestCurrent.activeAgents.subagents, agentName);
+  const nextAssignmentGuides = removeAssignmentGuide(latestCurrent.assignmentGuides, agentName);
+  const nextFocusModules = ensureFocusModules(
+    withoutItem(latestCurrent.currentFocusModules, assignmentPath),
+    [lifecyclePath, replacementAssignmentPath]
+  );
+  const nextCurrent = normalizeCurrentIndex({
+    ...latestCurrent,
+    latestAssignmentLifecycle: lifecyclePath,
+    currentFocusModules: nextFocusModules,
+    activeAgents: {
+      ...latestCurrent.activeAgents,
+      subagents: nextSubagents
+    },
+    assignmentGuides: nextAssignmentGuides,
+    notes: [
+      `Current work cycle: ${humanizeSlug(parseCycleDescriptor(latestCurrent.latestApprovedPlan ?? current.latestApprovedPlan).slug)}.`,
+      `Recorded ${action} lifecycle decision for ${agentName}: ${lifecyclePath}.`,
+      replacementAssignmentPath === null ? `The completed assignment guide was ${assignmentPath}.` : `Replacement assignment guide: ${replacementAssignmentPath}.`,
+      `Previous relevant summary: ${latestCurrent.latestRelevantSummary}`
+    ]
+  });
+  const currentWrites = writeCurrentArtifacts(
+    root,
+    nextCurrent,
+    buildTemplateContext(root).implementationMenuPath
+  );
+  if (currentWrites.index !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/index/current.json`);
+  }
+  if (currentWrites.state !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/state.md`);
+  }
+  if (currentWrites.readThisFirst !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/guides/read-this-first.md`);
+  }
+  return {
+    root,
+    agentName,
+    action,
+    lifecyclePath,
+    replacementAssignmentPath,
+    createdFiles,
+    updatedFiles
+  };
+}
+
+// src/commands/complete-assignment.ts
+function runCompleteAssignment(args) {
+  const [agentName, action, third, ...rest] = args;
+  if (agentName === void 0 || action === void 0 || !ASSIGNMENT_LIFECYCLE_ACTIONS.includes(action)) {
+    console.error(
+      "Usage: sb-codex-tool complete-assignment <agent-name> <close|clear|replace> [replacement-agent] [replacement-slug] [title words]"
+    );
+    return 1;
+  }
+  const replacement = action === "replace" ? {
+    agentName: third,
+    slug: rest[0],
+    title: rest.slice(1).length > 0 ? rest.slice(1).join(" ") : void 0
+  } : void 0;
+  if (action === "replace" && (replacement?.agentName === void 0 || replacement.slug === void 0)) {
+    console.error(
+      "Usage: sb-codex-tool complete-assignment <agent-name> replace <replacement-agent> <replacement-slug> [title words]"
+    );
+    return 1;
+  }
+  const result = completeAssignment(process.cwd(), agentName, action, replacement);
+  console.log(`Project root: ${result.root}`);
+  console.log(`Completed assignment for: ${result.agentName}`);
+  console.log(`Lifecycle action: ${result.action}`);
+  console.log(`Lifecycle artifact: ${result.lifecyclePath}`);
+  console.log(`Replacement assignment: ${result.replacementAssignmentPath ?? "none"}`);
+  console.log("");
+  console.log(`Created files: ${result.createdFiles.length}`);
+  for (const file of result.createdFiles) {
+    console.log(`- ${file}`);
+  }
+  if (result.updatedFiles.length > 0) {
+    console.log("");
+    console.log("Updated files:");
+    for (const file of result.updatedFiles) {
+      console.log(`- ${file}`);
+    }
+  }
+  return 0;
+}
+
+// src/lib/doctor.ts
+import { existsSync as existsSync5 } from "node:fs";
+import path12 from "node:path";
+
+// src/lib/state-coherence.ts
+import { existsSync as existsSync4 } from "node:fs";
+import path11 from "node:path";
+function createIssue(label, detail, level = "fail") {
+  return { level, label, detail };
+}
+function validateLatestRunCoherence(current, latestRunRecord) {
+  if (current.latestRun === null) {
+    return [];
+  }
+  if (latestRunRecord === null) {
+    return [
+      createIssue(
+        "latest run coherence",
+        "current state references a latest run that could not be read"
+      )
+    ];
+  }
+  const issues = [];
+  if (latestRunRecord.stage !== current.currentStage) {
+    issues.push(
+      createIssue(
+        "latest run coherence",
+        `current stage ${current.currentStage} does not match latest run stage ${latestRunRecord.stage}`
+      )
+    );
+  }
+  if (current.latestApprovedPlan !== latestRunRecord.paths.planPath) {
+    issues.push(
+      createIssue(
+        "latest run coherence",
+        "current approved plan does not match the latest run plan path"
+      )
+    );
+  }
+  const allowedSummaryPaths = [
+    latestRunRecord.paths.executionSummaryPath,
+    latestRunRecord.paths.verificationSummaryPath
+  ].filter((value) => value !== null);
+  if (current.latestRelevantSummary !== null && !allowedSummaryPaths.includes(current.latestRelevantSummary)) {
+    issues.push(
+      createIssue(
+        "latest run coherence",
+        "current latest summary does not match the latest run summary paths"
+      )
+    );
+  }
+  if (current.currentGuide !== latestRunRecord.paths.guidePath) {
+    issues.push(
+      createIssue(
+        "latest run coherence",
+        "current guide does not match the latest run guide path"
+      )
+    );
+  }
+  if (current.currentHandoff !== latestRunRecord.paths.handoffPath) {
+    issues.push(
+      createIssue(
+        "latest run coherence",
+        "current handoff does not match the latest run handoff path"
+      )
+    );
+  }
+  if (current.currentReview !== latestRunRecord.paths.reviewPath) {
+    issues.push(
+      createIssue(
+        "latest run coherence",
+        "current review does not match the latest run review path"
+      )
+    );
+  }
+  return issues;
+}
+function validateVerifyStage(current) {
+  const issues = [];
+  if (current.currentStage !== "verify") {
+    if (current.activeAgents.verification !== null) {
+      issues.push(
+        createIssue(
+          "verification-agent coherence",
+          "verification agent is still assigned outside the verify stage"
+        )
+      );
+    }
+    return issues;
+  }
+  if (current.activeAgents.verification === null) {
+    issues.push(
+      createIssue(
+        "verification-agent coherence",
+        "verify stage requires a pending or assigned verification agent"
+      )
+    );
+  }
+  const missingArtifacts = [];
+  if (current.currentGuide === null) {
+    missingArtifacts.push("current guide");
+  }
+  if (current.currentHandoff === null) {
+    missingArtifacts.push("current handoff");
+  }
+  if (current.currentReview === null) {
+    missingArtifacts.push("current review");
+  }
+  if (current.latestRelevantSummary === null) {
+    missingArtifacts.push("latest relevant summary");
+  }
+  if (current.latestApprovedPlan === null) {
+    missingArtifacts.push("latest approved plan");
+  }
+  if (missingArtifacts.length > 0) {
+    issues.push(
+      createIssue(
+        "verify-stage readiness",
+        `verify stage is missing required references: ${missingArtifacts.join(", ")}`
+      )
+    );
+  }
+  return issues;
+}
+function validateAssignmentGuides(root, current) {
+  const issues = [];
+  const activeSubagents = new Set(current.activeAgents.subagents);
+  const guideEntries = Object.entries(current.assignmentGuides);
+  for (const agentName of activeSubagents) {
+    if (current.assignmentGuides[agentName] === void 0) {
+      issues.push(
+        createIssue(
+          "assignment-guide coherence",
+          `active subagent ${agentName} is missing an assignment guide`
+        )
+      );
+    }
+  }
+  for (const [agentName, guidePath] of guideEntries) {
+    if (!activeSubagents.has(agentName)) {
+      issues.push(
+        createIssue(
+          "assignment-guide coherence",
+          `assignment guide for ${agentName} is still registered without an active subagent`
+        )
+      );
+      continue;
+    }
+    if (!existsSync4(path11.join(root, guidePath))) {
+      issues.push(
+        createIssue(
+          "assignment-guide coherence",
+          `assignment guide for ${agentName} is missing: ${guidePath}`
+        )
+      );
+    }
+  }
+  return issues;
+}
+function collectStateCoherenceIssues(root, current, latestRunRecord) {
+  if (current === null) {
+    return [];
+  }
+  return [
+    ...validateLatestRunCoherence(current, latestRunRecord),
+    ...validateVerifyStage(current),
+    ...validateAssignmentGuides(root, current)
+  ];
+}
+
+// src/lib/doctor.ts
+var PLAN_PLACEHOLDERS = [
+  "Replace with the concrete objective for this work cycle.",
+  "Replace with the acceptance criteria that define completion.",
+  "Replace with in-scope and out-of-scope notes.",
+  "fill-in-file-scope",
+  "describe the concrete implementation task",
+  "describe how this task will be checked"
+];
+var GUIDE_PLACEHOLDERS = [
+  "Replace with the concrete goal for this cycle.",
+  "Replace with the files or modules that should be touched.",
+  "Replace with the checks and verdict expectations for this cycle."
+];
+var EXECUTION_SUMMARY_PLACEHOLDERS = [
+  "Replace with the actual implementation scope.",
+  "not started yet",
+  "none yet",
+  "Update this section as implementation progresses.",
+  "Update this section after refactor.",
+  "Add deferred issues if they exist."
+];
+var HANDOFF_PLACEHOLDERS = [
+  "Replace with the current implementation status.",
+  "Replace with the checks relevant to this work cycle.",
+  "Replace with the current blocker or risk list."
+];
+var CONSISTENCY_REVIEW_PLACEHOLDERS = [
+  "Add findings here in severity order.",
+  "Add follow-up recommendations here.",
+  `Record whether ${STATE_ROOT_NAME}/guides/code-consistency.md needs an update.`
+];
+function findPlaceholderMatches(text, placeholders) {
+  return placeholders.filter((placeholder) => text.includes(placeholder));
+}
+function validatePlaceholderArtifact(root, check) {
+  if (check.relativePath === null) {
+    return null;
+  }
+  const text = readTextIfPresent(path12.join(root, check.relativePath));
+  if (text === null) {
+    return {
+      level: "fail",
+      label: check.label,
+      detail: `missing artifact: ${check.relativePath}`
+    };
+  }
+  const matches = findPlaceholderMatches(text, check.placeholders);
+  if (matches.length === 0) {
+    return {
+      level: "ok",
+      label: check.label,
+      detail: "no scaffold placeholders detected"
+    };
+  }
+  return {
+    level: "fail",
+    label: check.label,
+    detail: `contains placeholder content: ${matches.join("; ")}`
+  };
+}
+function pushExistenceChecks(root, items, labelPrefix, results) {
+  for (const item of items) {
+    results.push(
+      existsSync5(path12.join(root, item)) ? {
+        level: "ok",
+        label: `${labelPrefix}: ${item}`,
+        detail: "present"
+      } : {
+        level: "fail",
+        label: `${labelPrefix}: ${item}`,
+        detail: "missing"
+      }
+    );
+  }
+}
+function validateAgents(root) {
+  const file = path12.join(root, "AGENTS.md");
+  const text = readTextIfPresent(file);
+  if (text === null) {
+    return [
+      {
+        level: "fail",
+        label: "AGENTS.md",
+        detail: "missing"
+      }
+    ];
+  }
+  const snippets = [
+    "fresh agent",
+    "Korean",
+    "code-consistency.md",
+    "work journal",
+    "refactor"
+  ];
+  const missing = snippets.filter((snippet) => !text.includes(snippet));
+  if (missing.length === 0) {
+    return [
+      {
+        level: "ok",
+        label: "AGENTS.md",
+        detail: "contains required operational guidance"
+      }
+    ];
+  }
+  return [
+    {
+      level: "warn",
+      label: "AGENTS.md",
+      detail: `missing guidance snippets: ${missing.join(", ")}`
+    }
+  ];
+}
+function validateIndex(root) {
+  const file = path12.join(root, ".sb-codex-tool/index/current.json");
+  const current = readJsonIfPresent(file);
+  if (current === null) {
+    return {
+      level: "fail",
+      label: "index/current.json",
+      detail: "missing or unreadable"
+    };
+  }
+  const requiredKeys = [
+    "currentStage",
+    "nextAction",
+    "hotPath",
+    "activeAgents"
+  ];
+  const missing = requiredKeys.filter((key) => !(key in current));
+  if (missing.length > 0) {
+    return {
+      level: "warn",
+      label: "index/current.json",
+      detail: `missing keys: ${missing.join(", ")}`
+    };
+  }
+  return {
+    level: "ok",
+    label: "index/current.json",
+    detail: "structured current state is present"
+  };
+}
+function validateConsistencyGuide(root) {
+  const file = path12.join(root, ".sb-codex-tool/guides/code-consistency.md");
+  const text = readTextIfPresent(file);
+  if (text === null) {
+    return {
+      level: "fail",
+      label: "code-consistency.md",
+      detail: "missing"
+    };
+  }
+  const requiredSections = [
+    "Naming Rules",
+    "Module Boundary Rules",
+    "Reuse Rules",
+    "Readability Rules",
+    "Anti-Patterns"
+  ];
+  const missing = requiredSections.filter((section) => !text.includes(section));
+  if (missing.length === 0) {
+    return {
+      level: "ok",
+      label: "code-consistency.md",
+      detail: "contains the expected guidance sections"
+    };
+  }
+  return {
+    level: "warn",
+    label: "code-consistency.md",
+    detail: `missing sections: ${missing.join(", ")}`
+  };
+}
+function validateIgnoreStrategy(root) {
+  const files = [".ignore", ".rgignore"];
+  const requiredPattern = ".sb-codex-tool/logs/work-journal/";
+  const missing = files.filter((file) => {
+    const text = readTextIfPresent(path12.join(root, file));
+    return text === null || !text.includes(requiredPattern);
+  });
+  if (missing.length === 0) {
+    return {
+      level: "ok",
+      label: "ignore strategy",
+      detail: "default search hot path excludes work-journal noise"
+    };
+  }
+  return {
+    level: "warn",
+    label: "ignore strategy",
+    detail: `missing work-journal exclusion in: ${missing.join(", ")}`
+  };
+}
+function validateCurrentReferences(root) {
+  const current = readCurrentIndex(root);
+  if (current === null) {
+    return [];
+  }
+  const referencedPaths = [
+    current.latestApprovedPlan,
+    current.latestRelevantSummary,
+    current.latestRun,
+    current.latestConsistencyReview,
+    current.currentGuide,
+    current.currentHandoff,
+    current.currentReview,
+    ...current.hotPath
+  ].filter((value) => value !== null);
+  const uniquePaths = referencedPaths.filter(
+    (value, index, array) => array.indexOf(value) === index
+  );
+  return uniquePaths.map(
+    (relativePath) => existsSync5(path12.join(root, relativePath)) ? {
+      level: "ok",
+      label: `current reference: ${relativePath}`,
+      detail: "present"
+    } : {
+      level: "fail",
+      label: `current reference: ${relativePath}`,
+      detail: "missing"
+    }
+  );
+}
+function validateReadThisFirst(root) {
+  const current = readCurrentIndex(root);
+  const text = readTextIfPresent(path12.join(root, ".sb-codex-tool/guides/read-this-first.md"));
+  if (current === null || text === null) {
+    return {
+      level: "fail",
+      label: "read-this-first hot path",
+      detail: "missing current index or read-this-first guide"
+    };
+  }
+  const hotPathSection = text.match(
+    /## Hot Path\s+Read in this order before implementation or verification:\s+([\s\S]*?)\n## Additional Repo Docs/
+  );
+  if (hotPathSection === null) {
+    return {
+      level: "fail",
+      label: "read-this-first hot path",
+      detail: "missing hot-path section structure"
+    };
+  }
+  const actualHotPath = hotPathSection[1].trim().split("\n").map((line) => line.trim()).filter((line) => /^\d+\.\s+/.test(line)).map((line) => line.replace(/^\d+\.\s+/, ""));
+  const missing = current.hotPath.filter((relativePath) => !text.includes(relativePath));
+  if (missing.length === 0) {
+    const orderMatches = actualHotPath.length === current.hotPath.length && actualHotPath.every((value, index) => value === current.hotPath[index]);
+    if (!orderMatches) {
+      return {
+        level: "fail",
+        label: "read-this-first hot path",
+        detail: "hot-path order does not match current state"
+      };
+    }
+    const mismatches = [];
+    const cycleChecks = [
+      [`Current stage: ${current.currentStage}`, "current stage"],
+      [
+        `Latest approved plan: ${current.latestApprovedPlan ?? "none yet"}`,
+        "latest approved plan"
+      ],
+      [
+        `Latest relevant summary: ${current.latestRelevantSummary ?? "none yet"}`,
+        "latest relevant summary"
+      ],
+      [
+        `Latest lifecycle run: ${current.latestRun ?? "none yet"}`,
+        "latest lifecycle run"
+      ],
+      [
+        `Current task guide: ${current.currentGuide ?? "none yet"}`,
+        "current task guide"
+      ],
+      [
+        `Current handoff: ${current.currentHandoff ?? "none yet"}`,
+        "current handoff"
+      ],
+      [
+        `Current review: ${current.currentReview ?? "none yet"}`,
+        "current review"
+      ]
+    ];
+    for (const [expected, label] of cycleChecks) {
+      if (!text.includes(expected)) {
+        mismatches.push(label);
+      }
+    }
+    if (mismatches.length === 0) {
+      return {
+        level: "ok",
+        label: "read-this-first hot path",
+        detail: "matches the current hot-path references and cycle metadata"
+      };
+    }
+    return {
+      level: "fail",
+      label: "read-this-first hot path",
+      detail: `stale current-cycle metadata: ${mismatches.join(", ")}`
+    };
+  }
+  return {
+    level: "fail",
+    label: "read-this-first hot path",
+    detail: `missing current hot-path references: ${missing.join(", ")}`
+  };
+}
+function validateCurrentArtifactSemantics(root) {
+  const current = readCurrentIndex(root);
+  if (current === null) {
+    return [];
+  }
+  const checks = [
+    {
+      label: "approved plan readiness",
+      relativePath: current.latestApprovedPlan,
+      placeholders: PLAN_PLACEHOLDERS
+    },
+    {
+      label: "current task guide readiness",
+      relativePath: current.currentGuide,
+      placeholders: GUIDE_PLACEHOLDERS
+    },
+    {
+      label: "current handoff readiness",
+      relativePath: current.currentHandoff,
+      placeholders: HANDOFF_PLACEHOLDERS
+    },
+    {
+      label: "latest consistency review readiness",
+      relativePath: current.latestConsistencyReview,
+      placeholders: CONSISTENCY_REVIEW_PLACEHOLDERS
+    }
+  ];
+  if (current.latestRelevantSummary !== null && current.latestRelevantSummary.endsWith("-execution-summary.md")) {
+    checks.push({
+      label: "execution summary readiness",
+      relativePath: current.latestRelevantSummary,
+      placeholders: EXECUTION_SUMMARY_PLACEHOLDERS
+    });
+  }
+  return checks.map((check) => validatePlaceholderArtifact(root, check)).filter((result) => result !== null);
+}
+function runDoctor(start = process.cwd()) {
+  const root = resolveProjectRoot(start);
+  const results = [];
+  const current = readCurrentIndex(root);
+  const latestRunRecord = readLifecycleRunRecord(root, current?.latestRun ?? null);
+  pushExistenceChecks(root, REQUIRED_DIRECTORIES, "directory", results);
+  pushExistenceChecks(root, REQUIRED_FILES, "file", results);
+  pushExistenceChecks(root, REQUIRED_WORKFLOW_FILES, "workflow", results);
+  results.push(...validateAgents(root));
+  results.push(validateIndex(root));
+  results.push(validateConsistencyGuide(root));
+  results.push(validateIgnoreStrategy(root));
+  results.push(...validateCurrentReferences(root));
+  results.push(validateReadThisFirst(root));
+  results.push(...validateCurrentArtifactSemantics(root));
+  results.push(...collectStateCoherenceIssues(root, current, latestRunRecord));
+  return { root, results };
+}
+
+// src/commands/doctor.ts
+function formatResult(level) {
+  if (level === "ok") {
+    return "[ok]";
+  }
+  if (level === "warn") {
+    return "[warn]";
+  }
+  return "[fail]";
+}
+function runDoctorCommand() {
+  const report = runDoctor();
+  let hasFailure = false;
+  console.log(`Project root: ${report.root}`);
+  console.log("");
+  for (const result of report.results) {
+    console.log(`${formatResult(result.level)} ${result.label}: ${result.detail}`);
+    if (result.level === "fail") {
+      hasFailure = true;
+    }
+  }
+  return hasFailure ? 1 : 0;
+}
+
+// src/lib/launch.ts
+import { spawnSync as spawnSync2 } from "node:child_process";
+import { existsSync as existsSync7, writeFileSync as writeFileSync2 } from "node:fs";
+import path14 from "node:path";
+
+// src/lib/codex.ts
+import { existsSync as existsSync6 } from "node:fs";
+import path13 from "node:path";
+function findExecutableInPath(binaryName, searchPath) {
+  for (const entry of searchPath.split(path13.delimiter)) {
+    if (entry.trim().length === 0) {
+      continue;
+    }
+    const candidate = path13.join(entry, binaryName);
+    if (existsSync6(candidate)) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveCodexBinary(root = process.cwd(), searchPath = process.env.PATH ?? "") {
+  const localBinary = path13.join(root, "node_modules", ".bin", "codex");
+  if (existsSync6(localBinary)) {
+    return localBinary;
+  }
+  return findExecutableInPath("codex", searchPath);
+}
+
+// src/lib/launch.ts
+function getInstructionSurface(hotPath) {
+  return ["AGENTS.md", ...hotPath].filter(
+    (value, index, array) => array.indexOf(value) === index
+  );
+}
+function writeInstructionSurfaceFile(root, instructionSurface) {
+  const relativePath = ".sb-codex-tool/index/current-launch-instructions.txt";
+  const absolutePath = path14.join(root, relativePath);
+  ensureDir(path14.dirname(absolutePath));
+  writeFileSync2(absolutePath, instructionSurface.join("\n") + "\n", "utf8");
+  return relativePath;
+}
+function writeLaunchMetadata(root, relativePath, metadata) {
+  const absolutePath = path14.join(root, relativePath);
+  ensureDir(path14.dirname(absolutePath));
+  writeFileSync2(absolutePath, JSON.stringify(metadata, null, 2) + "\n", "utf8");
+}
+function recordLaunchStart(root, args, current, codexBinary, instructionSurface, instructionSurfaceFile, missingHotPath) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:]/g, "-");
+  const relativePath = `.sb-codex-tool/runs/launch-${timestamp}.json`;
+  const metadata = {
+    version: 2,
+    launchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: null,
+    cwd: root,
+    args,
+    codexBinary,
+    instructionSurface,
+    instructionSurfaceFile,
+    currentStage: current?.currentStage ?? "unknown",
+    latestPlan: current?.latestApprovedPlan ?? null,
+    latestSummary: current?.latestRelevantSummary ?? null,
+    latestRun: current?.latestRun ?? null,
+    preflight: {
+      missingHotPath,
+      scaffoldPresent: true
+    },
+    exitStatus: null,
+    failedReason: null
+  };
+  writeLaunchMetadata(root, relativePath, metadata);
+  return { relativePath, metadata };
+}
+function finalizeLaunchMetadata(root, relativePath, metadata, exitStatus, failedReason) {
+  writeLaunchMetadata(root, relativePath, {
+    ...metadata,
+    completedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    exitStatus,
+    failedReason
+  });
+}
+function launchCodex(start, args, env = process.env, spawnImpl = spawnSync2) {
+  const root = resolveProjectRoot(start);
+  const stateRoot = statePath(root);
+  if (!existsSync7(stateRoot)) {
+    throw new Error("Missing .sb-codex-tool scaffold. Run `sb-codex-tool setup` first.");
+  }
+  const current = readJsonIfPresent(statePath(root, "index", "current.json"));
+  const instructionSurface = getInstructionSurface(current?.hotPath ?? []);
+  const missingHotPath = instructionSurface.filter((file) => !existsSync7(path14.join(root, file)));
+  const instructionSurfaceFile = writeInstructionSurfaceFile(root, instructionSurface);
+  const codexBinary = resolveCodexBinary(root, env.PATH ?? "");
+  const launch = recordLaunchStart(
+    root,
+    args,
+    current,
+    codexBinary,
+    instructionSurface,
+    instructionSurfaceFile,
+    missingHotPath
+  );
+  if (missingHotPath.length > 0) {
+    finalizeLaunchMetadata(
+      root,
+      launch.relativePath,
+      launch.metadata,
+      1,
+      `missing hot-path files: ${missingHotPath.join(", ")}`
+    );
+    throw new Error(
+      `Launch preflight failed because hot-path files are missing: ${missingHotPath.join(", ")}.`
+    );
+  }
+  if (codexBinary === null) {
+    finalizeLaunchMetadata(
+      root,
+      launch.relativePath,
+      launch.metadata,
+      1,
+      "Codex binary not found in PATH or node_modules/.bin."
+    );
+    throw new Error("Codex binary not found in PATH. Install or expose `codex` first.");
+  }
+  const result = spawnImpl(codexBinary, args, {
+    cwd: root,
+    env: {
+      ...env,
+      SB_CODEX_TOOL_PROJECT_INSTRUCTIONS: instructionSurface.join("\n"),
+      SB_CODEX_TOOL_PROJECT_INSTRUCTIONS_FILE: instructionSurfaceFile,
+      SB_CODEX_TOOL_CURRENT_STAGE: current?.currentStage ?? "unknown",
+      SB_CODEX_TOOL_LATEST_PLAN: current?.latestApprovedPlan ?? "",
+      SB_CODEX_TOOL_LATEST_SUMMARY: current?.latestRelevantSummary ?? "",
+      SB_CODEX_TOOL_LATEST_RUN: current?.latestRun ?? ""
+    },
+    stdio: "inherit"
+  });
+  finalizeLaunchMetadata(
+    root,
+    launch.relativePath,
+    launch.metadata,
+    result.status ?? 1,
+    result.error?.message ?? null
+  );
+  return {
+    root,
+    launchFile: launch.relativePath,
+    instructionSurface,
+    instructionSurfaceFile,
+    exitStatus: result.status ?? 1
+  };
+}
+
+// src/commands/launch.ts
+function runLaunch(args) {
+  try {
+    const result = launchCodex(process.cwd(), args);
+    console.log(`Launch metadata: ${result.launchFile}`);
+    console.log(`Instruction surface file: ${result.instructionSurfaceFile}`);
+    console.log("Instruction surface for this session:");
+    for (const file of result.instructionSurface) {
+      console.log(`- ${file}`);
+    }
+    return result.exitStatus;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    return 1;
+  }
+}
+
+// src/lib/prepare-verify.ts
+import path15 from "node:path";
+function readSummaryContext2(root, summaryPath) {
+  const text = readTextIfPresent(path15.join(root, summaryPath));
+  if (text === null) {
+    throw new Error(`prepare-verify requires the execution summary ${summaryPath}.`);
+  }
+  return {
+    scope: extractSectionLines(text, "Scope"),
+    implementedSurface: extractSectionLines(text, "Implemented Surface"),
+    deferredIssues: extractSectionLines(text, "Deferred Issues"),
+    nextAgentGuidance: extractSectionLines(text, "Next-Agent Guidance")
+  };
+}
+function readVerificationExpectations(root, guidePath) {
+  const text = readTextIfPresent(path15.join(root, guidePath));
+  if (text === null) {
+    throw new Error(`prepare-verify requires the current guide ${guidePath}.`);
+  }
+  return extractSectionLines(text, "Verification Expectations");
+}
+function ensureExplicitLines(lines, label) {
+  const values = stripBulletPrefix(lines).map((line) => line.trim()).filter(
+    (line) => line.length > 0 && line !== "none" && line !== "none." && line !== "not started yet" && line !== "none yet"
+  );
+  if (values.length === 0) {
+    throw new Error(`prepare-verify requires explicit ${label} before verify can start.`);
+  }
+  return values;
+}
+function renderBulletList3(items) {
+  return items.map((item) => `- ${item}`).join("\n");
+}
+function buildHandoff(title, summaryContext, verificationExpectations, summaryPath, planPath, guidePath, runPath, gitContextSection) {
+  const implementedSurface = ensureExplicitLines(
+    summaryContext.implementedSurface,
+    "implemented surface details"
+  );
+  const nextAgentGuidance = ensureExplicitLines(
+    summaryContext.nextAgentGuidance,
+    "next-agent guidance"
+  );
+  const checks = ensureExplicitLines(
+    verificationExpectations,
+    "verification expectations"
+  );
+  const scope = stripBulletPrefix(summaryContext.scope).filter((line) => line.trim().length > 0);
+  const risks = stripBulletPrefix(summaryContext.deferredIssues).filter((line) => line.trim().length > 0 && line.trim().toLowerCase() !== "none.");
+  return `# Handoff: ${title}
+
+## Goal
+
+- Enable the next fresh agent to continue this work cycle without hidden context.
+
+## Read In This Order
+
+1. AGENTS.md
+2. ${STATE_ROOT_NAME}/project.md
+3. ${STATE_ROOT_NAME}/state.md
+4. ${STATE_ROOT_NAME}/guides/read-this-first.md
+5. ${STATE_ROOT_NAME}/guides/code-consistency.md
+6. ${summaryPath}
+7. ${planPath}
+8. ${guidePath}
+
+## Current Status
+
+${renderBulletList3([
+    ...scope,
+    ...implementedSurface,
+    "Implementation and refactor are ready for fresh verification."
+  ])}
+
+${gitContextSection}
+## Expected Verification Checks
+
+${renderBulletList3(checks)}
+
+## Open Risks
+
+${renderBulletList3(risks.length > 0 ? risks : ["None."])}
+
+## Next-Agent Guidance
+
+${renderBulletList3(nextAgentGuidance)}
+`;
+}
+function prepareVerify(start) {
+  const root = resolveProjectRoot(start);
+  const current = normalizeCurrentIndex(readCurrentIndex(root));
+  if (current.latestApprovedPlan === null) {
+    throw new Error("prepare-verify requires a current approved plan.");
+  }
+  if (current.latestRelevantSummary === null) {
+    throw new Error("prepare-verify requires a current execution summary.");
+  }
+  if (current.currentGuide === null) {
+    throw new Error("prepare-verify requires a current task guide.");
+  }
+  if (current.currentHandoff === null) {
+    throw new Error("prepare-verify requires a current handoff artifact.");
+  }
+  if (current.currentReview === null) {
+    throw new Error("prepare-verify requires a current review artifact.");
+  }
+  const { dateStamp, slug } = parseCycleDescriptor(current.latestApprovedPlan);
+  const title = readCycleTitle(root, current.latestApprovedPlan, slug);
+  const summaryContext = readSummaryContext2(root, current.latestRelevantSummary);
+  const verificationExpectations = readVerificationExpectations(root, current.currentGuide);
+  const git = getGitContext(root);
+  const runWrite = writeLifecycleRunRecord(root, {
+    dateStamp,
+    slug,
+    title,
+    phase: "prepare-verify",
+    stage: "verify",
+    verdict: "pending",
+    git,
+    paths: {
+      planPath: current.latestApprovedPlan,
+      executionSummaryPath: current.latestRelevantSummary,
+      handoffPath: current.currentHandoff,
+      reviewPath: current.currentReview,
+      guidePath: current.currentGuide,
+      verificationSummaryPath: null,
+      journalPath: null
+    }
+  });
+  const handoffWrite = writeFileIfChanged(
+    path15.join(root, current.currentHandoff),
+    buildHandoff(
+      title,
+      summaryContext,
+      verificationExpectations,
+      current.latestRelevantSummary,
+      current.latestApprovedPlan,
+      current.currentGuide,
+      runWrite.path,
+      renderGitContextSection(runWrite.path, git)
+    )
+  );
+  const nextCurrent = normalizeCurrentIndex({
+    ...current,
+    currentStage: "verify",
+    nextAction: `Run fresh verification for the ${title} increment.`,
+    latestRun: runWrite.path,
+    currentFocusModules: [
+      "AGENTS.md",
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      current.latestRelevantSummary,
+      current.latestApprovedPlan,
+      current.currentGuide,
+      current.currentHandoff,
+      current.currentReview,
+      runWrite.path
+    ],
+    hotPath: [
+      `${STATE_ROOT_NAME}/project.md`,
+      `${STATE_ROOT_NAME}/state.md`,
+      `${STATE_ROOT_NAME}/guides/read-this-first.md`,
+      `${STATE_ROOT_NAME}/guides/code-consistency.md`,
+      current.latestRelevantSummary,
+      current.latestApprovedPlan,
+      current.currentGuide
+    ],
+    activeAgents: {
+      ...current.activeAgents,
+      verification: "pending assignment"
+    },
+    notes: [
+      `Current work cycle: ${title}.`,
+      "Execution and refactor are complete.",
+      "Handoff and current-state artifacts are aligned for fresh verification.",
+      `Previous relevant summary: ${current.latestRelevantSummary}`
+    ]
+  });
+  const updatedFiles = [];
+  if (runWrite.writeResult === "created" || runWrite.writeResult === "updated") {
+    updatedFiles.push(runWrite.path);
+  }
+  if (handoffWrite === "created" || handoffWrite === "updated") {
+    updatedFiles.push(current.currentHandoff);
+  }
+  const currentWrites = writeCurrentArtifacts(
+    root,
+    nextCurrent,
+    buildTemplateContext(root).implementationMenuPath
+  );
+  if (currentWrites.index !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/index/current.json`);
+  }
+  if (currentWrites.state !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/state.md`);
+  }
+  if (currentWrites.readThisFirst !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/guides/read-this-first.md`);
+  }
+  return {
+    root,
+    title,
+    runPath: runWrite.path,
+    handoffPath: current.currentHandoff,
+    updatedFiles
+  };
+}
+
+// src/commands/prepare-verify.ts
+function runPrepareVerify(args) {
+  if (args.length > 0) {
+    console.error("Usage: sb-codex-tool prepare-verify");
+    return 1;
+  }
+  const result = prepareVerify(process.cwd());
+  console.log(`Project root: ${result.root}`);
+  console.log(`Work cycle: ${result.title}`);
+  console.log(`Updated run: ${result.runPath}`);
+  console.log(`Updated handoff: ${result.handoffPath}`);
+  console.log("");
+  console.log(`Updated files: ${result.updatedFiles.length}`);
+  for (const file of result.updatedFiles) {
+    console.log(`- ${file}`);
+  }
+  return 0;
+}
+
+// src/lib/consistency-review.ts
+import path16 from "node:path";
+function readAllowedFileScope3(root, guidePath) {
+  if (guidePath === null) {
+    return [];
+  }
+  const text = readTextIfPresent(path16.join(root, guidePath));
+  if (text === null) {
+    return [];
+  }
+  return extractSectionLines(text, "Allowed File Scope");
+}
+function buildConsistencyReview(agentName, title, current, allowedFileScope) {
+  const fileScope = allowedFileScope.length > 0 ? allowedFileScope.join("\n") : "- Replace with the bounded file scope for this review.";
+  return `# Code Consistency Review: ${title}
+
+## Assigned Consistency Agent
+
+- ${agentName}
+
+## Review Target
+
+- Current plan: ${current.latestApprovedPlan ?? "none yet"}
+- Latest summary: ${current.latestRelevantSummary ?? "none yet"}
+- Current guide: ${current.currentGuide ?? "none yet"}
+- Latest lifecycle run: ${current.latestRun ?? "none yet"}
+
+## Review Scope
+
+${fileScope}
+
+## Required References
+
+- AGENTS.md
+- ${STATE_ROOT_NAME}/guides/code-consistency.md
+- ${current.latestApprovedPlan ?? `${STATE_ROOT_NAME}/plans/README.md`}
+- ${current.latestRelevantSummary ?? `${STATE_ROOT_NAME}/summaries/README.md`}
+- ${current.currentGuide ?? `${STATE_ROOT_NAME}/guides/read-this-first.md`}
+
+## Review Questions
+
+- Do naming and module boundaries still match the consistency guide?
+- Did the latest increment preserve reuse, readability, and low complexity?
+- Are there new anti-patterns or consistency drifts that should be recorded?
+- Is the code still easy for a fresh agent to read and modify?
+
+## Findings
+
+- Add findings here in severity order.
+
+## Recommendations
+
+- Add follow-up recommendations here.
+
+## Guide Update Decision
+
+- Record whether ${STATE_ROOT_NAME}/guides/code-consistency.md needs an update.
+`;
+}
+function createConsistencyReview(start, agentName, requestedTitle) {
+  const root = resolveProjectRoot(start);
+  const current = normalizeCurrentIndex(readCurrentIndex(root));
+  if (current.latestApprovedPlan === null) {
+    throw new Error("review-consistency requires a current approved plan.");
+  }
+  if (current.latestRelevantSummary === null) {
+    throw new Error("review-consistency requires a current summary.");
+  }
+  if (current.currentGuide === null) {
+    throw new Error("review-consistency requires a current task guide.");
+  }
+  const agentSlug = normalizeSlug(agentName);
+  if (agentSlug.length === 0) {
+    throw new Error("Agent name must contain at least one alphanumeric character.");
+  }
+  const { dateStamp, slug } = parseCycleDescriptor(current.latestApprovedPlan);
+  const cycleTitle = readCycleTitle(root, current.latestApprovedPlan, slug);
+  const title = requestedTitle?.trim().length ? requestedTitle.trim() : `${cycleTitle} Consistency Review`;
+  const reviewPath = `${STATE_ROOT_NAME}/reviews/${dateStamp}-${slug}-${agentSlug}-consistency-review.md`;
+  const allowedFileScope = readAllowedFileScope3(root, current.currentGuide);
+  const writeResult = writeFileIfMissing(
+    path16.join(root, reviewPath),
+    buildConsistencyReview(agentName, title, current, allowedFileScope)
+  );
+  const createdFiles = [];
+  const keptFiles = [];
+  if (writeResult === "created") {
+    createdFiles.push(reviewPath);
+  } else {
+    keptFiles.push(reviewPath);
+  }
+  const nextFocusModules = current.currentFocusModules.includes(reviewPath) ? current.currentFocusModules : [...current.currentFocusModules, reviewPath];
+  const nextCurrent = normalizeCurrentIndex({
+    ...current,
+    latestConsistencyReview: reviewPath,
+    currentFocusModules: nextFocusModules,
+    activeAgents: {
+      ...current.activeAgents,
+      consistency: agentName
+    },
+    notes: [
+      `Current work cycle: ${humanizeSlug(slug)}.`,
+      `Prepared consistency review for ${agentName}: ${reviewPath}.`,
+      `Previous relevant summary: ${current.latestRelevantSummary}`
+    ]
+  });
+  const updatedFiles = [];
+  const currentWrites = writeCurrentArtifacts(
+    root,
+    nextCurrent,
+    buildTemplateContext(root).implementationMenuPath
+  );
+  if (currentWrites.index !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/index/current.json`);
+  }
+  if (currentWrites.state !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/state.md`);
+  }
+  if (currentWrites.readThisFirst !== "unchanged") {
+    updatedFiles.push(`${STATE_ROOT_NAME}/guides/read-this-first.md`);
+  }
+  return {
+    root,
+    agentName,
+    title,
+    reviewPath,
+    createdFiles,
+    keptFiles,
+    updatedFiles
+  };
+}
+
+// src/commands/review-consistency.ts
+function runReviewConsistency(args) {
+  const [agentName, ...titleParts] = args;
+  if (agentName === void 0) {
+    console.error("Usage: sb-codex-tool review-consistency <agent-name> [title words]");
+    return 1;
+  }
+  const title = titleParts.length > 0 ? titleParts.join(" ") : void 0;
+  const result = createConsistencyReview(process.cwd(), agentName, title);
+  console.log(`Project root: ${result.root}`);
+  console.log(`Consistency agent: ${result.agentName}`);
+  console.log(`Review: ${result.title}`);
+  console.log("");
+  console.log("Artifacts:");
+  console.log(`- consistency review: ${result.reviewPath}`);
+  console.log("");
+  console.log(`Created files: ${result.createdFiles.length}`);
+  for (const file of result.createdFiles) {
+    console.log(`- ${file}`);
+  }
+  if (result.updatedFiles.length > 0) {
+    console.log("");
+    console.log("Updated state:");
+    for (const file of result.updatedFiles) {
+      console.log(`- ${file}`);
+    }
+  }
+  return 0;
+}
+
+// src/lib/scaffold.ts
+import { existsSync as existsSync8 } from "node:fs";
+import path17 from "node:path";
+function ensureDirectories(root) {
+  const created = [];
+  for (const relativeDir of REQUIRED_DIRECTORIES) {
+    const absoluteDir = path17.join(root, relativeDir);
+    const existed = existsSync8(absoluteDir);
+    ensureDir(absoluteDir);
+    if (!existed) {
+      created.push(relativeDir);
+    }
+  }
+  return created;
+}
+function scaffoldProject(start = process.cwd()) {
+  const root = resolveProjectRoot(start);
+  const context = buildTemplateContext(root);
+  const createdDirectories = ensureDirectories(root);
+  const createdFiles = [];
+  const keptFiles = [];
+  const updatedFiles = [];
+  for (const file of buildGeneratedFiles(context)) {
+    const result = writeFileIfMissing(path17.join(root, file.path), file.content);
+    if (result === "created") {
+      createdFiles.push(file.path);
+    } else {
+      keptFiles.push(file.path);
+    }
+  }
+  const gitIgnore = ensureLines(
+    path17.join(root, ".gitignore"),
+    getGitIgnoreLines(),
+    "# Added by sb-codex-tool"
+  );
+  if (gitIgnore.created || gitIgnore.added.length > 0) {
+    updatedFiles.push(".gitignore");
+  }
+  const ignore = ensureLines(
+    path17.join(root, ".ignore"),
+    getSearchIgnoreLines(),
+    "# Added by sb-codex-tool"
+  );
+  if (ignore.created || ignore.added.length > 0) {
+    updatedFiles.push(".ignore");
+  }
+  const rgIgnore = ensureLines(
+    path17.join(root, ".rgignore"),
+    getSearchIgnoreLines(),
+    "# Added by sb-codex-tool"
+  );
+  if (rgIgnore.created || rgIgnore.added.length > 0) {
+    updatedFiles.push(".rgignore");
+  }
+  const workflowReadme = writeFileIfMissing(
+    statePath(root, "workflows", "README.md"),
+    "# Workflows\n\nThis directory stores the canonical workflow stage assets.\n"
+  );
+  if (workflowReadme === "created") {
+    createdFiles.push(`${statePath(".", "workflows", "README.md")}`);
+  }
+  return {
+    root,
+    createdFiles,
+    keptFiles,
+    createdDirectories,
+    updatedFiles
+  };
+}
+
+// src/commands/setup.ts
+function runSetup() {
+  const summary = scaffoldProject();
+  const codexBinary = resolveCodexBinary();
+  console.log(`Project root: ${summary.root}`);
+  console.log("");
+  console.log(`Created directories: ${summary.createdDirectories.length}`);
+  for (const directory of summary.createdDirectories) {
+    console.log(`- ${directory}`);
+  }
+  console.log("");
+  console.log(`Created files: ${summary.createdFiles.length}`);
+  for (const file of summary.createdFiles) {
+    console.log(`- ${file}`);
+  }
+  if (summary.updatedFiles.length > 0) {
+    console.log("");
+    console.log("Updated files:");
+    for (const file of summary.updatedFiles) {
+      console.log(`- ${file}`);
+    }
+  }
+  console.log("");
+  if (codexBinary === null) {
+    console.log("Codex binary: missing");
+    console.log("Remediation: install Codex or expose `codex` in PATH before using the launch wrapper.");
+  } else {
+    console.log(`Codex binary: ${codexBinary}`);
+  }
+  return 0;
+}
+
+// src/lib/status.ts
+function getStatus(start = process.cwd()) {
+  const root = resolveProjectRoot(start);
+  const current = readCurrentIndex(root);
+  const git = getGitContext(root);
+  const latestRun = current?.latestRun ?? null;
+  const latestRunRecord = readLifecycleRunRecord(root, latestRun);
+  const coherenceIssues = collectStateCoherenceIssues(root, current, latestRunRecord);
+  return {
+    root,
+    stage: current?.currentStage ?? "unknown",
+    nextAction: current?.nextAction ?? "No next action recorded.",
+    latestPlan: current?.latestApprovedPlan ?? null,
+    latestSummary: current?.latestRelevantSummary ?? null,
+    latestRun,
+    latestRunRecord,
+    latestConsistencyReview: current?.latestConsistencyReview ?? null,
+    latestAssignmentLifecycle: current?.latestAssignmentLifecycle ?? null,
+    currentGuide: current?.currentGuide ?? null,
+    currentReview: current?.currentReview ?? null,
+    currentHandoff: current?.currentHandoff ?? null,
+    hotPath: current?.hotPath ?? [
+      ".sb-codex-tool/project.md",
+      ".sb-codex-tool/state.md",
+      ".sb-codex-tool/guides/read-this-first.md",
+      ".sb-codex-tool/guides/code-consistency.md"
+    ],
+    agents: current?.activeAgents,
+    assignmentGuides: current?.assignmentGuides ?? {},
+    coherenceIssues,
+    git
+  };
+}
+
+// src/commands/status.ts
+function runStatus() {
+  const status = getStatus();
+  console.log(`Project root: ${status.root}`);
+  console.log(`Current stage: ${status.stage}`);
+  console.log(`Next action: ${status.nextAction}`);
+  console.log(`Latest approved plan: ${status.latestPlan ?? "none"}`);
+  console.log(`Latest summary: ${status.latestSummary ?? "none"}`);
+  console.log(`Latest run: ${status.latestRun ?? "none"}`);
+  console.log(`Latest consistency review: ${status.latestConsistencyReview ?? "none"}`);
+  console.log(`Latest assignment lifecycle: ${status.latestAssignmentLifecycle ?? "none"}`);
+  console.log(`Current guide: ${status.currentGuide ?? "none"}`);
+  console.log(`Current handoff: ${status.currentHandoff ?? "none"}`);
+  console.log(`Current review: ${status.currentReview ?? "none"}`);
+  if (status.latestRunRecord !== null) {
+    console.log("");
+    console.log("Latest run details:");
+    console.log(`- Title: ${status.latestRunRecord.title}`);
+    console.log(`- Phase: ${status.latestRunRecord.phase}`);
+    console.log(`- Stage: ${status.latestRunRecord.stage}`);
+    console.log(`- Verdict: ${status.latestRunRecord.verdict}`);
+    console.log("Run-linked artifacts:");
+    console.log(`- Plan: ${status.latestRunRecord.paths.planPath}`);
+    console.log(`- Execution summary: ${status.latestRunRecord.paths.executionSummaryPath}`);
+    console.log(`- Guide: ${status.latestRunRecord.paths.guidePath ?? "none"}`);
+    console.log(`- Handoff: ${status.latestRunRecord.paths.handoffPath ?? "none"}`);
+    console.log(`- Review: ${status.latestRunRecord.paths.reviewPath ?? "none"}`);
+    console.log(
+      `- Verification summary: ${status.latestRunRecord.paths.verificationSummaryPath ?? "none"}`
+    );
+    console.log(`- Work journal: ${status.latestRunRecord.paths.journalPath ?? "none"}`);
+    console.log("Recorded run git context:");
+    if (status.latestRunRecord.git.available) {
+      console.log(`- Branch: ${status.latestRunRecord.git.branch ?? "detached"}`);
+      console.log(`- Dirty: ${status.latestRunRecord.git.dirty ? "yes" : "no"}`);
+      console.log("- Changed files:");
+      if (status.latestRunRecord.git.changedFiles.length === 0) {
+        console.log("  - none");
+      } else {
+        for (const file of status.latestRunRecord.git.changedFiles) {
+          console.log(`  - ${file}`);
+        }
+      }
+    } else {
+      console.log("- Branch: unavailable");
+      console.log("- Dirty: unavailable");
+      console.log("- Changed files: unavailable");
+    }
+  }
+  console.log("");
+  console.log("Hot path:");
+  for (const file of status.hotPath) {
+    console.log(`- ${file}`);
+  }
+  console.log("");
+  console.log("Active agents:");
+  console.log(`- Main: ${status.agents?.main ?? "unassigned"}`);
+  console.log(
+    `- Subagents: ${status.agents?.subagents && status.agents.subagents.length > 0 ? status.agents.subagents.join(", ") : "none"}`
+  );
+  console.log(`- Verification: ${status.agents?.verification ?? "none"}`);
+  console.log(`- Consistency: ${status.agents?.consistency ?? "none"}`);
+  console.log("");
+  console.log("Assignment guides:");
+  const assignmentEntries = Object.entries(status.assignmentGuides);
+  if (assignmentEntries.length === 0) {
+    console.log("- none");
+  } else {
+    for (const [agent, guidePath] of assignmentEntries.sort(([left], [right]) => left.localeCompare(right))) {
+      console.log(`- ${agent}: ${guidePath}`);
+    }
+  }
+  console.log("");
+  console.log("Semantic issues:");
+  if (status.coherenceIssues.length === 0) {
+    console.log("- none");
+  } else {
+    for (const issue of status.coherenceIssues) {
+      console.log(`- [${issue.level}] ${issue.label}: ${issue.detail}`);
+    }
+  }
+  console.log("");
+  if (status.git.available) {
+    console.log(`Git branch: ${status.git.branch ?? "detached"}`);
+    console.log(`Git dirty: ${status.git.dirty ? "yes" : "no"}`);
+    console.log("Changed files:");
+    if (status.git.changedFiles.length === 0) {
+      console.log("- none");
+    } else {
+      for (const file of status.git.changedFiles) {
+        console.log(`- ${file}`);
+      }
+    }
+  } else {
+    console.log("Git branch: unavailable");
+    console.log("Git dirty: unavailable");
+  }
+  return 0;
+}
+
+// src/cli.ts
+function printHelp() {
+  console.log("sb-codex-tool");
+  console.log("");
+  console.log("Usage:");
+  console.log("  sb-codex-tool assign <agent-name> <slug> [title words]");
+  console.log("  sb-codex-tool begin <slug> [title words]");
+  console.log("  sb-codex-tool close");
+  console.log("  sb-codex-tool complete-assignment <agent-name> <close|clear|replace> [replacement-agent] [replacement-slug] [title words]");
+  console.log("  sb-codex-tool prepare-verify");
+  console.log("  sb-codex-tool review-consistency <agent-name> [title words]");
+  console.log("  sb-codex-tool setup");
+  console.log("  sb-codex-tool doctor");
+  console.log("  sb-codex-tool status");
+  console.log("  sb-codex-tool [codex args]");
+  console.log("");
+  console.log("Commands:");
+  console.log("  assign  Create a bounded assignment guide and update active subagents.");
+  console.log("  begin   Create the next work-cycle artifacts and update current state.");
+  console.log("  close   Finalize the current cycle from the recorded review verdict.");
+  console.log("  complete-assignment  Record close/clear/replace lifecycle handling for a bounded subagent task.");
+  console.log("  prepare-verify  Align handoff, run state, and current state for fresh verification.");
+  console.log("  review-consistency  Create a consistency review artifact and update visible review state.");
+  console.log("  setup   Create the sb-codex-tool scaffold in the current project.");
+  console.log("  doctor  Validate the scaffold and required operational files.");
+  console.log("  status  Show current stage, next action, hot path, and git context.");
+  console.log("  help    Show this message.");
+  console.log("");
+  console.log("When no command is provided, sb-codex-tool launches Codex through the wrapper.");
+}
+function main(argv) {
+  const [command, ...rest] = argv;
+  if (command === void 0) {
+    return runLaunch([]);
+  }
+  if (command === "setup") {
+    return runSetup();
+  }
+  if (command === "begin") {
+    return runBegin(rest);
+  }
+  if (command === "assign") {
+    return runAssign(rest);
+  }
+  if (command === "close") {
+    return runClose(rest);
+  }
+  if (command === "complete-assignment") {
+    return runCompleteAssignment(rest);
+  }
+  if (command === "review-consistency") {
+    return runReviewConsistency(rest);
+  }
+  if (command === "prepare-verify") {
+    return runPrepareVerify(rest);
+  }
+  if (command === "doctor") {
+    return runDoctorCommand();
+  }
+  if (command === "status") {
+    return runStatus();
+  }
+  if (command === "help" || command === "--help" || command === "-h") {
+    printHelp();
+    return 0;
+  }
+  if (command.startsWith("-")) {
+    return runLaunch(argv);
+  }
+  return runLaunch(argv);
+}
+process.exit(main(process.argv.slice(2)));