refactor(sense-generator): use createCursorRole factory, slim meta to routing-only

- planner/coder: replaced 80+ lines hand-written agent calls with createCursorRole()
- SenseMeta slimmed to routing signals only (senseName, filesCreated, passed/attempt)
- Roles read context from thread via nerve thread <id>, not from previous role's meta
- tester stays hand-written (pure CLI logic)
- Re-exported spawnSafe from workflow-utils for helper use

Refs uncaged/nerve#210

小橘 🍊（NEKO Team）

nerve.yaml

@@ -32,6 +32,9 @@ workflows:
   hello-world:
     concurrency: 1
     overflow: drop
+  gitea-issue-solver:
+    concurrency: 1
+    overflow: drop
 
 reflexes:
   - kind: sense

workflows/gitea-issue-solver/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "gitea-issue-solver-workflow",
+  "version": "0.0.1",
+  "private": true,
+  "type": "module",
+  "dependencies": {
+    "@uncaged/nerve-core": "latest",
+    "@uncaged/nerve-workflow-utils": "latest",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0"
+  },
+  "pnpm": {
+    "overrides": {
+      "@uncaged/nerve-daemon": "link:../../../repos/nerve/packages/daemon",
+      "@uncaged/nerve-core": "link:../../../repos/nerve/packages/core",
+      "@uncaged/nerve-workflow-utils": "link:../../../repos/nerve/packages/workflow-utils"
+    }
+  }
+}

workflows/gitea-issue-solver/pnpm-lock.yaml

@@ -0,0 +1,59 @@
+lockfileVersion: '9.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+overrides:
+  '@uncaged/nerve-daemon': link:../../../repos/nerve/packages/daemon
+  '@uncaged/nerve-core': link:../../../repos/nerve/packages/core
+  '@uncaged/nerve-workflow-utils': link:../../../repos/nerve/packages/workflow-utils
+
+importers:
+
+  .:
+    dependencies:
+      '@uncaged/nerve-core':
+        specifier: link:../../../repos/nerve/packages/core
+        version: link:../../../repos/nerve/packages/core
+      '@uncaged/nerve-workflow-utils':
+        specifier: link:../../../repos/nerve/packages/workflow-utils
+        version: link:../../../repos/nerve/packages/workflow-utils
+      zod:
+        specifier: ^4.3.6
+        version: 4.3.6
+    devDependencies:
+      '@types/node':
+        specifier: ^22.0.0
+        version: 22.19.17
+      typescript:
+        specifier: ^5.7.0
+        version: 5.9.3
+
+packages:
+
+  '@types/node@22.19.17':
+    resolution: {integrity: sha512-wGdMcf+vPYM6jikpS/qhg6WiqSV/OhG+jeeHT/KlVqxYfD40iYJf9/AE1uQxVWFvU7MipKRkRv8NSHiCGgPr8Q==}
+
+  typescript@5.9.3:
+    resolution: {integrity: sha512-jl1vZzPDinLr9eUt3J/t7V6FgNEw9QjvBPdysz9KfQDD41fQrC2Y4vKQdiaUpFT4bXlb1RHhLpp8wtm6M5TgSw==}
+    engines: {node: '>=14.17'}
+    hasBin: true
+
+  undici-types@6.21.0:
+    resolution: {integrity: sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==}
+
+  zod@4.3.6:
+    resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==}
+
+snapshots:
+
+  '@types/node@22.19.17':
+    dependencies:
+      undici-types: 6.21.0
+
+  typescript@5.9.3: {}
+
+  undici-types@6.21.0: {}
+
+  zod@4.3.6: {}

workflows/gitea-issue-solver/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022"],
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "skipLibCheck": true,
+    "noEmit": true,
+    "types": ["node"]
+  },
+  "include": ["./**/*.ts"]
+}

workflows/sense-generator/index.ts

@@ -5,25 +5,28 @@ import type {
   WorkflowMessage,
 } from "@uncaged/nerve-core";
 import { END } from "@uncaged/nerve-core";
