@smithers-orchestrator/cli 0.17.0 → 0.19.0

package/src/workflow-pack.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -19,6 +20,9 @@ import { generateAgentsTs } from "./agent-detection.js";
  * @typedef {{ path: string; contents: string; preserveExisting?: boolean; }} TemplateFile
  */
 
+const FALLBACK_SMITHERS_SPEC = "latest";
+const require = createRequire(import.meta.url);
+
 /**
  * @param {string} path
  */
@@ -50,26 +54,33 @@ function readPackageVersion(path, fallback) {
     }
 }
 /**
- * Resolve `<spec>/package.json` via Node's module resolution (from this file's
- * location) and return its `version`. Uses `import.meta.resolve` so it works
- * whether the CLI is running from the monorepo checkout (deps under
- * `apps/cli/node_modules/`) or installed flat under a user's project
- * `node_modules/`. Falls back to the pin bundled at release time when the
- * package isn't installed in the user's project (typical for devDep-only
- * specs like `typescript` and `@types/*`).
+ * Resolve an installed dependency version from the current package layout.
  *
- * @param {string} spec
+ * @param {string} specifier
  * @param {string} fallback
  */
-function resolveDependencyVersion(spec, fallback) {
+function resolveInstalledPackageVersion(specifier, fallback) {
     try {
-        const url = import.meta.resolve(`${spec}/package.json`);
-        return readPackageVersion(fileURLToPath(url), fallback);
+        const resolved = require.resolve(`${specifier}/package.json`);
+        return readPackageVersion(resolved, fallback);
     }
     catch {
         return fallback;
     }
 }
+/**
+ * @returns {string | undefined}
+ */
+function readOwnPackageVersion() {
+    try {
+        const ownPackagePath = fileURLToPath(new URL("../package.json", import.meta.url));
+        const version = readJson(ownPackagePath).version;
+        return typeof version === "string" && version.length > 0 ? version : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Pins shipped with this release for devDep-only specs that won't be in the
  * user's `node_modules` after `bunx smithers-orchestrator@latest init`. Bump
@@ -77,6 +88,8 @@ function resolveDependencyVersion(spec, fallback) {
  */
 const BUNDLED_VERSION_PINS = {
     zod: "4.3.6",
+    react: "19.2.5",
+    reactDom: "19.2.5",
     typescript: "5.9.3",
     reactTypes: "19.2.14",
     reactDomTypes: "19.2.3",
@@ -88,32 +101,40 @@ const BUNDLED_VERSION_PINS = {
  */
 function readDependencyVersions() {
     return {
-        smithersVersion: readPackageVersion(fileURLToPath(new URL("../package.json", import.meta.url)), "0.0.0"),
-        zodVersion: resolveDependencyVersion("zod", BUNDLED_VERSION_PINS.zod),
-        typescriptVersion: resolveDependencyVersion("typescript", BUNDLED_VERSION_PINS.typescript),
-        reactTypesVersion: resolveDependencyVersion("@types/react", BUNDLED_VERSION_PINS.reactTypes),
-        reactDomTypesVersion: resolveDependencyVersion("@types/react-dom", BUNDLED_VERSION_PINS.reactDomTypes),
-        mdxTypesVersion: resolveDependencyVersion("@types/mdx", BUNDLED_VERSION_PINS.mdxTypes),
-        nodeTypesVersion: resolveDependencyVersion("@types/node", BUNDLED_VERSION_PINS.nodeTypes),
+        smithersVersion: readOwnPackageVersion(),
+        zodVersion: resolveInstalledPackageVersion("zod", BUNDLED_VERSION_PINS.zod),
+        reactVersion: resolveInstalledPackageVersion("react", BUNDLED_VERSION_PINS.react),
+        reactDomVersion: resolveInstalledPackageVersion("react-dom", BUNDLED_VERSION_PINS.reactDom),
+        typescriptVersion: resolveInstalledPackageVersion("typescript", BUNDLED_VERSION_PINS.typescript),
+        reactTypesVersion: resolveInstalledPackageVersion("@types/react", BUNDLED_VERSION_PINS.reactTypes),
+        reactDomTypesVersion: resolveInstalledPackageVersion("@types/react-dom", BUNDLED_VERSION_PINS.reactDomTypes),
+        mdxTypesVersion: resolveInstalledPackageVersion("@types/mdx", BUNDLED_VERSION_PINS.mdxTypes),
+        nodeTypesVersion: resolveInstalledPackageVersion("@types/node", BUNDLED_VERSION_PINS.nodeTypes),
     };
 }
 /**
  * @param {DependencyVersions} versions
  */
 function renderPackageJson(versions) {
+    const smithersSpec = versions.smithersVersion
+        ? `^${versions.smithersVersion}`
+        : FALLBACK_SMITHERS_SPEC;
     return JSON.stringify({
         name: "smithers-workflows",
         private: true,
         type: "module",
         scripts: {
             typecheck: "tsc --noEmit",
+            gateway: "bun ./gateway.ts",
             "workflow:list": "smithers workflow list",
             "workflow:run": "smithers workflow run",
             "workflow:implement": "smithers workflow implement",
         },
         dependencies: {
+            react: versions.reactVersion,
+            "react-dom": versions.reactDomVersion,
             skills: "github:mattpocock/skills",
-            "smithers-orchestrator": "latest",
+            "smithers-orchestrator": smithersSpec,
             zod: versions.zodVersion,
         },
         devDependencies: {
@@ -590,6 +611,183 @@ function renderPrompts() {
                 "",
             ].join("\n"),
         },
+        {
+            path: ".smithers/prompts/mission-plan.mdx",
+            contents: [
+                "# Mission Plan",
+                "",
+                "You are the mission orchestrator for a long-running Smithers workflow.",
+                "Scope the goal with the user before execution. If critical requirements, constraints, or acceptance criteria are missing, ask one question at a time using the ask-user command from the instructions you were given.",
+                "",
+                "Design the mission as serial milestones with targeted parallelism inside each milestone.",
+                "Each milestone must be a meaningful checkpoint that can be validated before the next milestone begins.",
+                "Each feature should be narrow enough for a fresh worker session to execute without needing the full mission history.",
+                "Include explicit validation checks for every milestone: tests, lint/typecheck/build commands, integration checks, and UI/browser walkthroughs when the repo has an app surface.",
+                "Capture risks, assumptions, out-of-scope items, and anything the user should approve before work starts.",
+                "",
+                "REQUEST:",
+                "{props.prompt}",
+                "",
+                "LIMITS:",
+                "- Max milestones: {props.maxMilestones}",
+                "- Max features per milestone: {props.maxFeaturesPerMilestone}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/mission-worker.mdx",
+            contents: [
+                "# Mission Worker",
+                "",
+                "You are a focused feature worker in a larger mission. Treat this as a fresh context window: use the mission plan below, execute only your assigned feature, and keep handoff notes precise.",
+                "",
+                "Rules:",
+                "1. Stay within the assigned feature scope unless you must make a small adjacent change to keep the repo working.",
+                "2. Prefer existing repo patterns and run the most relevant checks you can.",
+                "3. Record files changed, commands run, unresolved issues, and reusable learnings for later workers.",
+                "4. If the feature cannot be completed, make the best safe partial progress and explain exactly what blocks it.",
+                "",
+                "MISSION GOAL:",
+                "{props.missionGoal}",
+                "",
+                "MILESTONE:",
+                "```json",
+                "{JSON.stringify(props.milestone, null, 2)}",
+                "```",
+                "",
+                "FEATURE:",
+                "```json",
+                "{JSON.stringify(props.feature, null, 2)}",
+                "```",
+                "",
+                "{props.previousSummary ? `PREVIOUS MILESTONE SUMMARY:\\n${props.previousSummary}` : \"\"}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/mission-integrate.mdx",
+            contents: [
+                "# Mission Integrate",
+                "",
+                "You are integrating feature-worker results for one milestone.",
+                "",
+                "{props.useWorktrees ? \"The feature work may live on per-feature worktree branches. Inspect the branches, merge successful work back into the main workspace, resolve conflicts carefully, and leave conflicted or unsafe branches unmerged with a clear explanation.\" : \"Feature workers ran in the main workspace. Inspect their results and make any small integration fixes needed before validation.\"}",
+                "",
+                "MISSION GOAL:",
+                "{props.missionGoal}",
+                "",
+                "MILESTONE:",
+                "```json",
+                "{JSON.stringify(props.milestone, null, 2)}",
+                "```",
+                "",
+                "FEATURE RESULTS:",
+                "```json",
+                "{JSON.stringify(props.results, null, 2)}",
+                "```",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/mission-validate.mdx",
+            contents: [
+                "# Mission Validate",
+                "",
+                "You are a validation worker for a mission milestone.",
+                "Validate accumulated work before the orchestrator moves to the next milestone.",
+                "",
+                "Run the strongest checks that fit the repo: tests, lint, typecheck, build, smoke tests, and integration checks.",
+                "If the repo has a UI, launch it and exercise core flows like a user would. Check render correctness, navigation, state transitions, and obvious layout regressions.",
+                "If a check cannot run because the repo lacks commands or setup, report that as a validation limitation instead of inventing results.",
+                "",
+                "MISSION GOAL:",
+                "{props.missionGoal}",
+                "",
+                "MILESTONE:",
+                "```json",
+                "{JSON.stringify(props.milestone, null, 2)}",
+                "```",
+                "",
+                "INTEGRATION RESULT:",
+                "```json",
+                "{JSON.stringify(props.integration, null, 2)}",
+                "```",
+                "",
+                "{props.followUp ? `FOLLOW-UP RESULT:\\n${JSON.stringify(props.followUp, null, 2)}` : \"\"}",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/mission-follow-up.mdx",
+            contents: [
+                "# Mission Follow-Up",
+                "",
+                "Validation found issues in the current milestone. Fix the concrete regressions and gaps before the mission proceeds.",
+                "Keep changes targeted. Do not begin the next milestone.",
+                "",
+                "MISSION GOAL:",
+                "{props.missionGoal}",
+                "",
+                "MILESTONE:",
+                "```json",
+                "{JSON.stringify(props.milestone, null, 2)}",
+                "```",
+                "",
+                "VALIDATION RESULT:",
+                "```json",
+                "{JSON.stringify(props.validation, null, 2)}",
+                "```",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
+        {
+            path: ".smithers/prompts/mission-final.mdx",
+            contents: [
+                "# Mission Final Report",
+                "",
+                "Write the final mission report. Summarize what shipped, what was validated, what remains risky, and the recommended next actions.",
+                "Be concrete about files, commands, validation gaps, and any milestone that did not pass validation.",
+                "",
+                "MISSION PLAN:",
+                "```json",
+                "{JSON.stringify(props.plan, null, 2)}",
+                "```",
+                "",
+                "FEATURE RESULTS:",
+                "```json",
+                "{JSON.stringify(props.featureResults, null, 2)}",
+                "```",
+                "",
+                "INTEGRATION RESULTS:",
+                "```json",
+                "{JSON.stringify(props.integrationResults, null, 2)}",
+                "```",
+                "",
+                "VALIDATION RESULTS:",
+                "```json",
+                "{JSON.stringify(props.validationResults, null, 2)}",
+                "```",
+                "",
+                "REQUIRED OUTPUT:",
+                "{props.schema}",
+                "",
+            ].join("\n"),
+        },
         {
             path: ".smithers/prompts/tickets-create.mdx",
             contents: [
@@ -1435,6 +1633,462 @@ function renderWorkflowFile(id, displayName, body) {
         ].join("\n"),
     };
 }
+function renderGatewayFile() {
+    return {
+        path: ".smithers/gateway.ts",
+        contents: [
+            'import { Gateway, mdxPlugin } from "smithers-orchestrator";',
+            'import { dirname, resolve } from "node:path";',
+            'import { fileURLToPath } from "node:url";',
+            "",
+            "mdxPlugin();",
+            "",
+            "const here = dirname(fileURLToPath(import.meta.url));",
+            "const projectRoot = resolve(here, \"..\");",
+            "process.chdir(projectRoot);",
+            "",
+            "const { default: kanban } = await import(\"./workflows/kanban.tsx\");",
+            "",
+            "const parsedPort = Number(process.env.PORT ?? \"7331\");",
+            "const port = Number.isInteger(parsedPort) && parsedPort > 0 ? parsedPort : 7331;",
+            "const host = process.env.HOST ?? \"127.0.0.1\";",
+            "",
+            "const gateway = new Gateway({ heartbeatMs: 15_000 });",
+            "",
+            "function registerWorkflow(key: string, workflow: any, options?: any) {",
+            "  gateway.register(key, workflow, options);",
+            "}",
+            "",
+            "registerWorkflow(\"kanban\", kanban, {",
+            "  ui: {",
+            "    entry: resolve(here, \"ui\", \"kanban.tsx\"),",
+            "    title: \"Kanban\",",
+            "  },",
+            "});",
+            "",
+            "await gateway.listen({ host, port });",
+            "console.log(\"Smithers Gateway listening on http://\" + host + \":\" + port);",
+            "console.log(\"Kanban UI mounted at http://\" + host + \":\" + port + \"/workflows/kanban\");",
+            "",
+        ].join("\n"),
+    };
+}
+function renderKanbanUiFile() {
+    return {
+        path: ".smithers/ui/kanban.tsx",
+        contents: [
+            "/** @jsxImportSource react */",
+            'import { useMemo, useState } from "react";',
+            "import {",
+            "  createGatewayReactRoot,",
+            "  useGatewayActions,",
+            "  useGatewayApprovals,",
+            "  useGatewayNodeOutput,",
+            "  useGatewayRunEvents,",
+            "  useGatewayRuns,",
+            '} from "smithers-orchestrator/gateway-react";',
+            "",
+            'const WORKFLOW_KEY = "kanban";',
+            "",
+            "type RunSummary = {",
+            "  runId: string;",
+            "  workflowKey?: string;",
+            "  status?: string;",
+            "  createdAtMs?: number;",
+            "  startedAtMs?: number;",
+            "};",
+            "",
+            'type BoardLane = "pending" | "in-progress" | "completed";',
+            'type TicketState = "pending" | "in-progress" | "finished" | "failed";',
+            "",
+            "type TicketSummary = {",
+            "  id: string;",
+            "  slug: string;",
+            "  title: string;",
+            "};",
+            "",
+            "type TicketView = {",
+            "  id: string;",
+            "  slug: string;",
+            "  title: string;",
+            "  lane: BoardLane;",
+            "  state: TicketState;",
+            "  events: number;",
+            "  currentStep?: string;",
+            "  nodeId?: string;",
+            "};",
+            "",
+            "const laneLabels: Record<BoardLane, string> = {",
+            '  pending: "Todo",',
+            '  "in-progress": "In Progress",',
+            '  completed: "Done",',
+            "};",
+            "",
+            "const laneOrder: BoardLane[] = [\"pending\", \"in-progress\", \"completed\"];",
+            "",
+            "const styles = [",
+            '  ":root { --bg: #0c0c0e; --panel: #151518; --card: #1c1c1f; --text: #eeeeee; --muted: #8a8a8e; --border: #262629; --primary: #5e6ad2; --success: #4ade80; --error: #f87171; --warning: #fbbf24; color-scheme: dark; font-family: -apple-system, BlinkMacSystemFont, \\"Segoe UI\\", Roboto, Helvetica, Arial, sans-serif; }",',
+            '  "* { box-sizing: border-box; -webkit-font-smoothing: antialiased; }",',
+            '  "body { margin: 0; background: var(--bg); color: var(--text); font-size: 13px; line-height: 1.4; }",',
+            '  "button, input { font: inherit; transition: all 0.1s ease; }",',
+            '  ".shell { height: 100vh; display: flex; flex-direction: column; overflow: hidden; }",',
+            '  ".topbar { display: flex; align-items: center; justify-content: space-between; padding: 12px 20px; border-bottom: 1px solid var(--border); background: var(--bg); z-index: 10; }",',
+            '  ".title-group { display: flex; align-items: center; gap: 12px; }",',
+            '  "h1 { margin: 0; font-size: 14px; font-weight: 600; }",',
+            '  ".run-indicator { display: flex; align-items: center; gap: 8px; font-size: 12px; color: var(--muted); background: var(--panel); padding: 4px 10px; border-radius: 6px; border: 1px solid var(--border); }",',
+            '  ".toolbar { display: flex; align-items: center; gap: 12px; }",',
+            '  ".field { display: flex; align-items: center; gap: 8px; }",',
+            '  ".field label { color: var(--muted); font-size: 11px; font-weight: 600; text-transform: uppercase; }",',
+            '  ".field input { width: 32px; border: 0; outline: none; color: var(--text); background: transparent; font-weight: 600; text-align: center; border-bottom: 1px solid var(--border); }",',
+            '  ".button { display: inline-flex; align-items: center; justify-content: center; border: 1px solid var(--border); border-radius: 6px; height: 28px; padding: 0 12px; background: var(--panel); color: var(--text); cursor: pointer; font-weight: 500; font-size: 12px; }",',
+            '  ".button:hover { background: var(--card); border-color: #3f3f46; }",',
+            '  ".button.primary { background: var(--primary); color: white; border-color: var(--primary); }",',
+            '  ".button.primary:hover { opacity: 0.9; }",',
+            '  ".button.danger { color: var(--error); }",',
+            '  ".button:disabled { opacity: 0.4; cursor: not-allowed; }",',
+            '  ".main { display: grid; grid-template-columns: 1fr 280px; flex: 1; overflow: hidden; }",',
+            '  ".board { display: grid; grid-template-columns: repeat(3, 1fr); background: var(--border); gap: 1px; overflow-x: auto; height: 100%; }",',
+            '  ".lane { background: var(--bg); display: flex; flex-direction: column; min-width: 300px; height: 100%; }",',
+            '  ".lane-head { display: flex; align-items: center; justify-content: space-between; padding: 14px 16px; position: sticky; top: 0; background: var(--bg); z-index: 5; }",',
+            '  ".lane-title-wrap { display: flex; align-items: center; gap: 8px; }",',
+            '  ".lane-title { font-weight: 600; font-size: 12px; }",',
+            '  ".count { color: var(--muted); font-size: 12px; }",',
+            '  ".status-circle { width: 14px; height: 14px; border: 1.5px solid var(--muted); border-radius: 50%; display: inline-block; position: relative; }",',
+            '  ".lane.in-progress .status-circle { border-color: var(--warning); border-left-color: transparent; }",',
+            '  ".lane.completed .status-circle { border-color: var(--primary); background: var(--primary); }",',
+            '  ".lane.completed .status-circle::after { content: \'\'; position: absolute; left: 3px; top: 1px; width: 4px; height: 7px; border: solid white; border-width: 0 1.5px 1.5px 0; transform: rotate(45deg); }",',
+            '  ".cards { padding: 8px; display: flex; flex-direction: column; gap: 4px; overflow-y: auto; flex: 1; }",',
+            '  ".ticket { background: var(--panel); border: 1px solid var(--border); border-radius: 6px; padding: 12px; display: flex; flex-direction: column; gap: 10px; transition: border-color 0.1s; }",',
+            '  ".ticket:hover { border-color: #3f3f46; }",',
+            '  ".ticket-id { font-family: monospace; font-size: 11px; color: var(--muted); }",',
+            '  ".ticket-title { font-size: 13px; font-weight: 500; color: var(--text); line-height: 1.4; }",',
+            '  ".ticket-meta { display: flex; align-items: center; gap: 8px; flex-wrap: wrap; }",',
+            '  ".pill { font-size: 10px; font-weight: 600; padding: 1px 6px; border-radius: 4px; background: #262629; color: var(--muted); border: 1px solid transparent; }",',
+            '  ".pill.active { border-color: rgba(94, 106, 210, 0.4); color: #8e96ff; background: rgba(94, 106, 210, 0.1); }",',
+            '  ".ticket-step { font-size: 11px; color: var(--muted); display: flex; align-items: center; gap: 6px; }",',
+            '  ".dot { width: 6px; height: 6px; border-radius: 50%; background: var(--border); }",',
+            '  ".ticket.in-progress .dot { background: var(--warning); box-shadow: 0 0 6px var(--warning); }",',
+            '  ".ticket.failed .dot { background: var(--error); }",',
+            '  ".ticket.finished .dot { background: var(--success); }",',
+            '  ".sidebar { border-left: 1px solid var(--border); display: flex; flex-direction: column; background: var(--bg); overflow: hidden; }",',
+            '  ".side-block { display: flex; flex-direction: column; flex: 1; overflow: hidden; border-bottom: 1px solid var(--border); }",',
+            '  ".side-head { padding: 12px 16px; border-bottom: 1px solid var(--border); }",',
+            '  ".side-head h2 { margin: 0; font-size: 11px; font-weight: 700; text-transform: uppercase; letter-spacing: 0.05em; color: var(--muted); }",',
+            '  ".side-list { overflow-y: auto; padding: 8px; display: flex; flex-direction: column; gap: 2px; }",',
+            '  ".run-btn { display: flex; flex-direction: column; gap: 4px; padding: 8px 10px; border-radius: 6px; cursor: pointer; border: 1px solid transparent; text-align: left; background: transparent; width: 100%; color: inherit; }",',
+            '  ".run-btn:hover { background: var(--panel); }",',
+            '  ".run-btn.selected { background: var(--panel); border-color: var(--border); }",',
+            '  ".run-info { display: flex; align-items: center; justify-content: space-between; }",',
+            '  ".run-name { font-family: monospace; font-weight: 600; font-size: 12px; }",',
+            '  ".run-time { font-size: 11px; color: var(--muted); }",',
+            '  ".approval-box { padding: 10px; border: 1px solid var(--border); border-radius: 6px; background: var(--panel); margin-bottom: 8px; display: flex; flex-direction: column; gap: 8px; }",',
+            '  ".approval-txt { font-weight: 600; font-size: 12px; }",',
+            '  ".approval-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 6px; }",',
+            '  ".empty { flex: 1; display: flex; align-items: center; justify-content: center; color: var(--muted); font-size: 12px; font-style: italic; opacity: 0.5; }",',
+            '  ".toast { position: fixed; bottom: 24px; left: 50%; transform: translateX(-50%); padding: 8px 16px; border-radius: 8px; background: var(--card); border: 1px solid var(--border); box-shadow: 0 8px 24px rgba(0,0,0,0.5); display: flex; align-items: center; gap: 12px; z-index: 100; font-size: 12px; font-weight: 500; }",',
+            '  ".error-msg { color: var(--error); }",',
+            '].join(\"\\n\");',
+            "",
+            "function isRecord(value: unknown): value is Record<string, unknown> {",
+            "  return typeof value === \"object\" && value !== null;",
+            "}",
+            "",
+            "function asString(value: unknown): string | undefined {",
+            "  return typeof value === \"string\" ? value : undefined;",
+            "}",
+            "",
+            "function asNumber(value: unknown): number | undefined {",
+            "  return typeof value === \"number\" && Number.isFinite(value) ? value : undefined;",
+            "}",
+            "",
+            "function shortRunId(runId: string | undefined) {",
+            "  return runId ? runId.slice(0, 8) : \"none\";",
+            "}",
+            "",
+            "function formatTime(ms: number | undefined) {",
+            "  if (!ms) return \"--\";",
+            "  const d = new Date(ms);",
+            "  return d.toLocaleDateString([], { month: \'short\', day: \'numeric\' }) + \" \" + d.toLocaleTimeString([], { hour: \'2-digit\', minute: \'2-digit\' });",
+            "}",
+            "",
+            "function titleFromSlug(slug: string) {",
+            "  return slug",
+            "    .replace(/__/g, \" / \")",
+            "    .replace(/[-_]+/g, \" \")",
+            "    .replace(/\\b\\w/g, (letter) => letter.toUpperCase());",
+            "}",
+            "",
+            "function extractDiscoveredTickets(value: unknown): TicketSummary[] {",
+            "  const response = isRecord(value) ? value : {};",
+            "  const row = isRecord(response.row) ? response.row : {};",
+            "  const rawTickets = Array.isArray(row.tickets) ? row.tickets : [];",
+            "  return rawTickets.flatMap((ticket): TicketSummary[] => {",
+            "    if (!isRecord(ticket)) return [];",
+            "    const slug = asString(ticket.slug);",
+            "    const id = asString(ticket.id) ?? (slug ? slug + \".md\" : undefined);",
+            "    if (!slug || !id) return [];",
+            "    return [{ id, slug, title: asString(ticket.title) ?? titleFromSlug(slug) }];",
+            "  });",
+            "}",
+            "",
+            "function parseTicketNode(nodeId: string): { slug: string; step: string; result: boolean } | null {",
+            "  if (nodeId.startsWith(\"result-\")) {",
+            "    const slug = nodeId.slice(\"result-\".length);",
+            "    return slug ? { slug, step: \"result\", result: true } : null;",
+            "  }",
+            "  const [slug, step] = nodeId.split(\":\");",
+            "  if (!slug || slug === \"tickets\" || slug === \"merge\" || step === \"loop\") return null;",
+            "  return { slug, step: step ?? \"process\", result: false };",
+            "}",
+            "",
+            "function stepLabel(step: string) {",
+            "  if (step === \"implement\") return \"Implementing\";",
+            "  if (step === \"validate\") return \"Validating\";",
+            "  if (step === \"review\") return \"Reviewing\";",
+            "  if (step === \"result\") return \"Done\";",
+            "  return titleFromSlug(step);",
+            "}",
+            "",
+            "function collectStreamEvents(events: Array<Record<string, unknown>>) {",
+            "  return events",
+            "    .map((frame) => (isRecord(frame.payload) ? frame.payload : frame))",
+            "    .filter((frame): frame is Record<string, unknown> => isRecord(frame));",
+            "}",
+            "",
+            "function deriveTickets(discovered: TicketSummary[], events: Array<Record<string, unknown>>): TicketView[] {",
+            "  const tickets = new Map<string, TicketView>();",
+            "  for (const ticket of discovered) {",
+            "    tickets.set(ticket.slug, {",
+            "      id: ticket.id,",
+            "      slug: ticket.slug,",
+            "      title: ticket.title,",
+            "      lane: \"pending\",",
+            "      state: \"pending\",",
+            "      events: 0,",
+            "      currentStep: \"Backlog\",",
+            "    });",
+            "  }",
+            "  for (const event of events) {",
+            "    const eventName = asString(event.event);",
+            "    if (eventName !== \"node.started\" && eventName !== \"node.finished\" && eventName !== \"node.failed\") continue;",
+            "    const payload = isRecord(event.payload) ? event.payload : {};",
+            "    const nodeId = asString(payload.nodeId);",
+            "    if (!nodeId) continue;",
+            "    const parsed = parseTicketNode(nodeId);",
+            "    if (!parsed) continue;",
+            "    const existing = tickets.get(parsed.slug) ?? {",
+            "      id: parsed.slug + \".md\",",
+            "      slug: parsed.slug,",
+            "      title: titleFromSlug(parsed.slug),",
+            "      lane: \"pending\" as BoardLane,",
+            "      state: \"pending\" as TicketState,",
+            "      events: 0,",
+            "    };",
+            "    if (eventName === \"node.failed\") {",
+            "      existing.lane = \"completed\";",
+            "      existing.state = \"failed\";",
+            "      existing.currentStep = \"Failed: \" + stepLabel(parsed.step);",
+            "    } else if (parsed.result && eventName === \"node.finished\") {",
+            "      existing.lane = \"completed\";",
+            "      existing.state = \"finished\";",
+            "      existing.currentStep = \"Completed\";",
+            "    } else {",
+            "      existing.lane = existing.lane === \"completed\" ? existing.lane : \"in-progress\";",
+            "      existing.state = existing.state === \"failed\" || existing.state === \"finished\" ? existing.state : \"in-progress\";",
+            "      existing.currentStep = stepLabel(parsed.step);",
+            "    }",
+            "    existing.nodeId = nodeId;",
+            "    existing.events += 1;",
+            "    tickets.set(parsed.slug, existing);",
+            "  }",
+            "  return Array.from(tickets.values()).sort((left, right) => left.title.localeCompare(right.title));",
+            "}",
+            "",
+            "function App() {",
+            "  const [maxConcurrency, setMaxConcurrency] = useState(3);",
+            "  const [selectedRunId, setSelectedRunId] = useState<string>();",
+            "  const [busy, setBusy] = useState(false);",
+            "  const [message, setMessage] = useState(\"\");",
+            "  const [showMsg, setShowMsg] = useState(false);",
+            "  const runs = useGatewayRuns({ filter: { limit: 20 } });",
+            "  const approvals = useGatewayApprovals({ filter: { workflow: WORKFLOW_KEY, limit: 10 } });",
+            "  const actions = useGatewayActions();",
+            "",
+            "  const kanbanRuns = useMemo(() => {",
+            "    return ((runs.data ?? []) as RunSummary[]).filter((run) => !run.workflowKey || run.workflowKey === WORKFLOW_KEY);",
+            "  }, [runs.data]);",
+            "  const activeRunId = selectedRunId ?? kanbanRuns[0]?.runId;",
+            "  const activeRun = kanbanRuns.find((run) => run.runId === activeRunId);",
+            "  const stream = useGatewayRunEvents(activeRunId, { afterSeq: 0 });",
+            "  const ticketsOutput = useGatewayNodeOutput({ runId: activeRunId, nodeId: \"tickets\", iteration: 0 });",
+            "  const streamEvents = useMemo(() => {",
+            "    return collectStreamEvents(stream.events as Array<Record<string, unknown>>)",
+            "      .filter((event) => !activeRunId || asString(event.runId) === activeRunId);",
+            "  }, [activeRunId, stream.events]);",
+            "  const discoveredTickets = useMemo(() => extractDiscoveredTickets(ticketsOutput.data), [ticketsOutput.data]);",
+            "  const tickets = useMemo(() => deriveTickets(discoveredTickets, streamEvents), [discoveredTickets, streamEvents]);",
+            "  const pendingApprovals = approvals.data ?? [];",
+            "  const ticketsByLane = useMemo(() => {",
+            "    const grouped: Record<BoardLane, TicketView[]> = { pending: [], \"in-progress\": [], completed: [] };",
+            "    for (const ticket of tickets) grouped[ticket.lane].push(ticket);",
+            "    return grouped;",
+            "  }, [tickets]);",
+            "",
+            "  function notify(msg: string) {",
+            "    setMessage(msg);",
+            "    setShowMsg(true);",
+            "    setTimeout(() => setShowMsg(false), 3000);",
+            "  }",
+            "",
+            "  async function refresh() {",
+            "    await Promise.all([runs.refetch(), approvals.refetch(), ticketsOutput.refetch()]);",
+            "  }",
+            "",
+            "  async function launch() {",
+            "    setBusy(true);",
+            "    try {",
+            "      const run = await actions.launchRun({ workflow: WORKFLOW_KEY, input: { maxConcurrency } });",
+            "      setSelectedRunId(run.runId);",
+            "      notify(\"Launched \" + shortRunId(run.runId));",
+            "      await refresh();",
+            "    } catch (e) { notify(String(e)); } finally { setBusy(false); }",
+            "  }",
+            "",
+            "  async function cancelRun() {",
+            "    if (!activeRunId) return;",
+            "    setBusy(true);",
+            "    try {",
+            "      await actions.cancelRun({ runId: activeRunId });",
+            "      notify(\"Cancelled run\");",
+            "      await refresh();",
+            "    } catch (e) { notify(String(e)); } finally { setBusy(false); }",
+            "  }",
+            "",
+            "  async function decide(approval: (typeof pendingApprovals)[number], ok: boolean) {",
+            "    setBusy(true);",
+            "    try {",
+            "      await actions.submitApproval({",
+            "        runId: approval.runId, nodeId: approval.nodeId, iteration: approval.iteration,",
+            "        decision: { approved: ok, note: (ok ? \'Approved\' : \'Denied\') + \' via UI\' }",
+            "      });",
+            "      notify(ok ? \'Approved\' : \'Denied\');",
+            "      await refresh();",
+            "    } catch (e) { notify(String(e)); } finally { setBusy(false); }",
+            "  }",
+            "",
+            "  const hasError = !!(stream.error || ticketsOutput.error);",
+            "",
+            "  return (",
+            "    <main className=\"shell\">",
+            "      <style>{styles}</style>",
+            "      <header className=\"topbar\">",
+            "        <div className=\"title-group\">",
+            "          <h1>Kanban</h1>",
+            "          <div className=\"run-indicator\">",
+            "            <div className=\"status-circle\" style={{ border: \'1.5px solid var(--primary)\', background: activeRun?.status === \'running\' ? \'var(--primary)\' : \'transparent\' }}></div>",
+            "            <span>{activeRunId ? shortRunId(activeRunId) : \'No Run\'}</span>",
+            "            <span style={{ color: activeRun?.status === \'running\' ? \'var(--warning)\' : \'var(--muted)\', fontWeight: 600 }}>",
+            "              {activeRun?.status ?? \'Idle\'}",
+            "            </span>",
+            "          </div>",
+            "        </div>",
+            "        <div className=\"toolbar\">",
+            "          <div className=\"field\">",
+            "            <label>Limit</label>",
+            "            <input",
+            "              type=\"number\" min={1} max={10} value={maxConcurrency}",
+            "              onChange={(e) => setMaxConcurrency(Math.max(1, Number(e.currentTarget.value) || 1))}",
+            "            />",
+            "          </div>",
+            "          <button className=\"button\" onClick={() => void refresh()} disabled={busy}>Refresh</button>",
+            "          {activeRun?.status === \"running\" && (",
+            "            <button className=\"button danger\" onClick={() => void cancelRun()} disabled={busy}>Cancel</button>",
+            "          )}",
+            "          <button className=\"button primary\" onClick={() => void launch()} disabled={busy}>Launch Run</button>",
+            "        </div>",
+            "      </header>",
+            "",
+            "      <div className=\"main\">",
+            "        <div className=\"board\">",
+            "          {laneOrder.map((lane) => (",
+            "            <section className={\"lane \" + lane} key={lane}>",
+            "              <div className=\"lane-head\">",
+            "                <div className=\"lane-title-wrap\">",
+            "                  <div className=\"status-circle\"></div>",
+            "                  <div className=\"lane-title\">{laneLabels[lane]}</div>",
+            "                  <div className=\"count\">{ticketsByLane[lane].length}</div>",
+            "                </div>",
+            "              </div>",
+            "              <div className=\"cards\">",
+            "                {ticketsByLane[lane].map((t) => (",
+            "                  <article className={\"ticket \" + t.state} key={t.slug}>",
+            "                    <span className=\"ticket-id\">{t.slug.slice(0, 12).toUpperCase()}</span>",
+            "                    <div className=\"ticket-title\">{t.title}</div>",
+            "                    <div className=\"ticket-meta\">",
+            "                      <div className=\"ticket-step\">",
+            "                        <div className=\"dot\"></div>",
+            "                        <span>{t.currentStep ?? t.state}</span>",
+            "                      </div>",
+            "                      <div className={\"pill \" + (t.state === \'in-progress\' ? \'active\' : \'\')}>{t.events} Events</div>",
+            "                    </div>",
+            "                  </article>",
+            "                ))}",
+            "                {ticketsByLane[lane].length === 0 && <div className=\"empty\">Empty</div>}",
+            "              </div>",
+            "            </section>",
+            "          ))}",
+            "        </div>",
+            "",
+            "        <aside className=\"sidebar\">",
+            "          <section className=\"side-block\">",
+            "            <div className=\"side-head\"><h2>Recent Runs</h2></div>",
+            "            <div className=\"side-list\">",
+            "              {kanbanRuns.map((r) => (",
+            "                <button",
+            "                  key={r.runId} className={\"run-btn \" + (r.runId === activeRunId ? \'selected\' : \'\')}",
+            "                  onClick={() => setSelectedRunId(r.runId)}",
+            "                >",
+            "                  <div className=\"run-info\">",
+            "                    <span className=\"run-name\">{shortRunId(r.runId)}</span>",
+            "                    <div className=\"pill\">{r.status}</div>",
+            "                  </div>",
+            "                  <span className=\"run-time\">{formatTime(asNumber(r.startedAtMs) ?? asNumber(r.createdAtMs))}</span>",
+            "                </button>",
+            "              ))}",
+            "            </div>",
+            "          </section>",
+            "          <section className=\"side-block\" style={{ flex: 1.5 }}>",
+            "            <div className=\"side-head\"><h2>Approvals</h2></div>",
+            "            <div className=\"side-list\">",
+            "              {pendingApprovals.map((a) => (",
+            "                <div className=\"approval-box\" key={a.runId + a.nodeId + a.iteration}>",
+            "                  <div className=\"approval-txt\">{a.requestTitle ?? a.nodeId}</div>",
+            "                  <div className=\"approval-grid\">",
+            "                    <button className=\"button\" onClick={() => void decide(a, false)} disabled={busy}>Deny</button>",
+            "                    <button className=\"button primary\" onClick={() => void decide(a, true)} disabled={busy}>Approve</button>",
+            "                  </div>",
+            "                </div>",
+            "              ))}",
+            "              {pendingApprovals.length === 0 && <div className=\"empty\">All clear</div>}",
+            "            </div>",
+            "          </section>",
+            "        </aside>",
+            "      </div>",
+            "",
+            "      {showMsg && (",
+            "        <div className=\"toast\">",
+            "          <div className={hasError ? \"error-msg\" : \"\"}>{stream.error?.message ?? ticketsOutput.error?.message ?? message}</div>",
+            "        </div>",
+            "      )}",
+            "    </main>",
+            "  );",
+            "}",
+            "",
+            "createGatewayReactRoot(<App />);",
+            "",
+        ].join("\n"),
+    };
+}
 /**
  * @returns {TemplateFile[]}
  */
@@ -1450,7 +2104,12 @@ function renderWorkflows() {
             'import { ValidationLoop, implementOutputSchema, validateOutputSchema } from "../components/ValidationLoop";',
             'import { reviewOutputSchema } from "../components/Review";',
             "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Implement the requested change."),',
+            "});",
+            "",
             "const { Workflow, smithers } = createSmithers({",
+            "  input: inputSchema,",
             "  implement: implementOutputSchema,",
             "  validate: validateOutputSchema,",
             "  review: reviewOutputSchema,",
@@ -1974,6 +2633,440 @@ function renderWorkflows() {
             "  </Workflow>",
             "));",
         ]),
+        renderWorkflowFile("mission", "Mission", [
+            ...sharedImports,
+            'import AskUserInstructions from "../prompts/ask-user-instructions.mdx";',
+            'import MissionPlanPrompt from "../prompts/mission-plan.mdx";',
+            'import MissionWorkerPrompt from "../prompts/mission-worker.mdx";',
+            'import MissionIntegratePrompt from "../prompts/mission-integrate.mdx";',
+            'import MissionValidatePrompt from "../prompts/mission-validate.mdx";',
+            'import MissionFollowUpPrompt from "../prompts/mission-follow-up.mdx";',
+            'import MissionFinalPrompt from "../prompts/mission-final.mdx";',
+            "",
+            "const missionFeatureSchema = z.looseObject({",
+            '  id: z.string().default("feature"),',
+            '  title: z.string().default("Feature"),',
+            '  instructions: z.string().default("Complete the assigned feature."),',
+            "  files: z.array(z.string()).default([]),",
+            "  validation: z.array(z.string()).default([]),",
+            '  workerType: z.enum(["implementation", "test", "docs", "research"]).default("implementation"),',
+            "  canRunInParallel: z.boolean().default(true),",
+            "});",
+            "",
+            "const missionMilestoneSchema = z.looseObject({",
+            '  id: z.string().default("milestone"),',
+            '  title: z.string().default("Milestone"),',
+            '  objective: z.string().default("Complete this milestone."),',
+            "  features: z.array(missionFeatureSchema).default([]),",
+            "  validationPlan: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const missionPlanSchema = z.looseObject({",
+            '  goal: z.string().default(""),',
+            '  summary: z.string().default("Mission plan created."),',
+            "  milestones: z.array(missionMilestoneSchema).default([]),",
+            "  assumptions: z.array(z.string()).default([]),",
+            "  risks: z.array(z.string()).default([]),",
+            "  outOfScope: z.array(z.string()).default([]),",
+            '  approvalNotes: z.string().nullable().default(null),',
+            "});",
+            "",
+            "const missionApprovalSchema = z.looseObject({",
+            "  approved: z.boolean().default(false),",
+            "  note: z.string().nullable().default(null),",
+            "  decidedBy: z.string().nullable().default(null),",
+            "  decidedAt: z.string().nullable().default(null),",
+            "});",
+            "",
+            "const missionFeatureResultSchema = z.looseObject({",
+            '  featureId: z.string().default("feature"),',
+            '  status: z.enum(["success", "partial", "failed"]).default("partial"),',
+            '  summary: z.string().default("Feature worker completed."),',
+            "  filesChanged: z.array(z.string()).default([]),",
+            "  commandsRun: z.array(z.string()).default([]),",
+            "  blockers: z.array(z.string()).default([]),",
+            "  reusableLearnings: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const milestoneIntegrationSchema = z.looseObject({",
+            '  milestoneId: z.string().default("milestone"),',
+            '  status: z.enum(["integrated", "partial", "blocked"]).default("integrated"),',
+            '  summary: z.string().default("Milestone integrated."),',
+            "  mergedBranches: z.array(z.string()).default([]),",
+            "  conflictedBranches: z.array(z.string()).default([]),",
+            "  filesChanged: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const milestoneValidationSchema = z.looseObject({",
+            '  milestoneId: z.string().default("milestone"),',
+            "  passed: z.boolean().default(true),",
+            '  summary: z.string().default("Validation completed."),',
+            "  checks: z.array(z.object({",
+            "    name: z.string(),",
+            '    status: z.enum(["passed", "failed", "skipped"]),',
+            "    details: z.string().nullable().default(null),",
+            "  })).default([]),",
+            "  regressions: z.array(z.string()).default([]),",
+            "  followUps: z.array(z.string()).default([]),",
+            "});",
+            "",
+            "const missionFinalSchema = z.looseObject({",
+            '  status: z.enum(["completed", "partial", "cancelled"]).default("completed"),',
+            '  summary: z.string().default("Mission complete."),',
+            "  completedMilestones: z.number().int().default(0),",
+            "  totalMilestones: z.number().int().default(0),",
+            "  validationPassed: z.boolean().default(true),",
+            "  remainingRisks: z.array(z.string()).default([]),",
+            "  nextActions: z.array(z.string()).default([]),",
+            "  markdownBody: z.string().default(\"\"),",
+            "});",
+            "",
+            "const inputSchema = z.object({",
+            '  prompt: z.string().default("Describe the mission goal."),',
+            "  requirePlanApproval: z.boolean().default(true),",
+            "  maxMilestones: z.number().int().min(1).max(20).default(6),",
+            "  maxFeaturesPerMilestone: z.number().int().min(1).max(20).default(6),",
+            "  maxConcurrency: z.number().int().min(1).max(10).default(3),",
+            "  useWorktrees: z.boolean().default(false),",
+            '  baseBranch: z.string().default("main"),',
+            "});",
+            "",
+            "const { Workflow, Task, Sequence, Parallel, Approval, Worktree, smithers, outputs } = createSmithers({",
+            "  input: inputSchema,",
+            "  missionPlan: missionPlanSchema,",
+            "  missionApproval: missionApprovalSchema,",
+            "  missionFeature: missionFeatureResultSchema,",
+            "  milestoneIntegration: milestoneIntegrationSchema,",
+            "  milestoneValidation: milestoneValidationSchema,",
+            "  missionFinal: missionFinalSchema,",
+            "});",
+            "",
+            'const missionMemory = { kind: "workflow", id: "mission" } as const;',
+            "",
+            "function slugify(value: unknown, fallback: string): string {",
+            '  const normalized = String(value ?? "")',
+            "    .toLowerCase()",
+            '    .replace(/[^a-z0-9]+/g, "-")',
+            '    .replace(/^-+|-+$/g, "");',
+            "  return normalized.length > 0 ? normalized : fallback;",
+            "}",
+            "",
+            "function asStringArray(value: unknown): string[] {",
+            "  return Array.isArray(value) ? value.map((entry) => String(entry)).filter(Boolean) : [];",
+            "}",
+            "",
+            "function normalizeFeature(feature: any, index: number): any {",
+            "  const title = typeof feature?.title === \"string\" && feature.title.length > 0",
+            "    ? feature.title",
+            "    : `Feature ${index + 1}`;",
+            "  return {",
+            "    id: slugify(feature?.id ?? title, `feature-${index + 1}`),",
+            "    title,",
+            "    instructions: typeof feature?.instructions === \"string\" && feature.instructions.length > 0",
+            "      ? feature.instructions",
+            "      : `Complete ${title}.`,",
+            "    files: asStringArray(feature?.files),",
+            "    validation: asStringArray(feature?.validation),",
+            "    workerType: [\"implementation\", \"test\", \"docs\", \"research\"].includes(feature?.workerType)",
+            "      ? feature.workerType",
+            '      : "implementation",',
+            "    canRunInParallel: feature?.canRunInParallel !== false,",
+            "  };",
+            "}",
+            "",
+            "function normalizeMilestones(plan: any, maxMilestones: number, maxFeaturesPerMilestone: number): any[] {",
+            "  return (Array.isArray(plan?.milestones) ? plan.milestones : [])",
+            "    .slice(0, maxMilestones)",
+            "    .map((milestone: any, index: number) => {",
+            "      const title = typeof milestone?.title === \"string\" && milestone.title.length > 0",
+            "        ? milestone.title",
+            "        : `Milestone ${index + 1}`;",
+            "      const features = (Array.isArray(milestone?.features) ? milestone.features : [])",
+            "        .slice(0, maxFeaturesPerMilestone)",
+            "        .map((feature: any, featureIndex: number) => normalizeFeature(feature, featureIndex));",
+            "      return {",
+            "        id: slugify(milestone?.id ?? title, `milestone-${index + 1}`),",
+            "        title,",
+            "        objective: typeof milestone?.objective === \"string\" && milestone.objective.length > 0",
+            "          ? milestone.objective",
+            "          : title,",
+            "        validationPlan: asStringArray(milestone?.validationPlan),",
+            "        features: features.length > 0",
+            "          ? features",
+            "          : [normalizeFeature({ title, instructions: milestone?.objective ?? title }, 0)],",
+            "      };",
+            "    });",
+            "}",
+            "",
+            "function featureTaskId(milestoneIndex: number, feature: any): string {",
+            "  return `mission:milestone:${milestoneIndex + 1}:feature:${feature.id}`;",
+            "}",
+            "",
+            "function milestoneIntegrateId(milestoneIndex: number): string {",
+            "  return `mission:milestone:${milestoneIndex + 1}:integrate`;",
+            "}",
+            "",
+            "function milestoneValidationId(milestoneIndex: number): string {",
+            "  return `mission:milestone:${milestoneIndex + 1}:validate`;",
+            "}",
+            "",
+            "function milestoneFollowUpId(milestoneIndex: number): string {",
+            "  return `mission:milestone:${milestoneIndex + 1}:follow-up`;",
+            "}",
+            "",
+            "function milestoneRevalidationId(milestoneIndex: number): string {",
+            "  return `mission:milestone:${milestoneIndex + 1}:revalidate`;",
+            "}",
+            "",
+            "function featureNeeds(milestoneIndex: number, features: any[]): Record<string, string> {",
+            "  return Object.fromEntries(features.map((feature, index) => [`feature${index}`, featureTaskId(milestoneIndex, feature)]));",
+            "}",
+            "",
+            "function featureDeps(features: any[]): Record<string, typeof missionFeatureResultSchema> {",
+            "  return Object.fromEntries(features.map((_, index) => [`feature${index}`, outputs.missionFeature]));",
+            "}",
+            "",
+            "function workerAgentsFor(feature: any): any {",
+            "  if (feature.workerType === \"research\") return agents.smartTool;",
+            "  if (feature.workerType === \"docs\") return agents.cheapFast;",
+            "  return agents.smart;",
+            "}",
+            "",
+            "function previousMilestoneSummary(ctx: any): string {",
+            "  const integrations = ctx.outputs.milestoneIntegration ?? [];",
+            "  const validations = ctx.outputs.milestoneValidation ?? [];",
+            "  return [",
+            "    ...integrations.map((entry: any) => `Integration: ${entry.summary}`),",
+            "    ...validations.map((entry: any) => `Validation: ${entry.passed ? \"passed\" : \"failed\"} - ${entry.summary}`),",
+            "  ].slice(-8).join(\"\\n\");",
+            "}",
+            "",
+            "function milestoneIsTerminal(ctx: any, milestoneIndex: number): boolean {",
+            "  const revalidation = ctx.outputMaybe(\"milestoneValidation\", { nodeId: milestoneRevalidationId(milestoneIndex) });",
+            "  if (revalidation) return true;",
+            "  const validation = ctx.outputMaybe(\"milestoneValidation\", { nodeId: milestoneValidationId(milestoneIndex) });",
+            "  return Boolean(validation && validation.passed !== false);",
+            "}",
+            "",
+            "function activeMilestoneIndex(ctx: any, milestones: any[]): number {",
+            "  for (let index = 0; index < milestones.length; index += 1) {",
+            "    if (!milestoneIsTerminal(ctx, index)) return index;",
+            "  }",
+            "  return milestones.length;",
+            "}",
+            "",
+            "function renderFeatureWorker(ctx: any, plan: any, milestone: any, milestoneIndex: number, feature: any) {",
+            "  const taskId = featureTaskId(milestoneIndex, feature);",
+            "  const workerTask = (",
+            "    <Task",
+            "      key={taskId}",
+            "      id={taskId}",
+            "      output={outputs.missionFeature}",
+            "      agent={workerAgentsFor(feature)}",
+            "      timeoutMs={3_600_000}",
+            "      heartbeatTimeoutMs={900_000}",
+            "      continueOnFail",
+            "      memory={{",
+            "        recall: { namespace: missionMemory, query: `${plan.goal} ${milestone.title} ${feature.title}`, topK: 5 },",
+            "        remember: { namespace: missionMemory, key: taskId },",
+            "      }}",
+            "    >",
+            "      <MissionWorkerPrompt",
+            "        missionGoal={plan.goal || ctx.input.prompt}",
+            "        milestone={milestone}",
+            "        feature={feature}",
+            "        previousSummary={previousMilestoneSummary(ctx)}",
+            "      />",
+            "    </Task>",
+            "  );",
+            "",
+            "  if (!(ctx.input.useWorktrees ?? false)) return workerTask;",
+            "",
+            "  return (",
+            "    <Worktree",
+            "      key={taskId}",
+            "      id={`mission-worktree-${milestoneIndex + 1}-${feature.id}`}",
+            "      path={`.worktrees/mission-${milestoneIndex + 1}-${feature.id}`}",
+            "      branch={`mission/${milestoneIndex + 1}/${feature.id}`}",
+            "      baseBranch={ctx.input.baseBranch ?? \"main\"}",
+            "    >",
+            "      {workerTask}",
+            "    </Worktree>",
+            "  );",
+            "}",
+            "",
+            "function renderMilestone(ctx: any, plan: any, milestone: any, milestoneIndex: number) {",
+            "  const features = milestone.features;",
+            "  const integrationId = milestoneIntegrateId(milestoneIndex);",
+            "  const validationId = milestoneValidationId(milestoneIndex);",
+            "  const integration = ctx.outputMaybe(\"milestoneIntegration\", { nodeId: integrationId });",
+            "  const validation = ctx.outputMaybe(\"milestoneValidation\", { nodeId: validationId });",
+            "  const needsFollowUp = Boolean(validation && validation.passed === false);",
+            "",
+            "  return (",
+            "    <Sequence>",
+            "      <Parallel maxConcurrency={Math.min(ctx.input.maxConcurrency ?? 3, features.length)}>",
+            "        {features.map((feature: any) => renderFeatureWorker(ctx, plan, milestone, milestoneIndex, feature))}",
+            "      </Parallel>",
+            "      <Task",
+            "        id={integrationId}",
+            "        output={outputs.milestoneIntegration}",
+            "        agent={agents.smartTool}",
+            "        needs={featureNeeds(milestoneIndex, features)}",
+            "        deps={featureDeps(features)}",
+            "        timeoutMs={1_800_000}",
+            "        memory={{ remember: { namespace: missionMemory, key: integrationId } }}",
+            "      >",
+            "        {(deps: any) => {",
+            "          const results = features.map((_: any, index: number) => deps[`feature${index}`]);",
+            "          return (",
+            "            <MissionIntegratePrompt",
+            "              missionGoal={plan.goal || ctx.input.prompt}",
+            "              milestone={milestone}",
+            "              results={results}",
+            "              useWorktrees={ctx.input.useWorktrees ?? false}",
+            "            />",
+            "          );",
+            "        }}",
+            "      </Task>",
+            "      <Task",
+            "        id={validationId}",
+            "        output={outputs.milestoneValidation}",
+            "        agent={agents.smart}",
+            "        needs={{ integration: integrationId }}",
+            "        deps={{ integration: outputs.milestoneIntegration }}",
+            "        timeoutMs={1_800_000}",
+            "        heartbeatTimeoutMs={900_000}",
+            "        memory={{ remember: { namespace: missionMemory, key: validationId } }}",
+            "      >",
+            "        {(deps: any) => (",
+            "          <MissionValidatePrompt",
+            "            missionGoal={plan.goal || ctx.input.prompt}",
+            "            milestone={milestone}",
+            "            integration={deps.integration}",
+            "          />",
+            "        )}",
+            "      </Task>",
+            "      {needsFollowUp && (",
+            "        <Sequence>",
+            "          <Task",
+            "            id={milestoneFollowUpId(milestoneIndex)}",
+            "            output={outputs.missionFeature}",
+            "            agent={agents.smart}",
+            "            needs={{ validation: validationId }}",
+            "            deps={{ validation: outputs.milestoneValidation }}",
+            "            timeoutMs={1_800_000}",
+            "            memory={{ remember: { namespace: missionMemory, key: milestoneFollowUpId(milestoneIndex) } }}",
+            "          >",
+            "            {(deps: any) => (",
+            "              <MissionFollowUpPrompt",
+            "                missionGoal={plan.goal || ctx.input.prompt}",
+            "                milestone={milestone}",
+            "                validation={deps.validation}",
+            "              />",
+            "            )}",
+            "          </Task>",
+            "          <Task",
+            "            id={milestoneRevalidationId(milestoneIndex)}",
+            "            output={outputs.milestoneValidation}",
+            "            agent={agents.smart}",
+            "            needs={{ followUp: milestoneFollowUpId(milestoneIndex) }}",
+            "            deps={{ followUp: outputs.missionFeature }}",
+            "            timeoutMs={1_800_000}",
+            "            heartbeatTimeoutMs={900_000}",
+            "            memory={{ remember: { namespace: missionMemory, key: milestoneRevalidationId(milestoneIndex) } }}",
+            "          >",
+            "            {(deps: any) => (",
+            "              <MissionValidatePrompt",
+            "                missionGoal={plan.goal || ctx.input.prompt}",
+            "                milestone={milestone}",
+            "                integration={integration}",
+            "                followUp={deps.followUp}",
+            "              />",
+            "            )}",
+            "          </Task>",
+            "        </Sequence>",
+            "      )}",
+            "    </Sequence>",
+            "  );",
+            "}",
+            "",
+            "function renderFinal(ctx: any, plan: any, milestones: any[]) {",
+            "  return (",
+            "    <Task id=\"mission:final\" output={outputs.missionFinal} agent={agents.smartTool}>",
+            "      <MissionFinalPrompt",
+            "        plan={{ ...plan, milestones }}",
+            "        featureResults={ctx.outputs.missionFeature ?? []}",
+            "        integrationResults={ctx.outputs.milestoneIntegration ?? []}",
+            "        validationResults={ctx.outputs.milestoneValidation ?? []}",
+            "      />",
+            "    </Task>",
+            "  );",
+            "}",
+            "",
+            "export default smithers((ctx) => {",
+            "  const plan = ctx.outputMaybe(\"missionPlan\", { nodeId: \"mission:plan\" });",
+            "  const approval = ctx.outputMaybe(\"missionApproval\", { nodeId: \"mission:approve-plan\" });",
+            "  const approvalRequired = ctx.input.requirePlanApproval;",
+            "  const approvalDenied = approvalRequired && approval && approval.approved === false;",
+            "  const approved = !approvalRequired || approval?.approved === true;",
+            "  const milestones = normalizeMilestones(plan, ctx.input.maxMilestones ?? 6, ctx.input.maxFeaturesPerMilestone ?? 6);",
+            "  const activeIndex = approved ? activeMilestoneIndex(ctx, milestones) : 0;",
+            "",
+            "  return (",
+            "    <Workflow name=\"mission\">",
+            "      <Sequence>",
+            "        <Task",
+            "          id=\"mission:plan\"",
+            "          output={outputs.missionPlan}",
+            "          agent={agents.smartTool}",
+            "          timeoutMs={1_800_000}",
+            "          heartbeatTimeoutMs={900_000}",
+            "          memory={{ remember: { namespace: missionMemory, key: \"mission:plan\" } }}",
+            "        >",
+            "          <AskUserInstructions />",
+            "          <MissionPlanPrompt",
+            "            prompt={ctx.input.prompt}",
+            "            maxMilestones={ctx.input.maxMilestones ?? 6}",
+            "            maxFeaturesPerMilestone={ctx.input.maxFeaturesPerMilestone ?? 6}",
+            "          />",
+            "        </Task>",
+            "",
+            "        {plan && approvalRequired && !approval && (",
+            "          <Approval",
+            "            id=\"mission:approve-plan\"",
+            "            output={outputs.missionApproval}",
+            "            request={{",
+            "              title: \"Approve mission plan?\",",
+            "              summary: plan.summary || \"Review the scoped mission plan before workers begin.\",",
+            "              metadata: { milestones: milestones.length, risks: plan.risks ?? [] },",
+            "            }}",
+            "            onDeny=\"continue\"",
+            "          />",
+            "        )}",
+            "",
+            "        {approvalDenied && (",
+            "          <Task id=\"mission:cancelled\" output={outputs.missionFinal}>",
+            "            {{",
+            "              status: \"cancelled\",",
+            "              summary: `Mission plan was not approved. ${approval?.note ?? \"\"}`.trim(),",
+            "              completedMilestones: 0,",
+            "              totalMilestones: milestones.length,",
+            "              validationPassed: false,",
+            "              remainingRisks: plan?.risks ?? [],",
+            "              nextActions: [\"Revise the mission scope and rerun the workflow.\"],",
+            "              markdownBody: \"# Mission Cancelled\\n\\nThe plan was not approved.\",",
+            "            }}",
+            "          </Task>",
+            "        )}",
+            "",
+            "        {plan && approved && activeIndex < milestones.length && renderMilestone(ctx, plan, milestones[activeIndex], activeIndex)}",
+            "        {plan && approved && activeIndex >= milestones.length && renderFinal(ctx, plan, milestones)}",
+            "      </Sequence>",
+            "    </Workflow>",
+            "  );",
+            "});",
+        ]),
         {
             path: ".smithers/workflows/kanban.tsx",
             contents: [
@@ -2001,7 +3094,21 @@ function renderWorkflows() {
                 "  summary: z.string(),",
                 "});",
                 "",
+                "const inputSchema = z.object({",
+                "  maxConcurrency: z.number().int().min(1).max(10).default(3),",
+                "});",
+                "",
+                "const ticketListSchema = z.object({",
+                "  tickets: z.array(z.object({",
+                "    id: z.string(),",
+                "    slug: z.string(),",
+                "    title: z.string(),",
+                "  })),",
+                "});",
+                "",
                 "const { Workflow, Task, smithers, outputs } = createSmithers({",
+                "  input: inputSchema,",
+                "  tickets: ticketListSchema,",
                 "  implement: implementOutputSchema,",
                 "  validate: validateOutputSchema,",
                 "  review: reviewOutputSchema,",
@@ -2025,6 +3132,16 @@ function renderWorkflows() {
                 "  }",
                 "}",
                 "",
+                "function ticketTitle(ticket: { id: string; slug: string; content: string }): string {",
+                '  const heading = ticket.content.match(/^#\\s+(.+)$/m)?.[1]?.trim();',
+                "  return heading && heading.length > 0",
+                "    ? heading",
+                "    : ticket.slug",
+                '      .replace(/__/g, " / ")',
+                '      .replace(/[-_]+/g, " ")',
+                "      .replace(/\\b\\w/g, (letter) => letter.toUpperCase());",
+                "}",
+                "",
                 "/** Build feedback string from validation + review outputs for a ticket. */",
                 "function buildFeedback(",
                 "  ctx: any,",
@@ -2071,12 +3188,22 @@ function renderWorkflows() {
                 "",
                 "export default smithers((ctx) => {",
                 "  const tickets = discoverTickets();",
-                "  const maxConcurrency = Number(ctx.input.maxConcurrency) || 3;",
+                "  const maxConcurrency = ctx.input.maxConcurrency;",
                 "  const ticketResults = ctx.outputs.ticketResult ?? [];",
                 "",
                 "  return (",
                 '    <Workflow name="kanban">',
                 "      <Sequence>",
+                "        <Task id=\"tickets\" output={outputs.tickets}>",
+                "          {{",
+                "            tickets: tickets.map((ticket) => ({",
+                "              id: ticket.id,",
+                "              slug: ticket.slug,",
+                "              title: ticketTitle(ticket),",
+                "            })),",
+                "          }}",
+                "        </Task>",
+                "",
                 "        {/* Implement each ticket in its own worktree branch, in parallel */}",
                 "        <Parallel maxConcurrency={maxConcurrency}>",
                 "          {tickets.map((ticket) => {",
@@ -2173,6 +3300,7 @@ function renderTemplateFiles(versions, env) {
             path: ".smithers/preload.ts",
             contents: ['import { mdxPlugin } from "smithers-orchestrator";', "", "mdxPlugin();", ""].join("\n"),
         },
+        renderGatewayFile(),
         ...renderAgentScaffoldFiles(),
         {
             path: ".smithers/agents.ts",
@@ -2194,6 +3322,7 @@ function renderTemplateFiles(versions, env) {
         ...renderPrompts(),
         ...renderComponents(),
         ...renderWorkflows(),
+        renderKanbanUiFile(),
         {
             path: ".smithers/tickets/.gitkeep",
             contents: "",
@@ -2222,6 +3351,7 @@ export function initWorkflowPack(options = {}) {
         const env = process.env;
         ensureDir(resolve(rootDir, "prompts"));
         ensureDir(resolve(rootDir, "components"));
+        ensureDir(resolve(rootDir, "ui"));
         ensureDir(resolve(rootDir, "workflows"));
         ensureDir(resolve(rootDir, "tickets"));
         const executionsDir = resolve(rootDir, "executions");
@@ -2291,8 +3421,10 @@ 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" },
+        { command: "workflow run mission", description: "Run a scoped long-horizon mission" },
     ],
     "plan": [
+        { command: "workflow run mission", description: "Execute as a milestone-gated mission" },
         { 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" },
@@ -2315,6 +3447,7 @@ const WORKFLOW_FOLLOW_UPS = {
         { command: "workflow run tickets-create", description: "Break directly into tickets" },
     ],
     "write-a-prd": [
+        { command: "workflow run mission", description: "Execute the PRD as a mission" },
         { 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" },
@@ -2331,6 +3464,11 @@ const WORKFLOW_FOLLOW_UPS = {
         { command: "workflow run review", description: "Review the changes" },
         { command: "workflow run improve-test-coverage", description: "Improve test coverage" },
     ],
+    "mission": [
+        { command: "workflow run review", description: "Review mission changes" },
+        { command: "workflow run improve-test-coverage", description: "Fill validation gaps" },
+        { command: "workflow run audit", description: "Audit completed feature areas" },
+    ],
     "review": [
         { command: "workflow run implement", description: "Address review feedback" },
     ],