@productbrain/mcp 0.0.1-beta.52 → 0.0.1-beta.54

package/dist/{chunk-SCSEEERT.js → chunk-QUWYOGHB.js}

@@ -38,7 +38,7 @@ import {
   unknownAction,
   validationResult,
   withEnvelope
-} from "./chunk-ED3KCWZE.js";
+} from "./chunk-WEH5CZJ7.js";
 import {
   trackQualityCheck,
   trackQualityVerdict
@@ -232,7 +232,7 @@ ${formatted}` }],
     },
     withEnvelope(async ({ entryId }) => {
       requireWriteAccess();
-      const { runContradictionCheck } = await import("./smart-capture-2IM2565I.js");
+      const { runContradictionCheck } = await import("./smart-capture-3OXWEXWM.js");
       const entry = await mcpQuery("chain.getEntry", { entryId });
       if (!entry) {
         return notFoundResult(entryId, `Entry '${entryId}' not found. Try search to find the right ID.`);
@@ -2569,11 +2569,150 @@ async function handleReEvaluate(entryId, context) {
 // src/tools/workflows.ts
 import { z as z11 } from "zod";
 
+// src/workflows/descriptor.ts
+function cloneWorkflowQuestion(question) {
+  return {
+    ...question,
+    options: question.options?.map((option) => ({ ...option }))
+  };
+}
+function cloneWorkflowRound(round) {
+  return {
+    ...round,
+    questions: round.questions?.map(cloneWorkflowQuestion),
+    outputSchema: { ...round.outputSchema }
+  };
+}
+function cloneWorkflowDescriptor(descriptor) {
+  return {
+    ...descriptor,
+    rounds: descriptor.rounds.map(cloneWorkflowRound),
+    template: { ...descriptor.template },
+    output: {
+      primaryRecord: {
+        routing: descriptor.output.primaryRecord.routing.mode === "fixed" ? {
+          mode: "fixed",
+          collection: descriptor.output.primaryRecord.routing.collection
+        } : { mode: "classifier" }
+      },
+      summaryCapture: descriptor.output.summaryCapture ? { ...descriptor.output.summaryCapture } : void 0,
+      emits: descriptor.output.emits?.map((emitted) => ({ ...emitted }))
+    },
+    runtime: { ...descriptor.runtime }
+  };
+}
+function cloneWorkflowDefinition(definition) {
+  return {
+    ...definition,
+    rounds: definition.rounds.map(cloneWorkflowRound),
+    kbOutputTemplate: definition.kbOutputTemplate ? { ...definition.kbOutputTemplate } : void 0
+  };
+}
+function validateWorkflowDescriptor(descriptor) {
+  if (descriptor.rounds.length === 0) {
+    throw new Error(`Workflow '${descriptor.id}' must define at least one round.`);
+  }
+  const roundIds = /* @__PURE__ */ new Set();
+  for (const [index, round] of descriptor.rounds.entries()) {
+    if (roundIds.has(round.id)) {
+      throw new Error(`Workflow '${descriptor.id}' has duplicate round id '${round.id}'.`);
+    }
+    roundIds.add(round.id);
+    const expectedNum = String(index + 1).padStart(2, "0");
+    if (round.num !== expectedNum) {
+      throw new Error(
+        `Workflow '${descriptor.id}' round '${round.id}' has num '${round.num}', expected '${expectedNum}'.`
+      );
+    }
+    const questionIds = /* @__PURE__ */ new Set();
+    for (const question of round.questions ?? []) {
+      if (questionIds.has(question.id)) {
+        throw new Error(
+          `Workflow '${descriptor.id}' round '${round.id}' has duplicate question id '${question.id}'.`
+        );
+      }
+      questionIds.add(question.id);
+    }
+  }
+  if (descriptor.runtime.kind === "facilitated" && !descriptor.runtime.primaryTool) {
+    throw new Error(
+      `Workflow '${descriptor.id}' is facilitated and must define runtime.primaryTool.`
+    );
+  }
+  if (descriptor.output.summaryCapture?.createsPrimaryRecord && descriptor.output.primaryRecord.routing.mode !== "fixed") {
+    throw new Error(
+      `Workflow '${descriptor.id}' cannot define summaryCapture when primaryRecord routing is classifier-based.`
+    );
+  }
+}
+function getWorkflowSummaryCaptureDefinition(descriptor) {
+  const { summaryCapture } = descriptor.output;
+  const { routing } = descriptor.output.primaryRecord;
+  if (!summaryCapture || !summaryCapture.createsPrimaryRecord) {
+    return null;
+  }
+  if (routing.mode !== "fixed") {
+    return null;
+  }
+  return {
+    collection: routing.collection,
+    nameTemplate: summaryCapture.nameTemplate,
+    descriptionField: summaryCapture.descriptionField ?? "description",
+    descriptionSource: summaryCapture.descriptionSource ?? "final-output-text"
+  };
+}
+function getWorkflowPrimaryRecordCollection(descriptor) {
+  const { routing } = descriptor.output.primaryRecord;
+  return routing.mode === "fixed" ? routing.collection : null;
+}
+function getWorkflowTemplateMetadata(descriptor) {
+  return {
+    slug: descriptor.template.slug,
+    name: descriptor.template.name
+  };
+}
+function getWorkflowContextCollection(descriptor) {
+  return getWorkflowPrimaryRecordCollection(descriptor);
+}
+function describeWorkflowPrimaryOutput(descriptor) {
+  const { routing } = descriptor.output.primaryRecord;
+  if (routing.mode === "fixed") {
+    return `Primary record routes to \`${routing.collection}\`.`;
+  }
+  return "Primary record is classifier-routed at runtime.";
+}
+function compileWorkflowDefinition(descriptor) {
+  validateWorkflowDescriptor(descriptor);
+  const clonedDescriptor = cloneWorkflowDescriptor(descriptor);
+  const primaryRecordCollection = getWorkflowPrimaryRecordCollection(
+    clonedDescriptor
+  );
+  const summaryCapture = getWorkflowSummaryCaptureDefinition(clonedDescriptor);
+  return {
+    id: clonedDescriptor.id,
+    name: clonedDescriptor.name,
+    shortDescription: clonedDescriptor.shortDescription,
+    icon: clonedDescriptor.icon,
+    facilitatorPreamble: clonedDescriptor.facilitatorPreamble,
+    rounds: clonedDescriptor.rounds,
+    kbOutputCollection: primaryRecordCollection ?? void 0,
+    kbOutputTemplate: summaryCapture ? {
+      nameTemplate: summaryCapture.nameTemplate,
+      descriptionField: summaryCapture.descriptionField
+    } : void 0,
+    errorRecovery: clonedDescriptor.errorRecovery
+  };
+}
+
 // src/workflows/definitions.ts