+import { createCursorRole, spawnSafe } from "@uncaged/nerve-workflow-utils";
 import type { SpawnError } from "@uncaged/nerve-workflow-utils";
-import {
-  createCursorRole,
-  nerveAgentContext,
-  readNerveYaml,
-  spawnSafe,
-} from "@uncaged/nerve-workflow-utils";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { z } from "zod";
 
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
 const HOME = process.env.HOME ?? "/home/azureuser";
 const NERVE_ROOT = join(HOME, ".uncaged-nerve");
 const SENSES_DIR = join(NERVE_ROOT, "senses");
-const AGENT_TIMEOUT_MS = 3_600_000;
 
-function getNerveYaml(): string {
+// ---------------------------------------------------------------------------
-  const result = readNerveYaml({ nerveRoot: NERVE_ROOT });
+// Helpers
-  return result.ok ? result.value : "# nerve.yaml unavailable";
+// ---------------------------------------------------------------------------
+
+function formatSpawnFailure(error: SpawnError): string {
+  if (error.kind === "spawn_failed") return error.message;
+  if (error.kind === "timeout") return `timeout (stdout=${error.stdout.slice(0, 200)})`;
+  return `exit ${error.exitCode} stderr=${error.stderr.slice(0, 400)}`;
 }
 
 async function cfgGet(key: string): Promise<string | null> {
@@ -32,9 +35,7 @@ async function cfgGet(key: string): Promise<string | null> {
     env: null,
     timeoutMs: 10_000,
   });
-  if (!result.ok) {
+  if (!result.ok) return null;
-    return null;
-  }
   return result.value.stdout.trim() || null;
 }
 
@@ -45,107 +46,19 @@ async function resolveDashScopeProvider(): Promise<{
 } | null> {
   const apiKey = process.env.DASHSCOPE_API_KEY ?? (await cfgGet("DASHSCOPE_API_KEY"));
   const baseUrl = process.env.DASHSCOPE_BASE_URL ?? (await cfgGet("DASHSCOPE_BASE_URL"));
-  const model =
+  const model = process.env.DASHSCOPE_MODEL ?? (await cfgGet("DASHSCOPE_MODEL")) ?? "qwen-plus";
-    process.env.DASHSCOPE_MODEL ?? (await cfgGet("DASHSCOPE_MODEL")) ?? "qwen-plus";
+  if (!apiKey || !baseUrl) return null;
-  if (!apiKey || !baseUrl) {
-    return null;
-  }
   return { apiKey, baseUrl, model };
 }
 
