@smithers-orchestrator/cli 0.16.0

package/src/workflow-pack.js

@@ -0,0 +1,2151 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+import { generateAgentsTs } from "./agent-detection.js";
+/**
+ * @typedef {{ force?: boolean; rootDir?: string; }} InitOptions
+ */
+/**
+ * @typedef {{ rootDir: string; writtenFiles: string[]; skippedFiles: string[]; preservedPaths: string[]; }} InitResult
+ */
+/**
+ * @typedef {{ command: string; description: string; }} WorkflowCta
+ */
+
+/**
+ * @param {string} path
+ */
+function ensureDir(path) {
+    mkdirSync(path, { recursive: true });
+}
+/**
+ * @param {string} path
+ */
+function ensureParent(path) {
+    ensureDir(dirname(path));
+}
+/**
+ * @param {string} path
+ */
+function readJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+/**
+ * @param {string} path
+ * @param {string} fallback
+ */
+function readPackageVersion(path, fallback) {
+    try {
+        return String(readJson(path).version ?? fallback);
+    }
+    catch {
+        return fallback;
+    }
+}
+/**
+ * @returns {DependencyVersions}
+ */
+function readDependencyVersions() {
+    const rootPackage = readJson(new URL("../../../package.json", import.meta.url).pathname);
+    const nodeModulesRoot = new URL("../../../node_modules/", import.meta.url).pathname;
+    return {
+        smithersVersion: String(rootPackage.version ?? "0.0.0"),
+        zodVersion: readPackageVersion(resolve(nodeModulesRoot, "zod", "package.json"), "4.0.0"),
+        typescriptVersion: readPackageVersion(resolve(nodeModulesRoot, "typescript", "package.json"), "5.0.0"),
+        reactTypesVersion: readPackageVersion(resolve(nodeModulesRoot, "@types", "react", "package.json"), "19.0.0"),
+        reactDomTypesVersion: readPackageVersion(resolve(nodeModulesRoot, "@types", "react-dom", "package.json"), "19.0.0"),
+        mdxTypesVersion: readPackageVersion(resolve(nodeModulesRoot, "@types", "mdx", "package.json"), "2.0.0"),
+    };
+}
+/**
+ * @param {DependencyVersions} versions
+ */
+function renderPackageJson(versions) {
+    return JSON.stringify({
+        name: "smithers-workflows",
+        private: true,
+        type: "module",
+        scripts: {
+            typecheck: "tsc --noEmit",
+            "workflow:list": "smithers workflow list",
+            "workflow:run": "smithers workflow run",
+            "workflow:implement": "smithers workflow implement",
+        },
+        dependencies: {
+            "smithers-orchestrator": "latest",
+            zod: versions.zodVersion,
+        },
+        devDependencies: {
+            typescript: versions.typescriptVersion,
+            "@types/react": versions.reactTypesVersion,
+            "@types/react-dom": versions.reactDomTypesVersion,
+            "@types/mdx": versions.mdxTypesVersion,
+        },
+    }, null, 2) + "\n";
+}
+function renderTsconfig() {
+    return JSON.stringify({
+        compilerOptions: {
+            lib: ["ESNext", "DOM", "DOM.Iterable"],
+            target: "ESNext",
+            module: "ESNext",
+            moduleDetection: "force",
+            jsx: "react-jsx",
+            jsxImportSource: "smithers-orchestrator",
+            moduleResolution: "bundler",
+            allowImportingTsExtensions: true,
+            verbatimModuleSyntax: true,
+            noEmit: true,
+            strict: true,
+            skipLibCheck: true,
+            baseUrl: ".",
+            paths: {
+                "~/*": ["./*"],
+            },
+        },
+        include: ["./**/*"],
+        exclude: ["./executions/**/*"],
+    }, null, 2) + "\n";
+}
+/**
+ * @returns {TemplateFile[]}
+ */
+function renderPrompts() {
+    return [
+        {
+            path: ".smithers/prompts/review.mdx",
+            contents: [
+                "# Review",
+                "",
+                "Reviewer: {props.reviewer}",
+                "",
+                "Review the following request and respond with a concise JSON object.",
+                "Be a very thorough reviewer who only accepts production ready tested",
+                "code.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/plan.mdx",
+            contents: [
+                "# Plan",
+                "",
+                "Create a practical implementation plan for the following request.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/implement.mdx",
+            contents: [
+                "# Implement",
+                "",
+                "Carry out the following request in the current repository.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/validate.mdx",
+            contents: [
+                "# Validate",
+                "",
+                "Validate the current repository state for the following request.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/coverage.mdx",
+            contents: [
+                "# Improve Test Coverage",
+                "",
+                "Identify the highest-impact missing tests for this request and add them.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/ticket.mdx",
+            contents: [
+                "# Ticket",
+                "",
+                "Create a well-structured ticket for the following request.",
+                "Include a clear title, detailed description, and acceptance criteria.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/research.mdx",
+            contents: [
+                "# Research",
+                "",
+                "Research the following request thoroughly. Gather relevant context,",
+                "prior art, and technical details needed to inform the implementation. ",
+                "Clone repos (if not already cloned) of external dependencies or websearch",
+                "for docs. Include working code from docs or from test cases in the repo",
+                "in your research. Understand codebase and point to relavent files. Think hard",
+                "about what context may be useful and find it. Be very thorough and take",
+                "your time with research unless the task seems trivially easy not worhty of",
+                'research. If you tink research was a waste of time include "Waste of time!" in',
+                "your output.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/ask-user-instructions.mdx",
+            contents: [
+                "## Asking the User Questions",
+                "",
+                "When you need to ask the user a question, run this command in bash:",
+                "",
+                "```bash",
+                'bun .smithers/scripts/ask-user.ts "Your question here" --recommended "Your recommended answer"',
+                "```",
+                "",
+                "The command will block and return the user's answer on stdout.",
+                "You MUST use this tool to ask questions — do not just print questions to the output.",
+                "Ask one question at a time, wait for the answer, then proceed.",
+                "",
+                "Options:",
+                "  --recommended, -r  Your recommended answer (shown to the user)",
+                "  --branch, -b       Which decision branch this question relates to",
+                "  --timeout, -t      Seconds to wait for answer (default: 300)",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/write-a-prd.mdx",
+            contents: [
+                "# Write a PRD",
+                "",
+                "You are writing a Product Requirements Document. Follow these steps,",
+                "skipping any you consider unnecessary:",
+                "",
+                "1. Ask the user for a long, detailed description of the problem they",
+                "   want to solve and any potential ideas for solutions.",
+                "",
+                "2. Explore the repo to verify their assertions and understand the",
+                "   current state of the codebase.",
+                "",
+                "3. Interview the user relentlessly about every aspect of this plan",
+                "   until you reach a shared understanding. Walk down each branch of",
+                "   the design tree, resolving dependencies between decisions",
+                "   one-by-one. Ask questions one at a time. For each question,",
+                "   provide your recommended answer. If a question can be answered",
+                "   by exploring the codebase, explore the codebase instead.",
+                "",
+                "4. Sketch out the major modules you will need to build or modify.",
+                "   Actively look for opportunities to extract deep modules that can",
+                "   be tested in isolation. A deep module (as opposed to a shallow",
+                "   module) is one which encapsulates a lot of functionality in a",
+                "   simple, testable interface which rarely changes. Check with the",
+                "   user that these modules match their expectations and which ones",
+                "   they want tests written for.",
+                "",
+                "5. Once you have a complete understanding, write the PRD using the",
+                "   template below.",
+                "",
+                "{props.additionalInstructions}",
+                "",
+                "CONTEXT:",
+                "{props.context}",
+                "",
+                "## PRD Template",
+                "",
+                "### Problem Statement",
+                "The problem from the user's perspective.",
+                "",
+                "### Solution",
+                "The solution from the user's perspective.",
+                "",
+                "### User Stories",
+                "A LONG numbered list. Format: As an <actor>, I want a <feature>,",
+                "so that <benefit>. Be extremely extensive.",
+                "",
+                "### Implementation Decisions",
+                "Modules to build/modify, interfaces, technical clarifications,",
+                "architectural decisions, schema changes, API contracts, and",
+                "specific interactions. Do NOT include file paths or code snippets.",
+                "",
+                "### Testing Decisions",
+                "What makes a good test (external behavior, not implementation",
+                "details), which modules will be tested, and prior art for tests.",
+                "",
+                "### Out of Scope",
+                "What is explicitly not covered.",
+                "",
+                "### Further Notes",
+                "Any additional context.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/feature-enum-scan.mdx",
+            contents: [
+                "# Feature Enum Scan",
+                "",
+                "Analyze the entire repository and produce an exhaustive feature inventory.",
+                "Scan routes, services, CLI commands, UI views, SDK modules, jobs, workflows,",
+                "and any other shipped or materially stubbed product surface you can find.",
+                "",
+                "Rules:",
+                "",
+                "1. Be exhaustive. Prefer missing nothing over being overly concise.",
+                "2. Group features by domain using SCREAMING_SNAKE_CASE group names.",
+                "3. Use SCREAMING_SNAKE_CASE feature names that are specific and code-backed.",
+                "4. Split broad buckets into concrete, independently auditable features.",
+                "5. Run `git rev-parse HEAD` and include the commit hash in `lastCommitHash`.",
+                "6. Include a markdownBody that explains the grouping and notable edge cases.",
+                "",
+                "{props.additionalContext ? `ADDITIONAL CONTEXT:\\n${props.additionalContext}\\n` : \"\"}",
+                "",
+                "Example format (truncated from a larger production feature enum):",
+                "",
+                "```ts",
+                "export const FeatureGroups = {",
+                "  PLATFORM_RUNTIME: [",
+                "    \"PLATFORM_SERVER_BOOTSTRAP\",",
+                "    \"PLATFORM_DB_INITIALIZATION\",",
+                "    \"PLATFORM_SERVICE_REGISTRY_INITIALIZATION\",",
+                "    \"PLATFORM_HTTP_MIDDLEWARE_REQUEST_ID\",",
+                "    \"PLATFORM_HEALTHCHECK_ENDPOINTS\",",
+                "  ],",
+                "",
+                "  AUTH_AND_IDENTITY: [",
+                "    \"AUTH_SIGN_IN_WITH_GITHUB_OAUTH\",",
+                "    \"AUTH_SIGN_IN_WITH_PERSONAL_ACCESS_TOKEN\",",
+                "    \"AUTH_SESSION_COOKIE_ISSUANCE\",",
+                "    \"AUTH_PERSONAL_ACCESS_TOKEN_CREATE\",",
+                "    \"AUTH_CLI_BROWSER_LOGIN\",",
+                "  ],",
+                "",
+                "  USER_ACCOUNT_AND_SETTINGS: [",
+                "    \"USER_SELF_PROFILE_VIEW\",",
+                "    \"USER_PROFILE_UPDATE\",",
+                "    \"USER_SSH_KEY_ADD\",",
+                "    \"USER_NOTIFICATION_SETTINGS_UPDATE\",",
+                "    \"USER_API_TOKENS_UI\",",
+                "  ],",
+                "};",
+                "```",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/feature-enum-refine.mdx",
+            contents: [
+                "# Feature Enum Refine",
+                "",
+                "Refine the existing feature inventory. Find missing features, split overly",
+                "broad items into concrete code-backed features, and keep the grouping stable",
+                "unless there is a strong repo-backed reason to reorganize it.",
+                "",
+                "Iteration: {props.iteration}",
+                "",
+                "{props.lastCommitHash ? `A previous inventory exists. Inspect repo deltas with:\\ngit log --oneline ${props.lastCommitHash}..HEAD\\n` : \"\"}",
+                "",
+                "CURRENT FEATURE GROUPS:",
+                "```json",
+                "{JSON.stringify(props.existingFeatures ?? {}, null, 2)}",
+                "```",
+                "",
+                "Checklist:",
+                "",
+                "1. Add any concrete missing features you can prove from the code.",
+                "2. Decompose vague or overloaded feature names into auditable units.",
+                "3. Preserve naming discipline: SCREAMING_SNAKE_CASE groups and features.",
+                "4. Remove only entries that are clearly unsupported by the current codebase.",
+                "5. Keep `lastCommitHash` current by running `git rev-parse HEAD`.",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/audit-feature.mdx",
+            contents: [
+                "# Audit Feature Group",
+                "",
+                "Audit the feature group below for the requested focus area.",
+                "",
+                "Group: {props.groupName}",
+                "Focus: {props.focus}",
+                "",
+                "Features:",
+                "{(props.features ?? []).map((feature) => `- ${feature}`).join(\"\\n\")}",
+                "",
+                "{props.additionalContext ? `ADDITIONAL CONTEXT:\\n${props.additionalContext}\\n` : \"\"}",
+                "",
+                "Review the code paths that implement these features. Identify concrete gaps,",
+                "risks, missing safeguards, and the most important follow-up actions.",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/merge-tickets.mdx",
+            contents: [
+                "# Merge Tickets",
+                "",
+                "Merge the completed ticket branches back into the main branch.",
+                "",
+                "The following tickets were implemented in worktree branches:",
+                "",
+                "{props.ticketSummary}",
+                "",
+                'For each branch with status "success":',
+                "1. git merge the branch into the current branch (main)",
+                "2. If there are merge conflicts, resolve them sensibly",
+                "3. If a branch cannot be cleanly merged, skip it and note it as conflicted",
+                "",
+                "Report which branches were merged and which had conflicts.",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/tickets-create.mdx",
+            contents: [
+                "# Tickets Create",
+                "",
+                "Break the following request into well-defined tickets with titles, descriptions, and acceptance criteria.",
+                "",
+                "Request: {props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/feature-task.mdx",
+            contents: [
+                '# {props.granularity === "feature" ? "Feature" : "Feature Group"} Task',
+                "",
+                "Group: {props.groupName}",
+                "Granularity: {props.granularity}",
+                "",
+                "Features:",
+                '{props.features.map((feature) => `- ${feature}`).join("\\n")}',
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/audit.mdx",
+            contents: [
+                "Audit for: {props.focus}.",
+                "",
+                "Evaluate the provided feature scope for gaps in testing, observability, error handling, operational safety, and maintainability.",
+                "Use the repository as the source of truth and report concrete findings with actionable next steps.",
+                "",
+                '{props.additionalContext ? `Additional context:\\n${props.additionalContext}` : ""}',
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sweep-documentation.mdx",
+            contents: [
+                "Review documentation coverage for this feature group.",
+                "",
+                "Check docs/ for each feature listed. For every feature:",
+                "- Verify documentation exists and is accurate.",
+                "- If docs are missing, incomplete, or out of date — fix them directly.",
+                "- Improve clarity, add usage examples, and correct errors.",
+                "- Do NOT modify the README.",
+                "",
+                "You MUST succeed regardless of what you find. Fix any issues and report what you changed.",
+                "Score 0–100 based on documentation completeness AFTER your fixes.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sweep-e2e-testing.mdx",
+            contents: [
+                "Review end-to-end test coverage for this feature group.",
+                "",
+                "For every feature listed:",
+                "- Verify an e2e test exists with ZERO mocks — real dependencies only.",
+                "- Tests must cover all boundary conditions: maximum file sizes, maximum input lengths, empty inputs, extremely large inputs.",
+                "- If a value can be infinite or unbounded, there must be a test case for that.",
+                "- Every boundary, limit, and edge of the input domain must be exercised.",
+                "",
+                "If tests are missing or incomplete, write them.",
+                "Score 0–100 based on boundary-condition coverage AFTER your fixes.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sweep-unit-tests.mdx",
+            contents: [
+                "Review unit test coverage for this feature group.",
+                "",
+                "For every feature listed:",
+                "- Verify unit tests exist covering every boundary condition, edge case, and error condition.",
+                "- Tests must exercise: empty inputs, null/undefined, maximum values, minimum values, off-by-one, type mismatches, concurrent access (if applicable), and error/exception paths.",
+                "- Each test should isolate a single behavior.",
+                "",
+                "If tests are missing or incomplete, write them.",
+                "Score 0–100 based on edge-case coverage AFTER your fixes.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sweep-observability.mdx",
+            contents: [
+                "Review observability coverage for this feature group.",
+                "",
+                "For every feature listed, verify the implementation has:",
+                "- Structured logging at appropriate levels (debug, info, warn, error).",
+                "- Distributed tracing spans with meaningful names and attributes.",
+                "- Prometheus metrics where applicable (counters, histograms, gauges).",
+                "- Error logging with sufficient context for debugging.",
+                "",
+                "If observability is missing or insufficient, add it.",
+                "Score 0–100 based on observability completeness AFTER your fixes.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sweep-implementation.mdx",
+            contents: [
+                "Review implementation quality for this feature group.",
+                "",
+                "For every feature listed, verify the implementation:",
+                "- Has complete and accurate JSDoc on all public functions, types, and classes.",
+                "- Is clean, production-ready code.",
+                "- Prefers inlining over abstraction — only abstract if the pattern is used more than once.",
+                "- Has ZERO magic strings or magic numbers — all such values must be named constants.",
+                "- Has no dead code, unused imports, or commented-out code.",
+                "",
+                "If you see any way to improve the code, improve it.",
+                "Score 0–100 based on code quality AFTER your fixes.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sweep-cli.mdx",
+            contents: [
+                "Review CLI coverage for this feature group.",
+                "",
+                "For every feature listed:",
+                "- Determine if the feature should be accessible via the CLI.",
+                "- If it should, verify a CLI command or flag exists to use it.",
+                "- Verify the CLI help text is accurate and complete.",
+                "- If CLI access is missing and the feature warrants it, add it.",
+                "",
+                "Not every feature needs CLI access — use your judgment on applicability.",
+                "Score 0–100 based on CLI coverage of applicable features AFTER your fixes.",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sync-features-scan.mdx",
+            contents: [
+                "# Feature Inventory Scan",
+                "",
+                "Produce an exhaustive feature inventory for this Smithers orchestrator codebase.",
+                "You have the full file tree below — DO NOT read any files yourself. Analyze the structure",
+                "and produce the feature groups directly.",
+                "",
+                "Rules:",
+                "1. Group features by domain using SCREAMING_SNAKE_CASE group names.",
+                "2. Use SCREAMING_SNAKE_CASE feature names that are specific and code-backed.",
+                "3. Split broad buckets into concrete, independently auditable features.",
+                '4. lastCommitHash should be "{props.currentHead}".',
+                "5. Include a markdownBody that explains the grouping.",
+                "",
+                "CODEBASE STRUCTURE:",
+                "{props.codebaseSummary}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sync-features-refine.mdx",
+            contents: [
+                "# Feature Inventory Refine",
+                "",
+                "Refine the existing feature inventory by analyzing recent changes.",
+                "",
+                '{props.lastCommitHash ? `Compare with the previous inventory at commit ${props.lastCommitHash}. Check what changed.` : "This is the first delta check — review the existing features against the codebase structure below."}',
+                "",
+                "CURRENT FEATURE GROUPS:",
+                "{JSON.stringify(props.existingFeatures ?? {}, null, 2)}",
+                "",
+                "CODEBASE STRUCTURE:",
+                "{props.codebaseSummary}",
+                "",
+                "Checklist:",
+                "1. Add any concrete missing features based on the codebase structure.",
+                "2. Remove entries not supported by the current codebase.",
+                "3. Preserve naming discipline: SCREAMING_SNAKE_CASE groups and features.",
+                '4. lastCommitHash should be "{props.currentHead}".',
+                "5. markdownBody should summarize what changed.",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/sync-features-write.mdx",
+            contents: [
+                "# Write Features File",
+                "",
+                "Write the file .smithers/specs/features.ts with the feature groups below.",
+                "",
+                "First create the directory: mkdir -p specs",
+                "",
+                "Use this exact TypeScript structure:",
+                "",
+                "```typescript",
+                "/**",
+                " * Code-backed Smithers feature inventory.",
+                " *",
+                " * Auto-generated by the sync-features workflow.",
+                ' * Last synced at commit: {props.lastCommitHash ?? "unknown"}',
+                " */",
+                "",
+                "export const FeatureGroups = {'{'}",
+                "  // Source: {'<'}file paths{'>'}",
+                "  GROUP_NAME: [",
+                '    "FEATURE_1",',
+                '    "FEATURE_2",',
+                "  ],",
+                "{'}'} as const satisfies Record{'<'}string, readonly string[]{'>'};",
+                "",
+                "type FeatureGroupMap = typeof FeatureGroups;",
+                "export type FeatureGroupName = keyof FeatureGroupMap;",
+                "export type FeatureName = FeatureGroupMap[FeatureGroupName][number];",
+                "",
+                "const featureEntries: Array{'<'}readonly [FeatureName, FeatureName]{'>'} = [];",
+                "",
+                "for (const group of Object.values(FeatureGroups) as readonly (readonly FeatureName[])[]) {'{'}",
+                "  for (const feature of group) {'{'}",
+                "    featureEntries.push([feature, feature] as const);",
+                "  {'}'}",
+                "{'}'}",
+                "",
+                "export const Features = Object.freeze(",
+                "  Object.fromEntries(featureEntries) as Record{'<'}FeatureName, FeatureName{'>'},{'\\n'}",
+                ");",
+                "```",
+                "",
+                "FEATURE GROUPS:",
+                "{JSON.stringify(props.featureGroups, null, 2)}",
+                "",
+                'Write the file, then report: filePath ".smithers/specs/features.ts", commitHash "{props.lastCommitHash ?? "unknown"}", totalGroups and totalFeatures counts.',
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+    ];
+}
+/**
+ * @returns {TemplateFile[]}
+ */
+function renderComponents() {
+    return [
+        {
+            path: ".smithers/components/Review.tsx",
+            contents: [
+                "// smithers-source: seeded",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Parallel, Task, type AgentLike } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                'import ReviewPrompt from "../prompts/review.mdx";',
+                "",
+                "const reviewIssueSchema = z.object({",
+                '  severity: z.enum(["critical", "major", "minor", "nit"]),',
+                "  title: z.string(),",
+                "  file: z.string().nullable().default(null),",
+                "  description: z.string(),",
+                "});",
+                "",
+                "export const reviewOutputSchema = z.object({",
+                "  reviewer: z.string(),",
+                "  approved: z.boolean(),",
+                "  feedback: z.string(),",
+                "  issues: z.array(reviewIssueSchema).default([]),",
+                "});",
+                "",
+                "type ReviewProps = {",
+                "  idPrefix: string;",
+                "  prompt: unknown;",
+                "  agents: AgentLike[];",
+                "};",
+                "",
+                "export function Review({ idPrefix, prompt, agents }: ReviewProps) {",
+                '  const promptText = typeof prompt === "string" ? prompt : JSON.stringify(prompt ?? null);',
+                "  return (",
+                "    <Parallel>",
+                "      {agents.map((agent, index) => (",
+                "        <Task",
+                "          key={`${idPrefix}:${index}`}",
+                "          id={`${idPrefix}:${index}`}",
+                "          output={reviewOutputSchema}",
+                "          agent={agent}",
+                "          continueOnFail",
+                "        >",
+                '          <ReviewPrompt reviewer={`reviewer-${index + 1}`} prompt={promptText} />',
+                "        </Task>",
+                "      ))}",
+                "    </Parallel>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/components/ValidationLoop.tsx",
+            contents: [
+                "// smithers-source: seeded",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Sequence, Loop, Task, type AgentLike } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                'import { Review } from "~/components/Review";',
+                'import ImplementPrompt from "~/prompts/implement.mdx";',
+                'import ValidatePrompt from "~/prompts/validate.mdx";',
+                "",
+                "export const implementOutputSchema = z.object({",
+                "  summary: z.string(),",
+                "  filesChanged: z.array(z.string()).default([]),",
+                "  allTestsPassing: z.boolean().default(true),",
+                "});",
+                "export const validateOutputSchema = z.object({",
+                "  summary: z.string(),",
+                "  allPassed: z.boolean().default(true),",
+                "  failingSummary: z.string().nullable().default(null),",
+                "});",
+                "",
+                "export type ValidationLoopProps = {",
+                "  idPrefix: string;",
+                "  prompt: unknown;",
+                "  implementAgents: AgentLike[];",
+                "  reviewAgents: AgentLike[];",
+                "  validateAgents?: AgentLike[];",
+                "  feedback?: string | null;",
+                "  done?: boolean;",
+                "  maxIterations?: number;",
+                "};",
+                "",
+                "export function ValidationLoop({",
+                "  idPrefix,",
+                "  prompt,",
+                "  implementAgents,",
+                "  reviewAgents,",
+                "  validateAgents,",
+                "  feedback,",
+                "  done = false,",
+                "  maxIterations = 3,",
+                "}: ValidationLoopProps) {",
+                '  const promptText = typeof prompt === "string" ? prompt : JSON.stringify(prompt ?? null);',
+                "  return (",
+                '    <Loop id={`${idPrefix}:loop`} until={done} maxIterations={maxIterations} onMaxReached="return-last">',
+                "      <Sequence>",
+                "        <Task id={`${idPrefix}:implement`} output={implementOutputSchema} agent={implementAgents} timeoutMs={1_800_000} heartbeatTimeoutMs={600_000}>",
+                "          <ImplementPrompt prompt={feedback",
+                "            ? `${promptText}\\n\\n---\\nPREVIOUS ATTEMPT FEEDBACK (fix these issues):\\n${feedback}`",
+                "            : promptText} />",
+                "        </Task>",
+                "        <Task id={`${idPrefix}:validate`} output={validateOutputSchema} agent={validateAgents && validateAgents.length > 0",
+                "          ? validateAgents",
+                "          : implementAgents} timeoutMs={1_800_000} heartbeatTimeoutMs={600_000}>",
+                "          <ValidatePrompt prompt={promptText} />",
+                "        </Task>",
+                "        <Review idPrefix={`${idPrefix}:review`} prompt={promptText} agents={reviewAgents} />",
+                "      </Sequence>",
+                "    </Loop>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/components/CommandProbe.tsx",
+            contents: [
+                "// smithers-source: seeded",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Task } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                "",
+                "export const commandProbeOutputSchema = z.looseObject({",
+                "  command: z.string(),",
+                "  available: z.boolean(),",
+                "});",
+                "",
+                "export function CommandProbe({ id, command }: { id: string; command: string }) {",
+                "  return (",
+                "    <Task id={id} output={commandProbeOutputSchema}>",
+                "      {{ command, available: true }}",
+                "    </Task>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/components/GrillMe.tsx",
+            contents: [
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Loop, Sequence, Task, type AgentLike, type OutputTarget } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                'import GrillMeSkill from "skills/grill-me/SKILL.md";',
+                'import AskUserInstructions from "../prompts/ask-user-instructions.mdx";',
+                "",
+                "export const grillOutputSchema = z.looseObject({",
+                "  question: z.string(),",
+                "  recommendedAnswer: z.string().nullable().default(null),",
+                "  branch: z.string().nullable().default(null),",
+                "  resolved: z.boolean().default(false),",
+                "  questionsAsked: z.number().int().default(0),",
+                "  sharedUnderstanding: z.string().nullable().default(null),",
+                "});",
+                "",
+                "type GrillMeProps = {",
+                "  idPrefix: string;",
+                "  context: string;",
+                "  currentDraft?: any;",
+                "  agent: AgentLike | AgentLike[];",
+                "  output: OutputTarget;",
+                "  maxIterations?: number;",
+                "  children?: React.ReactNode;",
+                "  until?: boolean;",
+                "};",
+                "",
+                "export function GrillMe({",
+                "  idPrefix,",
+                "  context,",
+                "  currentDraft,",
+                "  agent,",
+                "  output,",
+                "  maxIterations = 1,",
+                "  children,",
+                "  until = false,",
+                "}: GrillMeProps) {",
+                "  return (",
+                "    <Sequence>",
+                "      <Loop until={until} maxIterations={maxIterations}>",
+                "        <Task id={`${idPrefix}:grill`} output={output} agent={agent}>",
+                "          <GrillMeSkill />",
+                "          <AskUserInstructions />",
+                "          {context}",
+                "          {currentDraft && `",
+                "",
+                "## Current Progress",
+                "Here is the result of the previous iteration:",
+                "",
+                "\\`\\`\\`json",
+                "${JSON.stringify(currentDraft, null, 2)}",
+                "\\`\\`\\`",
+                "",
+                "Review this result. If it completely fulfills the requirements, you can stop asking questions and mark resolved: true. Otherwise, I want you to further grill me so we can improve it.`}",
+                "        </Task>",
+                "        {children}",
+                "      </Loop>",
+                "    </Sequence>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/components/WriteAPrd.tsx",
+            contents: [
+                "// smithers-source: seeded",
+                "// Inspired by Matt Pocock's write-a-prd skill (https://github.com/mattpocock/skills)",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Sequence, Task, type AgentLike } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                'import WriteAPrdPrompt from "../prompts/write-a-prd.mdx";',
+                "",
+                "const userStorySchema = z.object({",
+                "  actor: z.string(),",
+                "  feature: z.string(),",
+                "  benefit: z.string(),",
+                "});",
+                "",
+                "const moduleSketchSchema = z.object({",
+                "  name: z.string(),",
+                "  description: z.string(),",
+                "  isDeepModule: z.boolean().default(false),",
+                "  needsTests: z.boolean().default(false),",
+                "});",
+                "",
+                "export const prdOutputSchema = z.looseObject({",
+                "  title: z.string(),",
+                "  problemStatement: z.string(),",
+                "  solution: z.string(),",
+                "  userStories: z.array(userStorySchema).default([]),",
+                "  implementationDecisions: z.array(z.string()).default([]),",
+                "  testingDecisions: z.array(z.string()).default([]),",
+                "  modules: z.array(moduleSketchSchema).default([]),",
+                "  outOfScope: z.array(z.string()).default([]),",
+                "  furtherNotes: z.string().nullable().default(null),",
+                "  markdownBody: z.string(),",
+                "});",
+                "",
+                "type WriteAPrdProps = {",
+                "  idPrefix: string;",
+                "  context: string;",
+                "  agent: AgentLike | AgentLike[];",
+                "  exploreCodebase?: boolean;",
+                "  interviewFirst?: boolean;",
+                "  maxInterviewQuestions?: number;",
+                "  moduleDepthGuidance?: boolean;",
+                "  outputFormat?: \"markdown\" | \"json\";",
+                "};",
+                "",
+                "export function WriteAPrd({",
+                "  idPrefix,",
+                "  context,",
+                "  agent,",
+                "  exploreCodebase = true,",
+                "  interviewFirst = true,",
+                "  maxInterviewQuestions = 20,",
+                "  moduleDepthGuidance = true,",
+                '  outputFormat = "markdown",',
+                "}: WriteAPrdProps) {",
+                "  const additionalInstructions = [",
+                "    exploreCodebase && \"Explore the codebase to verify assertions before writing.\",",
+                "    interviewFirst && `Interview the user first (up to ${maxInterviewQuestions} questions).`,",
+                "    moduleDepthGuidance && \"Prefer deep modules over shallow ones when sketching architecture.\",",
+                "    outputFormat === \"json\" && \"Return structured JSON in addition to the markdown body.\",",
+                "  ].filter(Boolean).join(\"\\n\");",
+                "",
+                "  return (",
+                "    <Sequence>",
+                "      <Task",
+                "        id={`${idPrefix}:prd`}",
+                "        output={prdOutputSchema}",
+                "        agent={agent}",
+                "      >",
+                "        <WriteAPrdPrompt context={context} additionalInstructions={additionalInstructions} />",
+                "      </Task>",
+                "    </Sequence>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/components/ForEachFeature.tsx",
+            contents: [
+                "// smithers-source: seeded",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Parallel, Sequence, Task, type AgentLike } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                'import FeatureTaskPrompt from "~/prompts/feature-task.mdx";',
+                "",
+                "export const forEachFeatureResultSchema = z.looseObject({",
+                "  groupName: z.string(),",
+                "  result: z.string(),",
+                "  featuresCovered: z.array(z.string()).default([]),",
+                "  score: z.number().min(0).max(100).optional(),",
+                "});",
+                "",
+                "export const forEachFeatureMergeSchema = z.looseObject({",
+                "  totalGroups: z.number().int(),",
+                "  summary: z.string(),",
+                "  mergedResult: z.string(),",
+                "  markdownBody: z.string(),",
+                "});",
+                "",
+                "type ForEachFeatureProps = {",
+                "  idPrefix: string;",
+                "  agent: AgentLike | AgentLike[];",
+                "  features: Record<string, string[]>;",
+                "  prompt: React.ReactNode;",
+                "  maxConcurrency?: number;",
+                "  mergeAgent?: AgentLike | AgentLike[];",
+                "  granularity?: \"group\" | \"feature\";",
+                "};",
+                "",
+                "type FeatureWorkItem = {",
+                "  id: string;",
+                "  groupName: string;",
+                "  features: string[];",
+                "};",
+                "",
+                "function slugifyFeatureToken(value: string) {",
+                "  const normalized = value",
+                '    .toLowerCase()',
+                '    .replace(/[^a-z0-9]+/g, "-")',
+                '    .replace(/^-+|-+$/g, "");',
+                '  return normalized.length > 0 ? normalized : "item";',
+                "}",
+                "",
+                "export function ForEachFeature({",
+                "  idPrefix,",
+                "  agent,",
+                "  features,",
+                "  prompt,",
+                "  maxConcurrency = 5,",
+                "  mergeAgent,",
+                '  granularity = "group",',
+                "}: ForEachFeatureProps) {",
+                "  const featureEntries = Object.entries(features ?? {}).filter(([, groupFeatures]) => Array.isArray(groupFeatures) && groupFeatures.length > 0);",
+                "  const workItems: FeatureWorkItem[] = granularity === \"feature\"",
+                "    ? featureEntries.flatMap(([groupName, groupFeatures]) =>",
+                "        groupFeatures.map((feature, index) => ({",
+                "          id: `${slugifyFeatureToken(groupName)}:${slugifyFeatureToken(feature)}:${index}`,",
+                "          groupName,",
+                "          features: [feature],",
+                "        })),",
+                "      )",
+                "    : featureEntries.map(([groupName, groupFeatures], index) => ({",
+                "        id: `${slugifyFeatureToken(groupName)}:${index}`,",
+                "        groupName,",
+                "        features: groupFeatures,",
+                "      }));",
+                "",
+                "  const mergeNeeds: Record<string, string> = Object.fromEntries(",
+                "    workItems.map((item, index) => [`item${index}`, `${idPrefix}:group:${item.id}`]),",
+                "  );",
+                "  const mergeDeps = Object.fromEntries(",
+                "    workItems.map((_, index) => [`item${index}`, forEachFeatureResultSchema]),",
+                "  ) as Record<string, typeof forEachFeatureResultSchema>;",
+                "",
+                "  if (workItems.length === 0) {",
+                "    return (",
+                "      <Sequence>",
+                "        <Task id={`${idPrefix}:merge`} output={forEachFeatureMergeSchema}>",
+                "          {{",
+                "            totalGroups: 0,",
+                '            summary: "No feature groups were provided.",',
+                '            mergedResult: "",',
+                '            markdownBody: "# Feature Audit\\n\\nNo feature groups were provided.",',
+                "          }}",
+                "        </Task>",
+                "      </Sequence>",
+                "    );",
+                "  }",
+                "",
+                "  return (",
+                "    <Sequence>",
+                "      <Parallel maxConcurrency={maxConcurrency}>",
+                "        {workItems.map((item) => (",
+                "          <Task",
+                "            key={`${idPrefix}:${item.id}`}",
+                "            id={`${idPrefix}:group:${item.id}`}",
+                "            output={forEachFeatureResultSchema}",
+                "            agent={agent}",
+                "            continueOnFail",
+                "          >",
+                "            <FeatureTaskPrompt",
+                "              granularity={granularity}",
+                "              groupName={item.groupName}",
+                "              features={item.features}",
+                "              prompt={prompt}",
+                "            />",
+                "          </Task>",
+                "        ))}",
+                "      </Parallel>",
+                "      <Task",
+                "        id={`${idPrefix}:merge`}",
+                "        output={forEachFeatureMergeSchema}",
+                "        agent={mergeAgent ?? agent}",
+                "        needs={mergeNeeds}",
+                "        deps={mergeDeps}",
+                "      >",
+                "        {(deps) => {",
+                "          const results = workItems.map((_, index) => deps[`item${index}`]);",
+                "          const totalGroups = new Set(workItems.map((item) => item.groupName)).size;",
+                "          return [",
+                '            "# Merge Feature Results",',
+                '            "",',
+                '            `Granularity: ${granularity}`,',
+                '            `Distinct groups: ${totalGroups}`,',
+                '            `Work items: ${workItems.length}`,',
+                '            `Set totalGroups to ${totalGroups}.`,',
+                '            "",',
+                '            "Combine the per-group results below into a single coherent output.",',
+                '            "Preserve group boundaries, highlight the most important gaps, and produce a markdownBody suitable for a report.",',
+                '            "",',
+                "            ...results.flatMap((result, index) => {",
+                "              const groupLabel = workItems[index]?.groupName ?? `Group ${index + 1}`;",
+                "              return [",
+                "                `## ${groupLabel}`,",
+                "                `Features covered: ${(result?.featuresCovered ?? []).join(\", \") || \"none\"}`,",
+                "                result?.score != null ? `Score: ${result.score}` : null,",
+                "                result?.result ?? \"\",",
+                "                \"\",",
+                "              ].filter(Boolean);",
+                "            }),",
+                "          ].join(\"\\n\");",
+                "        }}",
+                "      </Task>",
+                "    </Sequence>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/components/FeatureEnum.tsx",
+            contents: [
+                "// smithers-source: seeded",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { Sequence, Task, type AgentLike } from "smithers-orchestrator";',
+                'import { z } from "zod/v4";',
+                'import FeatureEnumScanPrompt from "../prompts/feature-enum-scan.mdx";',
+                'import FeatureEnumRefinePrompt from "../prompts/feature-enum-refine.mdx";',
+                "",
+                "export const featureEnumOutputSchema = z.looseObject({",
+                "  featureGroups: z.record(z.string(), z.array(z.string())).default({}),",
+                "  totalFeatures: z.number().int().default(0),",
+                "  lastCommitHash: z.string().nullable().optional(),",
+                "  markdownBody: z.string(),",
+                "});",
+                "",
+                "type FeatureEnumProps = {",
+                "  idPrefix: string;",
+                "  agent: AgentLike | AgentLike[];",
+                "  refineIterations?: number;",
+                "  existingFeatures?: Record<string, string[]> | null;",
+                "  lastCommitHash?: string | null;",
+                "  additionalContext?: string;",
+                "};",
+                "",
+                'const memoryNamespace = { kind: "workflow", id: "feature-enum" } as const;',
+                "",
+                "export function FeatureEnum({",
+                "  idPrefix,",
+                "  agent,",
+                "  refineIterations,",
+                "  existingFeatures = null,",
+                "  lastCommitHash = null,",
+                '  additionalContext = "",',
+                "}: FeatureEnumProps) {",
+                "  const isFirstRun = !existingFeatures;",
+                "  const totalRefineIterations = Math.max(1, refineIterations ?? (isFirstRun ? 5 : 1));",
+                "  const scanTaskId = `${idPrefix}:scan`;",
+                "  const refineTaskIds = Array.from({ length: totalRefineIterations }, (_, index) => `${idPrefix}:refine:${index + 1}`);",
+                "  const finalTaskId = `${idPrefix}:result`;",
+                "",
+                "  return (",
+                "    <Sequence>",
+                "      {isFirstRun && (",
+                "        <Task",
+                "          id={scanTaskId}",
+                "          output={featureEnumOutputSchema}",
+                "          agent={agent}",
+                "          memory={{",
+                "            remember: {",
+                "              namespace: memoryNamespace,",
+                "              key: scanTaskId,",
+                "            },",
+                "          }}",
+                "        >",
+                "          <FeatureEnumScanPrompt additionalContext={additionalContext} />",
+                "        </Task>",
+                "      )}",
+                "",
+                "      {refineTaskIds.map((taskId, index) => {",
+                "        const previousTaskId = index === 0",
+                "          ? (isFirstRun ? scanTaskId : null)",
+                "          : refineTaskIds[index - 1];",
+                "",
+                "        if (previousTaskId) {",
+                "          return (",
+                "            <Task",
+                "              key={taskId}",
+                "              id={taskId}",
+                "              output={featureEnumOutputSchema}",
+                "              agent={agent}",
+                "              needs={{ previous: previousTaskId }}",
+                "              deps={{ previous: featureEnumOutputSchema }}",
+                "              memory={{",
+                "                recall: {",
+                "                  namespace: memoryNamespace,",
+                '                  query: "feature inventory feature enum grouped features",',
+                "                  topK: 5,",
+                "                },",
+                "                remember: {",
+                "                  namespace: memoryNamespace,",
+                "                  key: taskId,",
+                "                },",
+                "              }}",
+                "            >",
+                "              {(deps) => (",
+                "                <FeatureEnumRefinePrompt",
+                "                  existingFeatures={deps.previous.featureGroups}",
+                "                  lastCommitHash={deps.previous.lastCommitHash ?? lastCommitHash}",
+                "                  iteration={index + 1}",
+                "                />",
+                "              )}",
+                "            </Task>",
+                "          );",
+                "        }",
+                "",
+                "        return (",
+                "          <Task",
+                "            key={taskId}",
+                "            id={taskId}",
+                "            output={featureEnumOutputSchema}",
+                "            agent={agent}",
+                "            memory={{",
+                "              recall: {",
+                "                namespace: memoryNamespace,",
+                '                query: "feature inventory feature enum grouped features",',
+                "                topK: 5,",
+                "              },",
+                "              remember: {",
+                "                namespace: memoryNamespace,",
+                "                key: taskId,",
+                "              },",
+                "            }}",
+                "          >",
+                "            <FeatureEnumRefinePrompt",
+                "              existingFeatures={existingFeatures ?? {}}",
+                "              lastCommitHash={lastCommitHash}",
+                "              iteration={index + 1}",
+                "            />",
+                "          </Task>",
+                "        );",
+                "      })}",
+                "",
+                "      <Task",
+                "        id={finalTaskId}",
+                "        output={featureEnumOutputSchema}",
+                "        needs={{ final: refineTaskIds[refineTaskIds.length - 1] ?? scanTaskId }}",
+                "        deps={{ final: featureEnumOutputSchema }}",
+                "      >",
+                "        {(deps) => deps.final}",
+                "      </Task>",
+                "    </Sequence>",
+                "  );",
+                "}",
+                "",
+            ].join("\n"),
+        },
+    ];
+}
+/**
+ * @param {string} id
+ * @param {string} displayName
+ * @param {string[]} body
+ */
+function renderWorkflowFile(id, displayName, body) {
+    return {
+        path: `.smithers/workflows/${id}.tsx`,
+        contents: [
+            "// smithers-source: seeded",
+            `// smithers-display-name: ${displayName}`,
+            "/** @jsxImportSource smithers-orchestrator */",
+            ...body,
+            "",
+        ].join("\n"),
+    };
+}
+/**
+ * @returns {TemplateFile[]}
+ */
+function renderWorkflows() {
+    const sharedImports = [
+        'import { createSmithers } from "smithers-orchestrator";',
+        'import { z } from "zod/v4";',
+        'import { agents } from "../agents";',
+    ];
+    return [
+        renderWorkflowFile("implement", "Implement", [
+            ...sharedImports,
+            'import { ValidationLoop, implementOutputSchema, validateOutputSchema } from "../components/ValidationLoop";',
+            'import { reviewOutputSchema } from "../components/Review";',
+            "",
+            "const { Workflow, smithers } = createSmithers({",
+            "  implement: implementOutputSchema,",
+            "  validate: validateOutputSchema,",
+            "  review: reviewOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => {",
+            '  const validate = ctx.outputMaybe("validate", { nodeId: "impl:validate" });',
+            "  const reviews = ctx.outputs.review ?? [];",
+            "",
+            "  // done = false until validate has actually run AND passed, AND at least one reviewer approved",
+            "  const hasValidated = validate !== undefined;",
+            "  const validationPassed = hasValidated && validate.allPassed !== false;",
+            "  const anyApproved = reviews.length > 0 && reviews.some((r: any) => r.approved === true);",
+            "  const done = validationPassed && anyApproved;",
+            "",
+            "  const feedbackParts: string[] = [];",
+            "  if (validate && !validationPassed && validate.failingSummary) {",
+            "    feedbackParts.push(`VALIDATION FAILED:\\n${validate.failingSummary}`);",
+            "  }",
+            "  for (const review of reviews) {",
+            "    if (review.approved === false) {",
+            "      feedbackParts.push(`REVIEWER REJECTED:\\n${review.feedback}`);",
+            "      if (review.issues?.length) {",
+            "        for (const issue of review.issues) {",
+            "          feedbackParts.push(`  [${issue.severity}] ${issue.title}: ${issue.description}${issue.file ? ` (${issue.file})` : \"\"}`);",
+            "        }",
+            "      }",
+            "    }",
+            "  }",
+            "  const feedback = feedbackParts.length > 0 ? feedbackParts.join(\"\\n\\n\") : null;",
+            "",
+            "  return (",
+            '    <Workflow name="implement">',
+            "      <ValidationLoop",
+            '        idPrefix="impl"',
+            "        prompt={ctx.input.prompt}",
+            "        implementAgents={agents.smart}",
+            "        validateAgents={agents.cheapFast}",
+            "        reviewAgents={agents.smart}",
+            "        feedback={feedback}",
+            "        done={done}",
+            "        maxIterations={3}",
+            "      />",
+            "    </Workflow>",
+            "  );",
+            "});",
+        ]),
+        renderWorkflowFile("research-plan-implement", "Research Plan Implement", [
+            ...sharedImports,
+            'import { ValidationLoop, implementOutputSchema, validateOutputSchema } from "../components/ValidationLoop";',
+            'import { reviewOutputSchema } from "../components/Review";',
+            'import ResearchPrompt from "../prompts/research.mdx";',
+            'import PlanPrompt from "../prompts/plan.mdx";',
+            "",
+            "const researchOutputSchema = z.looseObject({",
+            "  summary: z.string(),",
+            "  keyFindings: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const planOutputSchema = z.looseObject({",
+            "  summary: z.string(),",
+            "  steps: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Implement the requested change."),',
+            "  tdd: z.boolean().default(false),",
+            "});",
+            "",
+            "const { Workflow, Task, Sequence, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  research: researchOutputSchema,",
+            "  plan: planOutputSchema,",
+            "  implement: implementOutputSchema,",
+            "  validate: validateOutputSchema,",
+            "  review: reviewOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => {",
+            "  const prompt = ctx.input.prompt;",
+            "  const tdd = ctx.input.tdd;",
+            "",
+            '  const research = ctx.outputMaybe("research", { nodeId: "research" });',
+            '  const plan = ctx.outputMaybe("plan", { nodeId: "plan" });',
+            "",
+            "  // Enrich plan prompt with research findings",
+            "  const planPromptParts = [",
+            "    prompt,",
+            "    research",
+            "      ? `RESEARCH FINDINGS:\\n${research.summary}\\n\\nKey findings:\\n${research.keyFindings.map((f: string) => `- ${f}`).join(\"\\n\")}`",
+            "      : null,",
+            "    tdd",
+            '      ? "IMPORTANT: Write tests FIRST. The plan MUST start with test steps before any implementation steps. Follow test-driven development: define expected behavior in tests, then implement to make them pass."',
+            "      : null,",
+            "  ];",
+            '  const planPrompt = planPromptParts.filter(Boolean).join("\\n\\n---\\n");',
+            "",
+            "  // Enrich implement prompt with both research and plan",
+            "  const implementPrompt = [",
+            "    prompt,",
+            "    research ? `RESEARCH FINDINGS:\\n${research.summary}\\n\\nKey findings:\\n${research.keyFindings.map((f: string) => `- ${f}`).join(\"\\n\")}` : null,",
+            "    plan ? `IMPLEMENTATION PLAN:\\n${plan.summary}\\n\\nSteps:\\n${plan.steps.map((s: string, i: number) => `${i + 1}. ${s}`).join(\"\\n\")}` : null,",
+            '    tdd ? "IMPORTANT: Follow the plan\'s test-first approach. Write or update tests before implementing production code." : null,',
+            "  ].filter(Boolean).join(\"\\n\\n---\\n\");",
+            "",
+            "  // Validation loop feedback",
+            '  const validate = ctx.outputMaybe("validate", { nodeId: "impl:validate" });',
+            "  const reviews = ctx.outputs.review ?? [];",
+            "",
+            "  const hasValidated = validate !== undefined;",
+            "  const validationPassed = hasValidated && validate.allPassed !== false;",
+            "  const anyApproved = reviews.length > 0 && reviews.some((r: any) => r.approved === true);",
+            "  const done = validationPassed && anyApproved;",
+            "",
+            "  const feedbackParts: string[] = [];",
+            "  if (validate && !validationPassed && validate.failingSummary) {",
+            "    feedbackParts.push(`VALIDATION FAILED:\\n${validate.failingSummary}`);",
+            "  }",
+            "  for (const review of reviews) {",
+            "    if (review.approved === false) {",
+            "      feedbackParts.push(`REVIEWER REJECTED:\\n${review.feedback}`);",
+            "      if (review.issues?.length) {",
+            "        for (const issue of review.issues) {",
+            "          feedbackParts.push(`  [${issue.severity}] ${issue.title}: ${issue.description}${issue.file ? ` (${issue.file})` : \"\"}`);",
+            "        }",
+            "      }",
+            "    }",
+            "  }",
+            "  const feedback = feedbackParts.length > 0 ? feedbackParts.join(\"\\n\\n\") : null;",
+            "",
+            "  return (",
+            '    <Workflow name="research-plan-implement">',
+            "      <Sequence>",
+            '        <Task id="research" output={researchOutputSchema} agent={agents.smartTool}>',
+            "          <ResearchPrompt prompt={prompt} />",
+            "        </Task>",
+            '        <Task id="plan" output={planOutputSchema} agent={agents.smart}>',
+            "          <PlanPrompt prompt={planPrompt} />",
+            "        </Task>",
+            "        <ValidationLoop",
+            '          idPrefix="impl"',
+            "          prompt={implementPrompt}",
+            "          implementAgents={agents.smart}",
+            "          validateAgents={agents.cheapFast}",
+            "          reviewAgents={agents.smart}",
+            "          feedback={feedback}",
+            "          done={done}",
+            "          maxIterations={3}",
+            "        />",
+            "      </Sequence>",
+            "    </Workflow>",
+            "  );",
+            "});",
+        ]),
+        renderWorkflowFile("review", "Review", [
+            ...sharedImports,
+            'import { Review, reviewOutputSchema } from "../components/Review";',
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Review the current repository changes."),',
+            "});",
+            "",
+            "const { Workflow, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  review: reviewOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="review">',
+            "    <Review",
+            '      idPrefix="review"',
+            "      prompt={ctx.input.prompt}",
+            "      agents={agents.smart}",
+            "    />",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("plan", "Plan", [
+            ...sharedImports,
+            'import PlanPrompt from "../prompts/plan.mdx";',
+            "",
+            "const planOutputSchema = z.looseObject({",
+            "  summary: z.string(),",
+            "  steps: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Create an implementation plan."),',
+            "});",
+            "",
+            "const { Workflow, Task, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  plan: planOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="plan">',
+            '    <Task id="plan" output={planOutputSchema} agent={agents.smart}>',
+            "      <PlanPrompt prompt={ctx.input.prompt} />",
+            "    </Task>",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("research", "Research", [
+            ...sharedImports,
+            'import ResearchPrompt from "../prompts/research.mdx";',
+            "",
+            "const researchOutputSchema = z.looseObject({",
+            "  summary: z.string(),",
+            "  keyFindings: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Research the given topic."),',
+            "});",
+            "",
+            "const { Workflow, Task, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  research: researchOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="research">',
+            '    <Task id="research" output={researchOutputSchema} agent={agents.smartTool}>',
+            "      <ResearchPrompt prompt={ctx.input.prompt} />",
+            "    </Task>",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("ticket-create", "Ticket Create", [
+            ...sharedImports,
+            'import TicketPrompt from "../prompts/ticket.mdx";',
+            "",
+            "const ticketCreateOutputSchema = z.looseObject({",
+            "  title: z.string(),",
+            "  description: z.string(),",
+            "  acceptanceCriteria: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Create a ticket for the requested work."),',
+            "});",
+            "",
+            "const { Workflow, Task, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  ticket: ticketCreateOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="ticket-create">',
+            '    <Task id="ticket" output={ticketCreateOutputSchema} agent={agents.smart}>',
+            "      <TicketPrompt prompt={ctx.input.prompt} />",
+            "    </Task>",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("tickets-create", "Tickets Create", [
+            ...sharedImports,
+            'import TicketsCreatePrompt from "../prompts/tickets-create.mdx";',
+            "",
+            "const ticketsCreateOutputSchema = z.looseObject({",
+            "  summary: z.string(),",
+            "  tickets: z.array(z.object({",
+            "    title: z.string(),",
+            "    description: z.string(),",
+            "    acceptanceCriteria: z.array(z.string()).default([]),",
+            "  })).default([]),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Create tickets for the requested work."),',
+            "});",
+            "",
+            "const { Workflow, Task, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  tickets: ticketsCreateOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="tickets-create">',
+            '    <Task id="tickets" output={ticketsCreateOutputSchema} agent={agents.smart}>',
+            "      <TicketsCreatePrompt prompt={ctx.input.prompt} />",
+            "    </Task>",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("ralph", "Ralph", [
+            ...sharedImports,
+            "",
+            "const ralphOutputSchema = z.looseObject({",
+            "  summary: z.string(),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Continue working on the current task."),',
+            "});",
+            "",
+            "const { Workflow, Task, Loop, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  ralph: ralphOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="ralph">',
+            "    <Loop until={false} maxIterations={Infinity}>",
+            '      <Task id="ralph" output={ralphOutputSchema} agent={agents.smart}>',
+            "        {ctx.input.prompt}",
+            "      </Task>",
+            "    </Loop>",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("improve-test-coverage", "Improve Test Coverage", [
+            ...sharedImports,
+            'import { ValidationLoop, implementOutputSchema, validateOutputSchema } from "../components/ValidationLoop";',
+            'import { reviewOutputSchema } from "../components/Review";',
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Improve the test coverage for the current repository."),',
+            "});",
+            "",
+            "const { Workflow, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  implement: implementOutputSchema,",
+            "  validate: validateOutputSchema,",
+            "  review: reviewOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="improve-test-coverage">',
+            "    <ValidationLoop",
+            '      idPrefix="improve-test-coverage"',
+            "      prompt={ctx.input.prompt}",
+            "      implementAgents={agents.smart}",
+            "      validateAgents={agents.cheapFast}",
+            "      reviewAgents={agents.smart}",
+            "    />",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("debug", "Debug", [
+            ...sharedImports,
+            'import { ValidationLoop, implementOutputSchema, validateOutputSchema } from "../components/ValidationLoop";',
+            'import { reviewOutputSchema } from "../components/Review";',
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Reproduce and fix the reported bug."),',
+            "});",
+            "",
+            "const { Workflow, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  implement: implementOutputSchema,",
+            "  validate: validateOutputSchema,",
+            "  review: reviewOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="debug">',
+            "    <ValidationLoop",
+            '      idPrefix="debug"',
+            "      prompt={ctx.input.prompt}",
+            "      implementAgents={agents.smart}",
+            "      validateAgents={agents.cheapFast}",
+            "      reviewAgents={agents.smart}",
+            "    />",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("grill-me", "Grill Me", [
+            ...sharedImports,
+            'import { GrillMe, grillOutputSchema } from "../components/GrillMe";',
+            "",
+            'const WORKFLOW_ID = "grill-me";',
+            "",
+            "const { Workflow, smithers, outputs } = createSmithers({",
+            "  input: z.object({",
+            '    prompt: z.string().default("Describe what you want to get grilled on."),',
+            "    maxIterations: z.number().int().default(30),",
+            "  }),",
+            "  grill: grillOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            "  <Workflow name={WORKFLOW_ID}>",
+            "    <GrillMe",
+            "      idPrefix={WORKFLOW_ID}",
+            "      context={ctx.input.prompt}",
+            "      agent={agents.smart}",
+            "      output={outputs.grill}",
+            "      maxIterations={ctx.input.maxIterations}",
+            "    />",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("write-a-prd", "Write a PRD", [
+            "// Inspired by Matt Pocock's write-a-prd skill (https://github.com/mattpocock/skills)",
+            ...sharedImports,
+            'import { GrillMe, grillOutputSchema } from "../components/GrillMe";',
+            'import WriteAPrdPrompt from "../prompts/write-a-prd.mdx";',
+            "",
+            'const WORKFLOW_ID = "write-a-prd";',
+            "",
+            "const { Workflow, Task, smithers, outputs } = createSmithers({",
+            "  input: z.object({",
+            '    prompt: z.string().default("Describe the feature or product you want to specify."),',
+            "    maxIterations: z.number().int().default(10),",
+            "  }),",
+            "  grill: grillOutputSchema,",
+            "  prd: z.looseObject({",
+            "    title: z.string(),",
+            "    problemStatement: z.string(),",
+            "    solution: z.string(),",
+            "    userStories: z.array(z.object({",
+            "      actor: z.string(),",
+            "      feature: z.string(),",
+            "      benefit: z.string(),",
+            "    })).default([]),",
+            "    implementationDecisions: z.array(z.string()).default([]),",
+            "    testingDecisions: z.array(z.string()).default([]),",
+            "    observabilityRequirements: z.array(z.string()).default([]),",
+            "    metrics: z.array(z.string()).default([]),",
+            "    verificationStrategy: z.array(z.string()).default([]),",
+            "    modules: z.array(z.object({",
+            "      name: z.string(),",
+            "      description: z.string(),",
+            "      isDeepModule: z.boolean().default(false),",
+            "      needsTests: z.boolean().default(false),",
+            "    })).default([]),",
+            "    outOfScope: z.array(z.string()).default([]),",
+            "    furtherNotes: z.string().nullable().default(null),",
+            "    markdownBody: z.string(),",
+            "  }),",
+            "});",
+            "",
+            "export default smithers((ctx) => {",
+            "  const prdHistory = ctx.outputs.prd || [];",
+            "  const currentDraft = prdHistory[prdHistory.length - 1];",
+            "  const previousDraft = prdHistory[prdHistory.length - 2];",
+            "  const isUnchanged = prdHistory.length > 1 && JSON.stringify(currentDraft) === JSON.stringify(previousDraft);",
+            "",
+            "  return (",
+            "    <Workflow name={WORKFLOW_ID}>",
+            "      <GrillMe",
+            "        until={isUnchanged}",
+            "        idPrefix={WORKFLOW_ID}",
+            "        context={ctx.input.prompt}",
+            "        currentDraft={currentDraft}",
+            "        agent={agents.smart}",
+            "        output={outputs.grill}",
+            "        maxIterations={ctx.input.maxIterations}",
+            "      >",
+            "        <Task id={`${WORKFLOW_ID}:prd`} output={outputs.prd} agent={agents.smart}>",
+            "          <WriteAPrdPrompt",
+            "            context={ctx.input.prompt}",
+            "            additionalInstructions={`Explore the codebase to verify assertions before writing.",
+            "Prefer deep modules over shallow ones when sketching architecture.`}",
+            "          />",
+            "        </Task>",
+            "      </GrillMe>",
+            "    </Workflow>",
+            "  );",
+            "});",
+        ]),
+        renderWorkflowFile("feature-enum", "Feature Enum", [
+            ...sharedImports,
+            'import { FeatureEnum, featureEnumOutputSchema } from "../components/FeatureEnum";',
+            "",
+            "const inputSchema = z.object({",
+            "  refineIterations: z.number().int().default(1),",
+            "  existingFeatures: z.record(z.string(), z.array(z.string())).nullable().default(null),",
+            "  lastCommitHash: z.string().nullable().default(null),",
+            '  additionalContext: z.string().default(""),',
+            "});",
+            "",
+            "const { Workflow, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  featureEnum: featureEnumOutputSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="feature-enum">',
+            "    <FeatureEnum",
+            '      idPrefix="feature-enum"',
+            "      agent={agents.smartTool}",
+            "      refineIterations={ctx.input.refineIterations}",
+            "      existingFeatures={ctx.input.existingFeatures}",
+            "      lastCommitHash={ctx.input.lastCommitHash}",
+            "      additionalContext={ctx.input.additionalContext}",
+            "    />",
+            "  </Workflow>",
+            "));",
+        ]),
+        renderWorkflowFile("audit", "Audit", [
+            ...sharedImports,
+            'import { ForEachFeature, forEachFeatureMergeSchema, forEachFeatureResultSchema } from "../components/ForEachFeature";',
+            'import AuditPrompt from "../prompts/audit.mdx";',
+            "",
+            "const inputSchema = z.object({",
+            "  features: z.record(z.string(), z.array(z.string())).default({}),",
+            '  focus: z.string().default("code review"),',
+            "  additionalContext: z.string().nullable().default(null),",
+            "  maxConcurrency: z.number().int().default(5),",
+            "});",
+            "",
+            "const { Workflow, smithers } = createSmithers({",
+            "  input: inputSchema,",
+            "  auditFeature: forEachFeatureResultSchema,",
+            "  audit: forEachFeatureMergeSchema,",
+            "});",
+            "",
+            "export default smithers((ctx) => (",
+            '  <Workflow name="audit">',
+            "    <ForEachFeature",
+            '      idPrefix="audit"',
+            "      agent={agents.smart}",
+            "      features={ctx.input.features}",
+            "      prompt={<AuditPrompt focus={ctx.input.focus} additionalContext={ctx.input.additionalContext} />}",
+            "      maxConcurrency={ctx.input.maxConcurrency}",
+            "      mergeAgent={agents.smart}",
+            "    />",
+            "  </Workflow>",
+            "));",
+        ]),
+        {
+            path: ".smithers/workflows/kanban.tsx",
+            contents: [
+                "// smithers-display-name: Kanban",
+                "/** @jsxImportSource smithers-orchestrator */",
+                'import { createSmithers, Sequence, Parallel, Worktree } from "smithers-orchestrator";',
+                'import { readdirSync, readFileSync } from "node:fs";',
+                'import { resolve } from "node:path";',
+                'import { z } from "zod/v4";',
+                'import { agents } from "../agents";',
+                'import { ValidationLoop, implementOutputSchema, validateOutputSchema } from "../components/ValidationLoop";',
+                'import { reviewOutputSchema } from "../components/Review";',
+                'import MergeTicketsPrompt from "../prompts/merge-tickets.mdx";',
+                "",
+                "const ticketResultSchema = z.object({",
+                "  ticketId: z.string(),",
+                "  branch: z.string(),",
+                '  status: z.enum(["success", "partial", "failed"]),',
+                "  summary: z.string(),",
+                "});",
+                "",
+                "const mergeResultSchema = z.object({",
+                "  merged: z.array(z.string()),",
+                "  conflicted: z.array(z.string()),",
+                "  summary: z.string(),",
+                "});",
+                "",
+                "const { Workflow, Task, smithers, outputs } = createSmithers({",
+                "  implement: implementOutputSchema,",
+                "  validate: validateOutputSchema,",
+                "  review: reviewOutputSchema,",
+                "  ticketResult: ticketResultSchema,",
+                "  merge: mergeResultSchema,",
+                "});",
+                "",
+                'function discoverTickets(): Array<{ id: string; slug: string; content: string }> {',
+                '  const ticketsDir = resolve(process.cwd(), ".smithers/tickets");',
+                "  try {",
+                "    return readdirSync(ticketsDir, { withFileTypes: true })",
+                '      .filter((e) => e.isFile() && e.name.endsWith(".md") && e.name !== ".gitkeep")',
+                "      .map((e) => {",
+                '        const content = readFileSync(resolve(ticketsDir, e.name), "utf8");',
+                '        const slug = e.name.replace(/\\.md$/, "");',
+                "        return { id: e.name, slug, content };",
+                "      })",
+                "      .sort((a, b) => a.id.localeCompare(b.id));",
+                "  } catch {",
+                "    return [];",
+                "  }",
+                "}",
+                "",
+                "/** Build feedback string from validation + review outputs for a ticket. */",
+                "function buildFeedback(",
+                "  ctx: any,",
+                "  slug: string,",
+                "): { feedback: string | null; done: boolean } {",
+                '  const validate = ctx.outputMaybe("validate", { nodeId: `${slug}:validate` });',
+                "  const reviews = ctx.outputs.review ?? [];",
+                "",
+                "  // Filter reviews for this ticket's prefix",
+                "  const ticketReviews = reviews.filter(",
+                '    (r: any) => r.reviewer?.startsWith?.("reviewer-"),',
+                "  );",
+                "",
+                "  // done = false until validate has actually run AND passed, AND at least one reviewer approved",
+                "  const hasValidated = validate !== undefined;",
+                "  const validationPassed = hasValidated && validate.allPassed !== false;",
+                "  const anyReviewApproved = ticketReviews.length > 0 && ticketReviews.some((r: any) => r.approved === true);",
+                "  const done = validationPassed && anyReviewApproved;",
+                "",
+                "  if (!hasValidated) return { feedback: null, done: false };",
+                "",
+                "  const parts: string[] = [];",
+                "",
+                "  if (!validationPassed && validate.failingSummary) {",
+                "    parts.push(`VALIDATION FAILED:\\n${validate.failingSummary}`);",
+                "  }",
+                "",
+                "  for (const review of ticketReviews) {",
+                "    if (review.approved === false) {",
+                "      parts.push(`REVIEWER REJECTED:\\n${review.feedback}`);",
+                "      if (review.issues?.length) {",
+                "        for (const issue of review.issues) {",
+                "          parts.push(`  [${issue.severity}] ${issue.title}: ${issue.description}${issue.file ? ` (${issue.file})` : \"\"}`);",
+                "        }",
+                "      }",
+                "    }",
+                "  }",
+                "",
+                "  return {",
+                '    feedback: parts.length > 0 ? parts.join("\\n\\n") : null,',
+                "    done,",
+                "  };",
+                "}",
+                "",
+                "export default smithers((ctx) => {",
+                "  const tickets = discoverTickets();",
+                "  const maxConcurrency = Number(ctx.input.maxConcurrency) || 3;",
+                "  const ticketResults = ctx.outputs.ticketResult ?? [];",
+                "",
+                "  return (",
+                '    <Workflow name="kanban">',
+                "      <Sequence>",
+                "        {/* Implement each ticket in its own worktree branch, in parallel */}",
+                "        <Parallel maxConcurrency={maxConcurrency}>",
+                "          {tickets.map((ticket) => {",
+                "            const { feedback, done } = buildFeedback(ctx, ticket.slug);",
+                "            return (",
+                "              <Worktree",
+                "                key={ticket.slug}",
+                "                path={`.worktrees/${ticket.slug}`}",
+                "                branch={`ticket/${ticket.slug}`}",
+                "              >",
+                "                <Sequence>",
+                "                  <ValidationLoop",
+                "                    idPrefix={ticket.slug}",
+                "                    prompt={`Implement the ticket below.\\n\\nTICKET FILE: .smithers/tickets/${ticket.id}\\n\\n${ticket.content}`}",
+                "                    implementAgents={agents.smart}",
+                "                    validateAgents={agents.smart}",
+                "                    reviewAgents={agents.smart}",
+                "                    feedback={feedback}",
+                "                    done={done}",
+                "                    maxIterations={3}",
+                "                  />",
+                "                  <Task",
+                "                    id={`result-${ticket.slug}`}",
+                "                    output={outputs.ticketResult}",
+                "                    continueOnFail",
+                "                  >",
+                "                    {{",
+                "                      ticketId: ticket.id,",
+                "                      branch: `ticket/${ticket.slug}`,",
+                '                      status: "success",',
+                "                      summary: `Implemented ${ticket.slug}`,",
+                "                    }}",
+                "                  </Task>",
+                "                </Sequence>",
+                "              </Worktree>",
+                "            );",
+                "          })}",
+                "        </Parallel>",
+                "",
+                "        {/* Agent merges completed branches back into main */}",
+                '        <Task id="merge" output={outputs.merge} agent={agents.smart}>',
+                "          <MergeTicketsPrompt ticketSummary={ticketResults",
+                '            .map((r) => `- ${r.ticketId}: branch "${r.branch}" — ${r.status} (${r.summary})`)',
+                '            .join("\\n")} />',
+                "        </Task>",
+                "      </Sequence>",
+                "    </Workflow>",
+                "  );",
+                "});",
+                "",
+            ].join("\n"),
+        },
+    ];
+}
+/**
+ * @param {DependencyVersions} versions
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {TemplateFile[]}
+ */
+function renderTemplateFiles(versions, env) {
+    return [
+        {
+            path: ".smithers/.gitignore",
+            contents: ["node_modules/", "executions/", "runs/", "sandboxes/", "state/", "tmp/", "*.db", "*.sqlite", "dist/", ".DS_Store", ""].join("\n"),
+        },
+        {
+            path: ".smithers/package.json",
+            contents: renderPackageJson(versions),
+        },
+        {
+            path: ".smithers/tsconfig.json",
+            contents: renderTsconfig(),
+        },
+        {
+            path: ".smithers/bunfig.toml",
+            contents: ['preload = ["./preload.ts"]', ""].join("\n"),
+        },
+        {
+            path: ".smithers/preload.ts",
+            contents: ['import { mdxPlugin } from "smithers-orchestrator";', "", "mdxPlugin();", ""].join("\n"),
+        },
+        {
+            path: ".smithers/agents.ts",
+            contents: generateAgentsTs(env),
+        },
+        {
+            path: ".smithers/smithers.config.ts",
+            contents: [
+                "export const repoCommands = {",
+                "  lint: null,",
+                "  test: null,",
+                "  coverage: null,",
+                "} as const;",
+                "",
+                "export default { repoCommands };",
+                "",
+            ].join("\n"),
+        },
+        ...renderPrompts(),
+        ...renderComponents(),
+        ...renderWorkflows(),
+        {
+            path: ".smithers/tickets/.gitkeep",
+            contents: "",
+        },
+    ];
+}
+/**
+ * @param {InitOptions} [options]
+ * @returns {InitResult}
+ */
+export function initWorkflowPack(options = {}) {
+    const rootDir = resolve(options.rootDir ?? process.cwd(), ".smithers");
+    const writtenFiles = [];
+    const skippedFiles = [];
+    const preservedPaths = [];
+    const versions = readDependencyVersions();
+    const env = process.env;
+    ensureDir(rootDir);
+    ensureDir(resolve(rootDir, "prompts"));
+    ensureDir(resolve(rootDir, "components"));
+    ensureDir(resolve(rootDir, "workflows"));
+    ensureDir(resolve(rootDir, "tickets"));
+    const executionsDir = resolve(rootDir, "executions");
+    if (existsSync(executionsDir)) {
+        preservedPaths.push(executionsDir);
+    }
+    else {
+        ensureDir(executionsDir);
+    }
+    for (const file of renderTemplateFiles(versions, env)) {
+        const absolutePath = resolve(options.rootDir ?? process.cwd(), file.path);
+        ensureParent(absolutePath);
+        if (existsSync(absolutePath) && !options.force) {
+            skippedFiles.push(absolutePath);
+            continue;
+        }
+        writeFileSync(absolutePath, file.contents, "utf8");
+        writtenFiles.push(absolutePath);
+    }
+    return {
+        rootDir,
+        writtenFiles,
+        skippedFiles,
+        preservedPaths,
+    };
+}
+const WORKFLOW_FOLLOW_UPS = {
+    "research": [
+        { command: "workflow run write-a-prd", description: "Formalize findings into a PRD" },
+        { command: "workflow run plan", description: "Turn research into an implementation plan" },
+    ],
+    "plan": [
+        { command: "workflow run research-plan-implement", description: "Research, plan, and execute" },
+        { command: "workflow run implement", description: "Execute the plan" },
+        { command: "workflow run tickets-create", description: "Break plan into tickets" },
+        { command: "workflow run grill-me", description: "Stress-test the plan first" },
+    ],
+    "ticket-create": [
+        { command: "workflow run implement", description: "Implement the ticket" },
+        { command: "workflow run kanban", description: "Implement all tickets in parallel" },
+    ],
+    "tickets-create": [
+        { command: "workflow run implement", description: "Implement a ticket" },
+        { command: "workflow run kanban", description: "Implement all tickets in parallel" },
+    ],
+    "kanban": [
+        { command: "workflow run review", description: "Review the merged changes" },
+        { command: "workflow run improve-test-coverage", description: "Add tests for implemented tickets" },
+    ],
+    "grill-me": [
+        { command: "workflow run write-a-prd", description: "Turn shared understanding into a PRD" },
+        { command: "workflow run tickets-create", description: "Break directly into tickets" },
+    ],
+    "write-a-prd": [
+        { command: "workflow run tickets-create", description: "Break PRD into implementable tickets" },
+        { command: "workflow run plan", description: "Turn PRD into a phased plan" },
+        { command: "workflow run implement", description: "Start building from the PRD" },
+    ],
+    "debug": [
+        { command: "workflow run review", description: "Review the fix" },
+        { command: "workflow run improve-test-coverage", description: "Add regression tests" },
+    ],
+    "implement": [
+        { command: "workflow run review", description: "Review the changes" },
+        { command: "workflow run improve-test-coverage", description: "Improve test coverage" },
+    ],
+    "research-plan-implement": [
+        { command: "workflow run review", description: "Review the changes" },
+        { command: "workflow run improve-test-coverage", description: "Improve test coverage" },
+    ],
+    "review": [
+        { command: "workflow run implement", description: "Address review feedback" },
+    ],
+    "feature-enum": [
+        { command: "workflow run audit", description: "Audit all features" },
+        { command: "workflow run implement", description: "Implement missing features" },
+    ],
+    "audit": [
+        { command: "workflow run implement", description: "Address audit findings" },
+        { command: "workflow run tickets-create", description: "Create tickets from findings" },
+    ],
+};
+/**
+ * @param {string} workflowPath
+ * @returns {WorkflowCta[]}
+ */
+export function getWorkflowFollowUpCtas(workflowPath) {
+    const id = workflowPath
+        .replace(/^.*\//, "")
+        .replace(/\.(tsx?)$/, "");
+    return WORKFLOW_FOLLOW_UPS[id] ?? [];
+}