-var RETRO_WORKFLOW = {
+var RETRO_WORKFLOW_DESCRIPTOR = {
   id: "retro",
   name: "Retrospective",
   shortDescription: "Structured team retrospective \u2014 reflect, surface patterns, commit to actions. Commits a decision entry to the Chain.",
+  template: {
+    slug: "retro",
+    name: "Retrospective"
+  },
   icon: "\u25CE",
   facilitatorPreamble: `You are now in **Facilitator Mode**. You are not a coding assistant \u2014 you are a facilitator running a structured retrospective.
 
@@ -2719,10 +2858,21 @@ Create a Cursor Plan with these rounds as tasks. Mark each in_progress as you en
       maxDurationHint: "2 min"
     }
   ],
-  kbOutputCollection: "decisions",
-  kbOutputTemplate: {
-    nameTemplate: "Retro: {scope} \u2014 {date}",
-    descriptionField: "rationale"
+  output: {
+    primaryRecord: {
+      routing: {
+        mode: "fixed",
+        collection: "decisions"
+      }
+    },
+    summaryCapture: {
+      createsPrimaryRecord: true,
+      nameTemplate: "Retro: {scope} \u2014 {date}",
+      descriptionField: "rationale"
+    }
+  },
+  runtime: {
+    kind: "guided"
   },
   errorRecovery: `If anything goes wrong during the retro:
 
@@ -2734,10 +2884,14 @@ Create a Cursor Plan with these rounds as tasks. Mark each in_progress as you en
 
 The retro must never fail silently. Always communicate state.`
 };
-var SHAPE_WORKFLOW = {
+var SHAPE_WORKFLOW_DESCRIPTOR = {
   id: "shape",
   name: "Shape a Bet",
   shortDescription: "Coached shaping session \u2014 problem \u2192 appetite \u2192 elements \u2192 architecture \u2192 de-risk \u2192 pitch. Uses the `facilitate` tool for scoring and Chain capture.",
+  template: {
+    slug: "shape-a-bet",
+    name: "Shape a Bet"
+  },
   icon: "\u25C6",
   facilitatorPreamble: `You are now in **Shaping Mode**. You are an **investigating** shaping facilitator powered by the \`facilitate\` tool and Cursor sub-agents.
 
@@ -2910,10 +3064,44 @@ If any facilitate call fails:
       maxDurationHint: "5 min"
     }
   ],
-  kbOutputCollection: "bets",
-  kbOutputTemplate: {
-    nameTemplate: "{betName}",
-    descriptionField: "problem"
+  output: {
+    primaryRecord: {
+      routing: {
+        mode: "fixed",
+        collection: "bets"
+      }
+    },
+    emits: [
+      {
+        kind: "entry",
+        collection: "features",
+        description: "Solution elements captured during shaping."
+      },
+      {
+        kind: "entry",
+        collection: "tensions",
+        description: "Risks and rabbit holes captured during shaping."
+      },
+      {
+        kind: "entry",
+        collection: "decisions",
+        description: "Decisions captured inline when they surface."
+      },
+      {
+        kind: "entry",
+        collection: "glossary",
+        description: "Glossary terms captured inline when they surface."
+      },
+      {
+        kind: "update",
+        collection: "bets",
+        description: "Bet status and no-go updates during finalize."
+      }
+    ]
+  },
+  runtime: {
+    kind: "facilitated",
+    primaryTool: "facilitate"
   },
   errorRecovery: `If anything goes wrong during shaping:
 
@@ -2925,10 +3113,14 @@ If any facilitate call fails:
 
 The shaping must never fail silently. Always communicate state.`
 };
-var IMPLEMENTATION_REVIEW_WORKFLOW = {
+var IMPLEMENTATION_REVIEW_WORKFLOW_DESCRIPTOR = {
   id: "implementation-review",
   name: "Implementation Review",
   shortDescription: "Review completed implementation against standards, Chain coherence, and test honesty. Spawns sub-agents, uses Context7 for library docs, validates chain is up to date. Ends with BET/chain IDs. Commits an insight to the Chain.",
+  template: {
+    slug: "implementation-review",
+    name: "Implementation Review"
+  },
   icon: "\u2713",
   facilitatorPreamble: `You are now in **Implementation Review Mode**. You orchestrate a structured review of work that was just built \u2014 not a conversation, but a tool-driven audit with sub-agent support.
 
@@ -3042,10 +3234,21 @@ When reviewing test results: (a) test staleness \u2014 code changed, test not up
       maxDurationHint: "3 min"
     }
   ],