-function formatSpawnFailure(error: SpawnError): string {
+function getNerveYaml(): string {
-  if (error.kind === "spawn_failed") {
+  try {
-    return error.message;
+    return readFileSync(join(NERVE_ROOT, "nerve.yaml"), "utf-8");
+  } catch {
+    return "# nerve.yaml unavailable";
   }
-  if (error.kind === "timeout") {
-    return `timeout (stdout=${error.stdout.slice(0, 200)})`;
-  }
-  return `exit ${error.exitCode} stderr=${error.stderr.slice(0, 400)}`;
 }
 
-/**
- * Run the same checks the workflow used to ask Hermes to perform, but locally.
- * Hermes chat often returns UI prose instead of shell output, which caused false failures.
- */
-async function runSenseSmokeTest(
-  senseName: string,
-): Promise<{ ok: boolean; log: string; reason: string }> {
-  const logParts: string[] = [];
-
-  const runNerve = async (args: string[]): Promise<{ ok: true; out: string } | { ok: false; err: string }> => {
-    const result = await spawnSafe("nerve", args, {
-      cwd: NERVE_ROOT,
-      env: null,
-      timeoutMs: 300_000,
-    });
-    if (!result.ok) {
-      return { ok: false, err: formatSpawnFailure(result.error) };
-    }
-    return { ok: true, out: result.value.stdout };
-  };
-
-  const statusRun = await runNerve(["status"]);
-  if (!statusRun.ok) {
-    return {
-      ok: false,
-      log: `=== nerve status ===\nERROR: ${statusRun.err}`,
-      reason: `Smoke test command failed: ${statusRun.err}`,
-    };
-  }
-  const status = statusRun.out;
-  logParts.push("=== nerve status ===\n" + status);
-  if (!status.includes(senseName)) {
-    return {
-      ok: false,
-      log: logParts.join("\n\n"),
-      reason: `Sense "${senseName}" not listed in \`nerve status\` output`,
-    };
-  }
-
-  const triggerRun = await runNerve(["sense", "trigger", senseName]);
-  if (!triggerRun.ok) {
-    logParts.push(`=== nerve sense trigger ===\nERROR: ${triggerRun.err}`);
-    return {
-      ok: false,
-      log: logParts.join("\n\n"),
-      reason: `Smoke test command failed: ${triggerRun.err}`,
-    };
-  }
-  logParts.push("=== nerve sense trigger ===\n" + triggerRun.out);
-
-  let lastQuery = "";
-  for (let i = 0; i < 25; i++) {
-    const sleepR = await spawnSafe("sleep", ["1"], { cwd: NERVE_ROOT, env: null, timeoutMs: 10_000 });
-    if (!sleepR.ok) {
-      logParts.push(`=== sleep (attempt ${i + 1}) ===\nERROR: ${formatSpawnFailure(sleepR.error)}`);
-    }
-
-    const queryRun = await runNerve(["sense", "query", senseName]);
-    if (!queryRun.ok) {
-      logParts.push(`=== nerve sense query (attempt ${i + 1}) ===\nERROR: ${queryRun.err}`);
-    } else {
-      lastQuery = queryRun.out;
-      logParts.push(`=== nerve sense query (attempt ${i + 1}) ===\n${lastQuery}`);
-      if (!lastQuery.includes("(0 rows)")) {
-        return {
-          ok: true,
-          log: logParts.join("\n\n"),
-          reason: "Trigger succeeded and query returned at least one row",
-        };
-      }
-    }
-  }
-
-  return {
-    ok: false,
-    log: logParts.join("\n\n"),
-    reason: lastQuery.includes("(0 rows)")
-      ? "Query still returned 0 rows after trigger (compute error, throttle drop, or DB not written)"
-      : "Timed out waiting for successful sense query",
-  };
-}
-
-// Build context string with existing sense examples
 function buildSenseExamples(): string {
   const examples: string[] = [];
   for (const name of ["cpu-usage", "linux-system-health"]) {
@@ -172,18 +85,78 @@ function buildSenseExamples(): string {
   return examples.join("\n\n---\n\n");
 }
 
-function getSenseNameFromThread(messages: WorkflowMessage[]): string {
+async function runSenseSmokeTest(
-  const p = messages.find((m) => m.role === "planner");
+  senseName: string,
-  if (p === undefined || typeof p.meta !== "object" || p.meta === null) {
+): Promise<{ ok: boolean; log: string; reason: string }> {
-    return "";
+  const logParts: string[] = [];
+
+  const runNerve = async (
+    args: string[],
+  ): Promise<{ ok: true; out: string } | { ok: false; err: string }> => {
+    const result = await spawnSafe("nerve", args, {
+      cwd: NERVE_ROOT,
+      env: null,
+      timeoutMs: 300_000,
+    });
+    if (!result.ok) return { ok: false, err: formatSpawnFailure(result.error) };
+    return { ok: true, out: result.value.stdout };
+  };
+
+  const statusRun = await runNerve(["status"]);
+  if (!statusRun.ok) {
+    return {
+      ok: false,
+      log: `=== nerve status ===\nERROR: ${statusRun.err}`,
+      reason: `Smoke test command failed: ${statusRun.err}`,
+    };
   }
-  return String((p.meta as { senseName: string }).senseName);
+  logParts.push("=== nerve status ===\n" + statusRun.out);
+  if (!statusRun.out.includes(senseName)) {
+    return {
+      ok: false,
+      log: logParts.join("\n\n"),
+      reason: `Sense "${senseName}" not listed in \`nerve status\` output`,
+    };
+  }
+
+  const triggerRun = await runNerve(["sense", "trigger", senseName]);
+  if (!triggerRun.ok) {
+    logParts.push(`=== nerve sense trigger ===\nERROR: ${triggerRun.err}`);
+    return { ok: false, log: logParts.join("\n\n"), reason: `Trigger failed: ${triggerRun.err}` };
+  }
+  logParts.push("=== nerve sense trigger ===\n" + triggerRun.out);
+
+  let lastQuery = "";
+  for (let i = 0; i < 25; i++) {
+    await new Promise((r) => setTimeout(r, 1000));
+    const queryRun = await runNerve(["sense", "query", senseName]);
+    if (!queryRun.ok) {
+      logParts.push(`=== query attempt ${i + 1} ===\nERROR: ${queryRun.err}`);
+    } else {
+      lastQuery = queryRun.out;
+      logParts.push(`=== query attempt ${i + 1} ===\n${lastQuery}`);
+      if (!lastQuery.includes("(0 rows)")) {
+        return {
+          ok: true,
+          log: logParts.join("\n\n"),
+          reason: "Trigger succeeded and query returned at least one row",
+        };
+      }
+    }
+  }
+
+  return {
+    ok: false,
+    log: logParts.join("\n\n"),
+    reason: lastQuery.includes("(0 rows)")
+      ? "Query still returned 0 rows after trigger"
+      : "Timed out waiting for successful sense query",
+  };
 }
 
-function getPlanFromThread(messages: WorkflowMessage[]): string {
+// ---------------------------------------------------------------------------
-  const p = messages.find((m) => m.role === "planner");
+// Meta — routing-only signals for the moderator
-  return p !== undefined ? p.content : "";
+// ---------------------------------------------------------------------------
-}
 
 type SenseMeta = {
   planner: { senseName: string };
@@ -191,185 +164,112 @@ type SenseMeta = {
   tester: { passed: boolean; attempt: number };
 };
 
-const plannerMetaSchema = z
+// ---------------------------------------------------------------------------
-  .object({
+// Bake static context (read once at module load, not per-call)
-    senseName: z
+// ---------------------------------------------------------------------------
-      .string()
-      .describe("kebab-case sense name from the plan, e.g. 'disk-usage'"),
-  })
-  .describe("Extract the kebab-case sense name from the plan text");
 
-const coderMetaSchema = z
+const senseExamples = buildSenseExamples();
-  .object({
+const nerveYaml = getNerveYaml();
-    filesCreated: z
-      .boolean()
-      .describe("true if index.js, schema.ts, migrations/0001_init.sql exist and nerve.yaml was updated"),
-  })
-  .describe("Whether the agent completed all file work for the sense");
 
-async function runPlanner(
+// ---------------------------------------------------------------------------
-  start: StartStep,
+// Roles
-  _messages: WorkflowMessage[],
+// ---------------------------------------------------------------------------
-): Promise<RoleResult<SenseMeta["planner"]>> {
+
-  const userInput = start.content;
+async function buildPlannerRole() {
   const provider = await resolveDashScopeProvider();
   if (provider === null) {
-    return {
+    throw new Error("Cannot create planner: set DASHSCOPE_API_KEY and DASHSCOPE_BASE_URL");
-      content:
-        "Cannot run planner: set DASHSCOPE_API_KEY and DASHSCOPE_BASE_URL (or configure via `cfg get`), " +
-        "and optionally DASHSCOPE_MODEL.",
-      meta: { senseName: "" },
-    };
   }
-
+  return createCursorRole<SenseMeta["planner"]>({
-  const role = createCursorRole<SenseMeta["planner"]>({
     cwd: NERVE_ROOT,
     mode: "ask",
-    timeoutMs: AGENT_TIMEOUT_MS,
+    prompt: async (threadId) =>
-    prompt: async (threadId) => {
+      `You are planning a new Nerve sense.
-      return `You are planning a new Nerve sense.
 
-${nerveAgentContext}
+Read the workflow thread for the user's request: \`nerve thread ${threadId}\`
 
-**Context:** Read this workflow run for background before you plan. From a shell in \`${NERVE_ROOT}\`, run:
+Pick a good kebab-case name for this sense. Produce a PLAN (not code) in markdown:
-\`nerve thread show ${threadId} --budget 50000\`
-Use the thread transcript (prior user messages and rounds) when deciding the sense.
-
-User request: ${userInput}
-Pick a good kebab-case name for this sense.
-
-Your job is to produce a PLAN (not code) for this sense. Output a structured plan in markdown with these sections:
 
 ## Sense Design
+### Name — kebab-case
+### Fields — name, type (integer/real/text), description
+### Compute Logic — step-by-step, specific Node.js APIs or shell commands
+### Trigger Config — group, interval, throttle, timeout
 
-### Name
+Reference senses:
-(decide a kebab-case name)
+${senseExamples}
-
-### Fields
-List every field the sense should collect, with name, type (integer/real/text), and description.
-
-### Compute Logic
-Describe step-by-step what the compute() function should do. Be specific about which Node.js APIs or shell commands to use.
-
-### Trigger Config
-- group: (suggest a group name)
-- interval: (decide based on the use case, e.g. 30s, 1m, 5m)
-- throttle: (suggest)
-- timeout: (suggest)
-
-Here are existing senses for reference on the format and patterns used:
-
-${buildSenseExamples()}
 
 Current nerve.yaml:
 \`\`\`yaml
-${getNerveYaml()}
+${nerveYaml}
 \`\`\`
 
-Output ONLY the plan in markdown. Be precise and implementation-ready.`;
+Output ONLY the plan. Be precise and implementation-ready.`,
+    extract: {
+      provider,
+      schema: z.object({
+        senseName: z.string().describe("kebab-case sense name from the plan"),
+      }),
     },
-    extract: { provider, schema: plannerMetaSchema },
   });
-
-  try {
-    return await role(start, _messages);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    return { content: message, meta: { senseName: "" } };
-  }
 }
 
-async function runCoder(
+async function buildCoderRole() {
-  _start: StartStep,
-  messages: WorkflowMessage[],
-): Promise<RoleResult<SenseMeta["coder"]>> {
-  const plan = getPlanFromThread(messages);
-  const senseName = getSenseNameFromThread(messages);
   const provider = await resolveDashScopeProvider();
   if (provider === null) {
-    return {
+    throw new Error("Cannot create coder: set DASHSCOPE_API_KEY and DASHSCOPE_BASE_URL");
-      content:
-        "Cannot run coder: set DASHSCOPE_API_KEY and DASHSCOPE_BASE_URL (or configure via `cfg get`), " +
-        "and optionally DASHSCOPE_MODEL.",
-      meta: { filesCreated: false },
-    };
   }
-
+  return createCursorRole<SenseMeta["coder"]>({
-  const role = createCursorRole<SenseMeta["coder"]>({
     cwd: NERVE_ROOT,
     mode: "default",
-    timeoutMs: AGENT_TIMEOUT_MS,
+    prompt: async (threadId) =>
-    prompt: async (threadId) => {
+      `Read the workflow thread for the planner's sense design: \`nerve thread ${threadId}\`
-      return `You are implementing a new Nerve sense called "${senseName}" in the directory ${SENSES_DIR}/${senseName}/.
 
-**Context:** Read this workflow run for background before you edit files. From a shell in \`${NERVE_ROOT}\`, run:
+Implement the sense. Create exactly:
-\`nerve thread show ${threadId} --budget 50000\`
+1. The sense directory under ${SENSES_DIR}/<sense-name>/
+2. index.js — export async function compute(db, _peers), import schema from "./schema.ts"
+3. schema.ts — drizzle-orm/sqlite-core
+4. migrations/0001_init.sql — must match schema.ts
+5. Update ${NERVE_ROOT}/nerve.yaml — add sense config + reflex entry
 
-Here is the plan (from the planner step):
+Follow the patterns from existing senses. Create all files now.`,
-
+    extract: {
-${plan}
+      provider,
-
+      schema: z.object({
-You need to create exactly 3 files:
+        filesCreated: z.boolean().describe("true if the sense files were created"),
-1. \`${SENSES_DIR}/${senseName}/index.js\` — the compute() function
+      }),
-2. \`${SENSES_DIR}/${senseName}/schema.ts\` — Drizzle ORM schema
-3. \`${SENSES_DIR}/${senseName}/migrations/0001_init.sql\` — SQLite migration
-
-And UPDATE the existing file:
-4. \`${NERVE_ROOT}/nerve.yaml\` — add the new sense config and reflex entry
-
-Here are existing senses for reference — follow the EXACT same patterns:
-
-${buildSenseExamples()}
-
-Current nerve.yaml (append to it, don't overwrite existing entries):
-\`\`\`yaml
-${getNerveYaml()}
-\`\`\`
-
-IMPORTANT RULES:
-- index.js uses \`export async function compute(db, _peers)\` signature
-- index.js imports the schema table from "./schema.ts" and uses \`await db.insert(table).values({...})\` to persist
-- schema.ts uses drizzle-orm/sqlite-core imports
-- migration SQL must match schema.ts exactly
-- nerve.yaml: add under \`senses:\` and add a reflex under \`reflexes:\`
-- Use the interval specified in the plan for the reflex
-
-Create all files now. End with a clear statement of whether all files and updates were created successfully, or what is still missing.`;
     },
-    extract: { provider, schema: coderMetaSchema },
   });
-
-  try {
-    return await role(_start, messages);
-  } catch (e) {
-    const message = e instanceof Error ? e.message : String(e);
-    return { content: message, meta: { filesCreated: false } };
-  }
 }
 
-async function runTester(
+// Tester: pure CLI logic — stays hand-written
+async function tester(
   _start: StartStep,
   messages: WorkflowMessage[],
 ): Promise<RoleResult<SenseMeta["tester"]>> {
-  const senseName = getSenseNameFromThread(messages);
-  const senseDir = join(SENSES_DIR, senseName);
-
-  const files = {
-    index: existsSync(join(senseDir, "index.js")),
-    schema: existsSync(join(senseDir, "schema.ts")),
-    migration: existsSync(join(senseDir, "migrations", "0001_init.sql")),
-  };
-
   const attempt = messages.filter((m) => m.role === "tester").length + 1;
 
-  if (!senseName) {
+  // Get senseName from planner meta
+  const plannerStep = messages.find((m) => m.role === "planner");
+  const senseName = plannerStep
+    ? (plannerStep.meta as SenseMeta["planner"]).senseName
+    : "";
+
+  if (senseName.length === 0) {
     return {
-      content: "FAIL — no senseName from planner meta",
+      content: "FAIL — no senseName from planner",
       meta: { passed: false, attempt },
     };
   }
 
-  const missing = Object.entries(files).filter(([, v]) => !v).map(([k]) => k);
+  // Check files exist
+  const senseDir = join(SENSES_DIR, senseName);
+  const missing = [
+    existsSync(join(senseDir, "index.js")) ? null : "index.js",
+    existsSync(join(senseDir, "schema.ts")) ? null : "schema.ts",
+    existsSync(join(senseDir, "migrations", "0001_init.sql")) ? null : "migrations/0001_init.sql",
+  ].filter((x) => x !== null);
+
   if (missing.length > 0) {
     return {
       content: `FAIL — missing files: ${missing.join(", ")}`,
@@ -377,60 +277,42 @@ async function runTester(
     };
   }
 
+  // Smoke test
   const smoke = await runSenseSmokeTest(senseName);
-
-  if (smoke.ok) {
   return {
-      content: `PASS — ${smoke.reason}`,
+    content: `${smoke.ok ? "PASS" : "FAIL"} — ${smoke.reason}`,
-      meta: { passed: true, attempt },
+    meta: { passed: smoke.ok, attempt },
   };
-  }
+}
+
+// ---------------------------------------------------------------------------
+// Workflow definition
+// ---------------------------------------------------------------------------
+
+async function buildWorkflow(): Promise<WorkflowDefinition<SenseMeta>> {
+  const plannerRole = await buildPlannerRole();
+  const coderRole = await buildCoderRole();
 
   return {
-    content: `FAIL — ${smoke.reason}\n\n--- smoke log ---\n${smoke.log}`,
+    name: "sense-generator",
-    meta: {
+    roles: {
-      passed: false,
+      planner: plannerRole,
-      attempt,
+      coder: coderRole,
+      tester,
+    },
+    moderator(context) {
+      if (context.steps.length === 0) return "planner";
+      const last = context.steps[context.steps.length - 1];
+      if (last.role === "planner") return "coder";
+      if (last.role === "coder") return "tester";
+      if (last.role === "tester") {
+        if (last.meta.passed) return END;
+        return last.meta.attempt < 3 ? "coder" : END;
+      }
+      return END;
     },
   };
 }
 
-const workflow: WorkflowDefinition<SenseMeta> = {
+const workflow = await buildWorkflow();
-  name: "sense-generator",
-
-  roles: {
-    planner: runPlanner,
-    coder: runCoder,
-    tester: runTester,
-  },
-
-  moderator(context) {
-    if (context.steps.length === 0) {
-      return "planner";
-    }
-
-    const signal = context.steps[context.steps.length - 1];
-    if (signal.role === "planner") {
-      return "coder";
-    }
-
-    if (signal.role === "coder") {
-      return "tester";
-    }
-
-    if (signal.role === "tester") {
-      const meta = signal.meta;
-      if (meta.passed) {
-        return END;
-      }
-      if (meta.attempt < 3) {
-        return "coder";
-      }
-      return END;
-    }
-
-    return END;
-  },
-};
-
 export default workflow;

workflows/workflow-generator/index.ts

@@ -77,11 +77,11 @@ const plannerExtractSchema = z.object({
     .default("")
     .describe("kebab-case workflow name under workflows/, e.g. issue-fixer"),
   roles: z.array(roleSchema).default([]),
-  flowTransitions: z.string().default(""),
+  flowTransitions: z.preprocess((v) => (Array.isArray(v) ? v.join("\n") : v), z.string().default("")),
-  validationLoopsDesign: z.string().default(""),
+  validationLoopsDesign: z.preprocess((v) => (Array.isArray(v) ? v.join("\n") : v), z.string().default("")),
-  externalDeps: z.string().default(""),
+  externalDeps: z.preprocess((v) => (Array.isArray(v) ? v.join(", ") : v), z.string().default("")),
-  dataFlow: z.string().default(""),
+  dataFlow: z.preprocess((v) => (Array.isArray(v) ? v.join("\n") : v), z.string().default("")),
-  planMarkdown: z.string().default(""),
+  planMarkdown: z.preprocess((v) => (Array.isArray(v) ? v.join("\n") : v), z.string().default("")),
 });
 
 function getNerveYaml(): string {
@@ -778,7 +778,9 @@ Rules:
     const last = context.steps[context.steps.length - 1];
 
     if (last.role === "planner") {
-      return last.meta.workflowName.trim().length > 0 ? "coder" : END;
+      if (last.meta.workflowName.trim().length > 0) return "coder";
+      const plannerAttempts = context.steps.filter((s) => s.role === "planner").length;
+      return plannerAttempts < 3 ? "planner" : END;
     }
     if (last.role === "coder") {
       if (last.meta.lintPassed && last.meta.buildPassed) {