-  kbOutputCollection: "insights",
-  kbOutputTemplate: {
-    nameTemplate: "Implementation Review: {scope} \u2014 {date}",
-    descriptionField: "description"
+  output: {
+    primaryRecord: {
+      routing: {
+        mode: "fixed",
+        collection: "insights"
+      }
+    },
+    summaryCapture: {
+      createsPrimaryRecord: true,
+      nameTemplate: "Implementation Review \u2014 {date}",
+      descriptionField: "description"
+    }
+  },
+  runtime: {
+    kind: "guided"
   },
   errorRecovery: `If anything goes wrong during implementation review:
 
@@ -3056,10 +3259,14 @@ When reviewing test results: (a) test staleness \u2014 code changed, test not up
 
 The review must never fail silently. Always end with BET/chain IDs.`
 };
-var PROCESS_CHANGE_WORKFLOW = {
+var PROCESS_CHANGE_WORKFLOW_DESCRIPTOR = {
   id: "process-change",
   name: "Process a Change",
   shortDescription: "Lightweight workflow for everyday changes \u2014 bug fixes, improvements, change requests. Captures what changed, why, and what's affected without a full shaping ceremony. Routes output to the right collection via the classifier.",
+  template: {
+    slug: "process-change",
+    name: "Process a Change"
+  },
   icon: "\u21BB",
   facilitatorPreamble: `You are now in **Change Processing Mode**. You are a lightweight facilitator helping the user capture the context around a change they're making or just made \u2014 a bug fix, improvement, change request, or prerequisite task.
 
@@ -3147,10 +3354,15 @@ var PROCESS_CHANGE_WORKFLOW = {
       maxDurationHint: "1 min"
     }
   ],
-  kbOutputCollection: "decisions",
-  kbOutputTemplate: {
-    nameTemplate: "{changeName} \u2014 {date}",
-    descriptionField: "rationale"
+  output: {
+    primaryRecord: {
+      routing: {
+        mode: "classifier"
+      }
+    }
+  },
+  runtime: {
+    kind: "guided"
   },
   errorRecovery: `If anything goes wrong during change processing:
 
@@ -3161,34 +3373,102 @@ var PROCESS_CHANGE_WORKFLOW = {
 
 Never block the user's real work. This workflow serves the work \u2014 it doesn't replace it.`
 };
-var WORKFLOWS = /* @__PURE__ */ new Map([
-  ["retro", RETRO_WORKFLOW],
-  ["shape", SHAPE_WORKFLOW],
-  ["implementation-review", IMPLEMENTATION_REVIEW_WORKFLOW],
-  ["process-change", PROCESS_CHANGE_WORKFLOW]
+var WORKFLOW_DESCRIPTORS = /* @__PURE__ */ new Map([
+  ["retro", RETRO_WORKFLOW_DESCRIPTOR],
+  ["shape", SHAPE_WORKFLOW_DESCRIPTOR],
+  ["implementation-review", IMPLEMENTATION_REVIEW_WORKFLOW_DESCRIPTOR],
+  ["process-change", PROCESS_CHANGE_WORKFLOW_DESCRIPTOR]
 ]);
+var WORKFLOWS = new Map(
+  Array.from(WORKFLOW_DESCRIPTORS.entries(), ([id, descriptor]) => [
+    id,
+    compileWorkflowDefinition(descriptor)
+  ])
+);
 function getWorkflow(id) {
-  return WORKFLOWS.get(id);
+  const workflow = WORKFLOWS.get(id);
+  return workflow ? cloneWorkflowDefinition(workflow) : void 0;
 }
 function listWorkflows() {
-  return Array.from(WORKFLOWS.values());
+  return Array.from(
+    WORKFLOWS.values(),
+    (workflow) => cloneWorkflowDefinition(workflow)
+  );
+}
+function getWorkflowDescriptor(id) {
+  const descriptor = WORKFLOW_DESCRIPTORS.get(id);
+  return descriptor ? cloneWorkflowDescriptor(descriptor) : void 0;
+}
+
+// ../../convex/lib/workflowRun.ts
+function workflowRunOutputToText(output) {
+  switch (output.format) {
+    case "freetext":
+      return output.value;
+    case "list":
+      return output.value.join(", ");
+    case "choice":
+      return Array.isArray(output.value) ? output.value.join(", ") : output.value;
+    case "structured":
+      if (output.value && typeof output.value === "object" && "text" in output.value) {
+        const textValue = output.value.text;
+        if (typeof textValue === "string") {
+          return textValue;
+        }
+      }
+      return JSON.stringify(output.value);
+  }
 }
 
 // src/tools/workflows.ts
-var WORKFLOWS_ACTIONS = ["list", "checkpoint"];
+var WORKFLOWS_ACTIONS = ["list", "checkpoint", "get-run"];
+var jsonValueSchema = z11.lazy(
+  () => z11.union([
+    z11.string(),
+    z11.number(),
+    z11.boolean(),
+    z11.null(),
+    z11.array(jsonValueSchema),
+    z11.record(jsonValueSchema)
+  ])
+);
+var workflowRunOutputInputSchema = z11.union([
+  z11.object({
+    format: z11.literal("freetext"),
+    value: z11.string()
+  }),
+  z11.object({
+    format: z11.literal("list"),
+    value: z11.array(z11.string())
+  }),
+  z11.object({
+    format: z11.literal("choice"),
+    value: z11.union([z11.string(), z11.array(z11.string())])
+  }),
+  z11.object({
+    format: z11.literal("structured"),
+    value: jsonValueSchema
+  })
+]);
 var workflowsSchema = z11.object({
   action: z11.enum(WORKFLOWS_ACTIONS).describe(
-    "'list': browse available workflows. 'checkpoint': record round output or final summary."
+    "'list': browse available workflows. 'checkpoint': record round output or final summary. 'get-run': inspect a persisted workflow run."
   ),
   workflowId: z11.string().optional().describe("Workflow ID for checkpoint, e.g. 'retro'"),
+  runId: z11.string().optional().describe("Workflow run ID to inspect. Optional for action='get-run' when workflowId is provided."),
   roundId: z11.string().optional().describe("Round ID for checkpoint, e.g. 'what-went-well'"),
-  output: z11.string().optional().describe("The round's output \u2014 synthesized by the facilitator"),
-  isFinal: z11.boolean().optional().describe("If true, final checkpoint \u2014 triggers summary chain entry"),
-  summaryName: z11.string().optional().describe("Name for final chain entry (required when isFinal=true)"),
-  summaryDescription: z11.string().optional().describe("Description for final chain entry (required when isFinal=true)")
+  output: z11.union([z11.string(), workflowRunOutputInputSchema]).optional().describe(
+    "The round's output \u2014 either legacy synthesized text or a typed workflow run payload."
+  ),
+  isFinal: z11.boolean().optional().describe("If true, finalize an existing durable workflow run from its terminal round and create the summary chain entry."),
+  restart: z11.boolean().optional().describe("If true, start a new durable run from the workflow's first round in the current session."),
+  summaryName: z11.string().optional().describe("Optional name for final chain entry. If omitted, the workflow summary template is used."),
+  summaryDescription: z11.string().optional().describe("Optional override for the final chain entry description. Defaults to the final round output text.")
 });
 function formatWorkflowCard(wf) {
   const roundList = wf.rounds.map((r) => `  ${r.num}. ${r.label} (${r.type}, ~${r.maxDurationHint ?? "?"})`).join("\n");
+  const descriptor = getWorkflowDescriptor(wf.id);
+  const outputDescription = descriptor ? describeWorkflowPrimaryOutput(descriptor) : wf.kbOutputCollection ? `Primary record routes to \`${wf.kbOutputCollection}\`.` : "Primary output routing is resolved at runtime.";
   return `## ${wf.icon} ${wf.name}
 **ID**: \`${wf.id}\`
 ${wf.shortDescription}
@@ -3196,33 +3476,69 @@ ${wf.shortDescription}
 **Rounds** (${wf.rounds.length}):
 ${roundList}
 
-**Output**: Creates entries in \`${wf.kbOutputCollection}\` collection.
+**Output**: ${outputDescription}
 _Use the \`run-workflow\` prompt with workflow="${wf.id}" to start._`;
 }
+function validateFinalWorkflowCheckpoint(workflow, roundId) {
+  const finalRound = workflow.rounds.at(-1);
+  if (!finalRound) {
+    return `Workflow '${workflow.id}' has no rounds and cannot create a final summary.`;
+  }
+  if (roundId !== finalRound.id) {
+    return `Workflow '${workflow.id}' can only create a final summary from its terminal round '${finalRound.id}' (${finalRound.label}).`;
+  }
+  return null;
+}
 function registerWorkflowTools(server) {
   const workflowsTool = server.registerTool(
     "workflows",
     {
       title: "Workflows",
-      description: "Chainwork workflow discovery and checkpointing. Two actions:\n\n- **list**: Browse available workflows \u2014 retro, shape-a-bet, IDM, etc. Use the `run-workflow` prompt to launch one.\n- **checkpoint**: Record round output during Facilitator Mode. Persists progress. At completion, use isFinal=true to create the summary chain entry.",
+      description: "Chainwork workflow discovery, checkpointing, and run inspection. Three actions:\n\n- **list**: Browse available workflows \u2014 retro, shape-a-bet, IDM, etc. Use the `run-workflow` prompt to launch one.\n- **checkpoint**: Record round output during Facilitator Mode. Persists progress. At completion, some workflows support isFinal=true to create the summary chain entry.\n- **get-run**: Inspect a persisted workflow run by run ID or by workflow ID in the current session.",
       inputSchema: workflowsSchema,
-      annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: false }
+      annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: false }
     },
     withEnvelope(async (args) => {
       const parsed = parseOrFail(workflowsSchema, args);
       if (!parsed.ok) return parsed.result;
-      const { action, workflowId, roundId, output, isFinal, summaryName, summaryDescription } = parsed.data;
+      const {
+        action,
+        workflowId,
+        runId,
+        roundId,
+        output,
+        isFinal,
+        restart,
+        summaryName,
+        summaryDescription
+      } = parsed.data;
       return runWithToolContext({ tool: "workflows", action }, async () => {
         if (action === "list") {
           return handleList3();
         }
+        if (action === "get-run") {
+          if (!runId && !workflowId) {
+            return validationResult(
+              "runId or workflowId is required when action is 'get-run'."
+            );
+          }
+          return handleGetRun(runId, workflowId);
+        }
         if (action === "checkpoint") {
           if (!workflowId || !roundId || output === void 0) {
             return validationResult(
               "workflowId, roundId, and output are required when action is 'checkpoint'."
             );
           }
-          return handleCheckpoint(workflowId, roundId, output, isFinal, summaryName, summaryDescription);
+          return handleCheckpoint(
+            workflowId,
+            roundId,
+            output,
+            isFinal,
+            restart,
+            summaryName,
+            summaryDescription
+          );
         }
         return unknownAction(action, WORKFLOWS_ACTIONS);
       });
@@ -3258,14 +3574,78 @@ ${cards}`
           id: w.id,
           name: w.name,
           rounds: w.rounds.length,
-          outputCollection: w.kbOutputCollection
+          outputCollection: w.kbOutputCollection ?? null
         })),
         total: workflows.length
       }
     )
   };
 }
-async function handleCheckpoint(workflowId, roundId, output, isFinal, summaryName, summaryDescription) {
+async function handleGetRun(runId, workflowId) {
+  let run;
+  if (runId) {
+    run = await mcpQuery("chainwork.getWorkflowRun", {
+      runId
+    });
+  } else {
+    requireActiveSession();
+    const agentSessionId = getAgentSessionId();
+    if (!agentSessionId) {
+      return validationResult(
+        "Active session required for workflow run inspection by workflowId."
+      );
+    }
+    run = await mcpQuery("chainwork.getLatestWorkflowRun", {
+      agentSessionId,
+      workflowId
+    });
+  }
+  if (!run) {
+    const target = runId ? `workflow run '${runId}'` : `workflow '${workflowId}' in the current session`;
+    return validationResult(`No persisted run found for ${target}.`);
+  }
+  if (workflowId && run.workflowId !== workflowId) {
+    return validationResult(
+      `Workflow run '${run.runId}' belongs to workflow '${run.workflowId}', not '${workflowId}'.`
+    );
+  }
+  const stepLines = run.projection.steps.map((step) => {
+    const status = step.status.toUpperCase();
+    const outputSummary = step.output ? ` \u2014 ${workflowRunOutputToText(step.output)}` : "";
+    return `- ${step.num}. ${step.label} [${status}]${outputSummary}`;
+  });
+  const lines = [
+    `# Workflow Run: ${run.workflowName}`,
+    "",
+    `- Run ID: \`${run.runId}\``,
+    `- Workflow ID: \`${run.workflowId}\``,
+    `- Status: ${run.status}`,
+    `- Progress: ${run.projection.completedCount}/${run.projection.totalCount}`,
+    `- Current round: ${run.currentRoundId ? `\`${run.currentRoundId}\`` : "complete"}`,
+    `- Renderable sections: ${Object.keys(run.projection.render.links).length}/${run.projection.render.sections.length}`,
+    `- Started: ${run.startedAt}`,
+    ...run.completedAt ? [`- Completed: ${run.completedAt}`] : [],
+    ...run.summary ? [`- Summary entry: \`${run.summary.entryId}\``] : [],
+    "",
+    "## Steps",
+    ...stepLines
+  ];
+  return {
+    content: [{ type: "text", text: lines.join("\n") }],
+    structuredContent: success(
+      `Loaded workflow run ${run.runId} (${run.workflowName}).`,
+      run,
+      run.summary ? [
+        {
+          tool: "graph",
+          description: "Discover connections for the summary entry",
+          parameters: { action: "suggest", entryId: run.summary.entryId }
+        }
+      ] : void 0
+    )
+  };
+}
+async function handleCheckpoint(workflowId, roundId, output, isFinal, restart, summaryName, summaryDescription) {
   const wf = getWorkflow(workflowId);
   if (!wf) {
     return {
@@ -3306,50 +3686,115 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
     `Workflow: ${wf.name} (\`${wf.id}\`)`,
     ""
   ];
-  if (isFinal && summaryName && summaryDescription) {
+  if (restart && isFinal) {
+    return validationResult(
+      "restart cannot be combined with isFinal. Restart from the first round, then continue the workflow normally."
+    );
+  }
+  let normalizedOutput;
+  try {
+    normalizedOutput = coerceWorkflowRunOutput(round, output);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return validationResult(message);
+  }
+  const outputPreview = workflowRunOutputToText(normalizedOutput);
+  if (isFinal) {
+    const finalCheckpointValidationError = validateFinalWorkflowCheckpoint(
+      wf,
+      roundId
+    );
+    if (finalCheckpointValidationError) {
+      return validationResult(finalCheckpointValidationError);
+    }
+    const descriptor = getWorkflowDescriptor(workflowId);
+    const template = descriptor ? getWorkflowTemplateMetadata(descriptor) : { slug: wf.id, name: wf.name };
+    const summaryCapture = descriptor ? getWorkflowSummaryCaptureDefinition(descriptor) : wf.kbOutputCollection && wf.kbOutputTemplate ? {
+      collection: wf.kbOutputCollection,
+      nameTemplate: wf.kbOutputTemplate.nameTemplate,
+      descriptionField: wf.kbOutputTemplate.descriptionField
+    } : null;
+    if (!summaryCapture) {
+      return validationResult(
+        `Workflow '${workflowId}' does not support final summary capture through workflows.checkpoint. Follow the workflow guidance and use capture directly for its primary record.`
+      );
+    }
     requireWriteAccess();
+    const agentSessionId = getAgentSessionId();
+    if (!agentSessionId) {
+      return validationResult(
+        "Active agent session required for workflow checkpoint persistence."
+      );
+    }
+    const existingRun = await mcpQuery(
+      "chainwork.getLatestWorkflowRun",
+      {
+        agentSessionId,
+        workflowId: wf.id
+      }
+    );
+    if (!existingRun) {
+      return validationResult(
+        `Workflow '${workflowId}' has no durable run to finalize yet. Record checkpoints for the earlier rounds first.`
+      );
+    }
     try {
-      const result = await mcpMutation("chain.createEntry", {
-        collectionSlug: wf.kbOutputCollection,
-        name: summaryName,
-        status: "draft",
-        data: {
-          [wf.kbOutputTemplate.descriptionField]: summaryDescription,
-          workflowType: wf.id,
-          completedRound: roundId,
-          date: (/* @__PURE__ */ new Date()).toISOString().split("T")[0]
+      const result = await mcpMutation("chainwork.finalizeWorkflowRun", {
+        agentSessionId,
+        workflowId: wf.id,
+        workflowName: wf.name,
+        templateSlug: template.slug,
+        templateName: template.name,
+        steps: wf.rounds.map((workflowRound) => ({
+          roundId: workflowRound.id,
+          num: workflowRound.num,
+          label: workflowRound.label,
+          type: workflowRound.type,
+          outputField: workflowRound.outputSchema.field,
+          outputFormat: workflowRound.outputSchema.format
+        })),
+        finalRoundId: roundId,
+        finalOutput: normalizedOutput,
+        summaryCapture: {
+          collection: summaryCapture.collection,
+          nameTemplate: summaryCapture.nameTemplate,
+          descriptionField: summaryCapture.descriptionField,
+          descriptionSource: summaryCapture.descriptionSource
         },
-        createdBy: `workflow:${wf.id}`
+        summaryDescription,
+        summaryName
       });
       lines.push(
-        `**Draft Created**: \`${result.entryId}\``,
-        `Collection: \`${wf.kbOutputCollection}\``,
-        `Name: ${summaryName}`,
+        result.summary.created ? `**Draft Created**: \`${result.summary.entryId}\`` : `**Draft Already Exists**: \`${result.summary.entryId}\``,
+        `Collection: \`${summaryCapture.collection}\``,
+        `Name: ${result.summary.name}`,
         "",
-        `The summary is captured as a draft. Use \`commit-entry entryId="${result.entryId}"\` to promote it to the Chain.`,
-        `Use \`graph action=suggest entryId="${result.entryId}"\` to discover connections.`
+        `The summary is captured as a draft. Use \`commit-entry entryId="${result.summary.entryId}"\` to promote it to the Chain.`,
+        `Use \`graph action=suggest entryId="${result.summary.entryId}"\` to discover connections.`
       );
       return {
         content: [{ type: "text", text: lines.join("\n") }],
         structuredContent: success(
-          `Draft '${summaryName}' created (${result.entryId}) for workflow ${workflowId}.`,
+          `Draft '${result.summary.name}' ${result.summary.created ? "created" : "reused"} (${result.summary.entryId}) for workflow ${workflowId}.`,
           {
-            entryId: result.entryId,
+            entryId: result.summary.entryId,
             workflowId,
             roundId,
-            collection: wf.kbOutputCollection,
-            isFinal: true
+            collection: summaryCapture.collection,
+            isFinal: true,
+            runId: result.runId,
+            created: result.summary.created
           },
           [
             {
               tool: "commit-entry",
               description: "Promote draft to Chain",
-              parameters: { entryId: result.entryId }
+              parameters: { entryId: result.summary.entryId }
             },
             {
               tool: "graph",
               description: "Discover connections",
-              parameters: { action: "suggest", entryId: result.entryId }
+              parameters: { action: "suggest", entryId: result.summary.entryId }
             }
           ]
         )
@@ -3361,9 +3806,9 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
         "",
         `The retro output is preserved in this conversation. `,
         `You can manually create the entry later using \`capture\` with:`,
-        `- Collection: \`${wf.kbOutputCollection}\``,
-        `- Name: ${summaryName}`,
-        `- Description: (copy from the conversation summary above)`
+        `- Collection: \`${summaryCapture.collection}\``,
+        `- Name: ${summaryName ?? summaryCapture.nameTemplate}`,
+        `- Description: ${summaryDescription ?? outputPreview}`
       );
       return {
         content: [{ type: "text", text: lines.join("\n") }],
@@ -3376,42 +3821,122 @@ This checkpoint was NOT saved. The conversation context is preserved \u2014 cont
       };
     }
   } else {
-    lines.push(
-      `Round ${round.num} output recorded.`,
-      `Output: ${output.substring(0, 200)}${output.length > 200 ? "..." : ""}`
-    );
-    const currentIdx = wf.rounds.findIndex((r) => r.id === roundId);
-    let nextRound;
-    if (currentIdx < wf.rounds.length - 1) {
-      const next = wf.rounds[currentIdx + 1];
-      nextRound = { id: next.id, num: next.num, label: next.label };
+    requireWriteAccess();
+    const agentSessionId = getAgentSessionId();
+    if (!agentSessionId) {
+      return validationResult(
+        "Active agent session required for workflow checkpoint persistence."
+      );
+    }
+    try {
+      const descriptor = getWorkflowDescriptor(workflowId);
+      const template = descriptor ? getWorkflowTemplateMetadata(descriptor) : { slug: wf.id, name: wf.name };
+      const checkpointResult = await mcpMutation("chainwork.recordWorkflowCheckpoint", {
+        agentSessionId,
+        workflowId: wf.id,
+        workflowName: wf.name,
+        templateSlug: template.slug,
+        templateName: template.name,
+        steps: wf.rounds.map((workflowRound) => ({
+          roundId: workflowRound.id,
+          num: workflowRound.num,
+          label: workflowRound.label,
+          type: workflowRound.type,
+          outputField: workflowRound.outputSchema.field,
+          outputFormat: workflowRound.outputSchema.format
+        })),
+        checkpoint: {
+          roundId,
+          output: normalizedOutput,
+          recordedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        restart
+      });
       lines.push(
-        "",
-        `**Next**: Round ${next.num} \u2014 ${next.label}`,
-        `_${next.instruction}_`
+        `Round ${round.num} output recorded.`,
+        `Output: ${outputPreview.substring(0, 200)}${outputPreview.length > 200 ? "..." : ""}`,
+        `Progress: ${checkpointResult.projection.completedCount}/${checkpointResult.projection.totalCount} rounds completed.`
       );
-    } else {
+      const nextWorkflowRound = checkpointResult.projection.currentRoundId ? wf.rounds.find((workflowRound) => workflowRound.id === checkpointResult.projection.currentRoundId) : void 0;
+      const nextRound = nextWorkflowRound ? { id: nextWorkflowRound.id, num: nextWorkflowRound.num, label: nextWorkflowRound.label } : void 0;
+      if (nextWorkflowRound) {
+        lines.push(
+          "",
+          `**Next**: Round ${nextWorkflowRound.num} \u2014 ${nextWorkflowRound.label}`,
+          `_${nextWorkflowRound.instruction}_`
+        );
+      } else {
+        lines.push(
+          "",
+          `**All rounds complete.** Call this tool again with \`isFinal: true\` to commit to the Chain.`
+        );
+      }
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: success(
+          `Round ${round.num} (${round.label}) output recorded for workflow ${workflowId}.`,
+          {
+            workflowId,
+            roundId,
+            roundNum: round.num,
+            roundLabel: round.label,
+            isFinal: false,
+            nextRound,
+            runId: checkpointResult.runId,
+            runStatus: checkpointResult.run.status,
+            progress: {
+              completedCount: checkpointResult.projection.completedCount,
+              totalCount: checkpointResult.projection.totalCount
+            }
+          }
+        )
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
       lines.push(
+        `**Checkpoint persistence failed**: ${msg}`,
         "",
-        `**All rounds complete.** Call this tool again with \`isFinal: true\` to commit to the Chain.`
+        `The conversation context is preserved, but this round was not saved as a durable workflow checkpoint.`
       );
+      return {
+        content: [{ type: "text", text: lines.join("\n") }],
+        structuredContent: failure(
+          "BACKEND_ERROR",
+          `Workflow checkpoint persistence failed: ${msg}.`,
+          "Continue the workflow in conversation or retry the checkpoint."
+        )
+      };
     }
-    return {
-      content: [{ type: "text", text: lines.join("\n") }],
-      structuredContent: success(
-        `Round ${round.num} (${round.label}) output recorded for workflow ${workflowId}.`,
-        {
-          workflowId,
-          roundId,
-          roundNum: round.num,
-          roundLabel: round.label,
-          isFinal: false,
-          nextRound
-        }
-      )
-    };
   }
 }
+function coerceWorkflowRunOutput(round, output) {
+  if (typeof output !== "string") {
+    assertWorkflowRunOutputMatchesRound(round, output);
+    return output;
+  }
+  const trimmed = output.trim();
+  switch (round.outputSchema.format) {
+    case "freetext":
+      return { format: "freetext", value: trimmed };
+    case "list":
+      return { format: "list", value: parseListOutput(trimmed) };
+    case "choice":
+      return { format: "choice", value: trimmed };
+    case "structured":
+      return { format: "structured", value: { text: trimmed } };
+  }
+}
+function assertWorkflowRunOutputMatchesRound(round, output) {
+  if (output.format !== round.outputSchema.format) {
+    throw new Error(
+      `Round '${round.id}' expects '${round.outputSchema.format}' output, received '${output.format}'.`
+    );
+  }
+}
+function parseListOutput(output) {
+  const lines = output.split("\n").map((line) => line.trim()).filter(Boolean).map((line) => line.replace(/^[-*]\s+/, "").replace(/^\d+\.\s+/, "").trim()).filter(Boolean);
+  return lines.length > 0 ? lines : [output];
+}
 
 // src/tools/facilitate.ts
 import { z as z12 } from "zod";
@@ -5533,7 +6058,7 @@ async function handleCommitConstellation(args) {
   }
   let contradictionWarnings = [];
   try {
-    const { runContradictionCheck } = await import("./smart-capture-2IM2565I.js");
+    const { runContradictionCheck } = await import("./smart-capture-3OXWEXWM.js");
     const descField = betData.problem ?? betData.description ?? "";
     contradictionWarnings = await runContradictionCheck(
       betEntry.name ?? betId,
@@ -10363,6 +10888,7 @@ Make sure the rule is consistent with existing rules and doesn't contradict them
     },
     async ({ workflow: workflowId, context }) => {
       const wf = getWorkflow(workflowId);
+      const descriptor = getWorkflowDescriptor(workflowId);
       if (!wf) {
         const available = listWorkflows().map((w) => `- **${w.id}**: ${w.name} \u2014 ${w.shortDescription}`).join("\n");
         return {
@@ -10383,15 +10909,18 @@ Use one of these IDs to run a workflow.`
         };
       }
       let kbContext = "";
+      const contextCollection = descriptor ? getWorkflowContextCollection(descriptor) : wf.kbOutputCollection ?? null;
       try {
-        const recentDecisions = await mcpQuery("chain.listEntries", {
-          collectionSlug: wf.kbOutputCollection
-        });
-        const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
-        if (sorted.length > 0) {
-          kbContext = `
-## Recent ${wf.kbOutputCollection} entries (for context)
+        if (contextCollection) {
+          const recentDecisions = await mcpQuery("chain.listEntries", {
+            collectionSlug: contextCollection
+          });
+          const sorted = [...recentDecisions].sort((a, b) => (b.data?.date ?? "") > (a.data?.date ?? "") ? 1 : -1).slice(0, 5);
+          if (sorted.length > 0) {
+            kbContext = `
+## Recent ${contextCollection} entries (for context)
 ` + sorted.map((d) => `- ${d.entryId ?? ""}: ${d.name} [${d.status}]`).join("\n");
+          }
         }
       } catch {
         kbContext = "\n_Could not load chain context \u2014 proceed without it._";
@@ -10405,12 +10934,34 @@ Use one of these IDs to run a workflow.`
           (q) => `**Question**: ${q.prompt}
 ` + (q.options ? q.options.map((o) => `  - ${o.id}: ${o.label}`).join("\n") : "  _(open response)_")
         ).join("\n") : "") + `
-**Output**: Capture to \`${r.outputSchema.field}\` (${r.outputSchema.format})`
+**Output**: Capture to \`${r.outputSchema.field}\` (${r.outputSchema.format})
+**Checkpoint**: Immediately persist this round with \`workflows action="checkpoint" workflowId="${wf.id}" roundId="${r.id}"\``
       ).join("\n\n---\n\n");
       const contextLine = context ? `
 The participant provided this context: "${context}"
 Use it \u2014 don't make them repeat themselves.
 ` : "";
+      const outputDescription = descriptor ? describeWorkflowPrimaryOutput(descriptor) : wf.kbOutputCollection ? `Primary record routes to \`${wf.kbOutputCollection}\`.` : "Primary output routing is resolved at runtime.";
+      const summaryCapture = descriptor ? getWorkflowSummaryCaptureDefinition(descriptor) : wf.kbOutputCollection && wf.kbOutputTemplate ? {
+        collection: wf.kbOutputCollection,
+        nameTemplate: wf.kbOutputTemplate.nameTemplate,
+        descriptionField: wf.kbOutputTemplate.descriptionField
+      } : null;
+      const chainOutputBlock = summaryCapture ? `Primary record routes to \`${summaryCapture.collection}\`.
+Summary capture template: ${summaryCapture.nameTemplate}
+Description field: ${summaryCapture.descriptionField}
+` : `Primary output: ${outputDescription}
+Use the workflow guidance to capture the primary record directly rather than relying on final summary auto-capture.
+`;
+      const checkpointingBlock = `## Checkpointing & Resume
+
+This workflow now supports durable workflow runs.
+1. Before starting, check for an existing run in the current session with \`workflows action="get-run" workflowId="${wf.id}"\`.
+2. If an active run exists, resume from its \`currentRoundId\` instead of restarting the workflow.
+3. After completing EACH round, immediately call \`workflows action="checkpoint" workflowId="${wf.id}" roundId="<round-id>" output=<round-output>\`.
+4. Only call \`isFinal: true\` from the terminal round when the workflow supports summary capture.
+5. If a checkpoint fails, say so explicitly and continue the conversation as backup.
+`;
       return {
         messages: [
           {
@@ -10429,6 +10980,9 @@ ${wf.facilitatorPreamble}
 
 ---
 
+${checkpointingBlock}
+---
+
 ## Rounds
 
 ${roundsPlan}
@@ -10443,10 +10997,7 @@ ${wf.errorRecovery}
 
 ## Chain Output
 
-When complete, use \`capture\` to create a \`${wf.kbOutputCollection}\` entry.
-Name template: ${wf.kbOutputTemplate.nameTemplate}
-Description field: ${wf.kbOutputTemplate.descriptionField}
-` + kbContext + `
+` + chainOutputBlock + kbContext + `
 
 ---
 
@@ -11045,4 +11596,4 @@ export {
   SERVER_VERSION,
   createProductBrainServer
 };
-//# sourceMappingURL=chunk-SCSEEERT.js.map
+//# sourceMappingURL=chunk-QUWYOGHB.js.map