@selesai/code 0.5.16 → 0.5.18

package/dist/extensions/workflow/adapter.ts

@@ -88,8 +88,6 @@ function disableSubagentOutput(input: Record<string, unknown>): void {
 }
 
 export interface WorkflowAdapterOptions {
-  toolNames: { start: string; resume: string; end: string };
-  toolLabels: { start: string; resume: string; end: string };
   commandName: string;
   commandDescription: string;
 }
@@ -108,14 +106,20 @@ interface WorkflowController {
 }
 
 const WORKFLOW_ARTIFACT_TOOL = "write_workflow_artifact";
+const WORKFLOW_CONTROL_MESSAGE = "selesai-workflow-control";
 // ponytail: shared across all module copies so prototype + quick registration
 // can race. Module-level state alone is not enough when the loader runs each
 // extension in its own module record.
 const WORKFLOW_GLOBAL = Symbol.for("selesai.workflow.registry.v1");
-type WorkflowRegistry = { controllers: WorkflowController[]; writerRegisteredFor: WeakSet<object> };
+type WorkflowRegistry = {
+  controllers: WorkflowController[];
+  writerRegisteredFor: WeakSet<object>;
+  toolsRegisteredFor: WeakSet<object>;
+};
 const registry: WorkflowRegistry = ((globalThis as any)[WORKFLOW_GLOBAL] ??= {
   controllers: [],
   writerRegisteredFor: new WeakSet(),
+  toolsRegisteredFor: new WeakSet(),
 });
 
 // ponytail: tests call this between cases to drop pi references and reset
@@ -371,21 +375,43 @@ function applyFooter(ctx: ExtensionContext, footer: FooterState): void {
   ctx.ui.setStatus(footer.statusKey, footerText(footer, ctx));
 }
 
-function continueAgent(pi: ExtensionAPI, ctx: ExtensionContext, prompt: string): void {
-  // ponytail: agent is mid-turn (streaming) when tool_result fires, so a bare
-  // sendUserMessage() throws "Agent is already processing". deliverAs:"followUp"
-  // is the framework-native continuation. In idle state (e.g. session resume)
-  // it sends a direct turn.
-  if (ctx.isIdle()) {
-    pi.sendUserMessage(prompt);
-  } else {
-    pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+function continueAgent(pi: ExtensionAPI, _ctx: ExtensionContext, prompt: string): void {
+  // Engine prompts are hidden custom messages. steer delivers after the current
+  // tool batch; triggerTurn starts the continuation when the agent is idle.
+  pi.sendMessage(
+    { customType: WORKFLOW_CONTROL_MESSAGE, content: prompt, display: false },
+    { triggerTurn: true, deliverAs: "steer" },
+  );
+}
+
+function isSoleToolCall(ctx: ExtensionContext, toolCallId: unknown): boolean {
+  if (typeof toolCallId !== "string") return false;
+  try {
+    const manager = (ctx as any)?.sessionManager;
+    if (!manager || typeof manager.getBranch !== "function") return false;
+    const entries = manager.getBranch();
+    if (!Array.isArray(entries)) return false;
+    const assistant = [...entries].reverse().find((entry: any) =>
+      entry?.type === "message" && entry.message?.role === "assistant",
+    )?.message;
+    if (!assistant || !Array.isArray(assistant.content)) return false;
+    const calls = assistant.content.filter((part: any) => part?.type === "toolCall");
+    return calls.length === 1 && calls[0]?.id === toolCallId;
+  } catch {
+    return false;
   }
 }
 
-// ponytail: apply side effects for effects that carry entry/footer/prompt.
-// Terminal/blocked/idle/noOp/alreadyActive carry none — the adapter's call
-// site formats the tool result from the effect's domain fields + config.
+function transitionBatchBlock(ctx: ExtensionContext, toolCallId: unknown): { block: true; reason: string } | undefined {
+  if (isSoleToolCall(ctx, toolCallId)) return undefined;
+  return {
+    block: true,
+    reason: "Workflow transition tools must be called alone. Retry this call without any other tool calls in the same assistant turn.",
+  };
+}
+
+// Apply side effects for effects that carry entry/footer/prompt. Engine prompts
+// are hidden custom messages; tool results remain concise and user-facing.
 function applyEffect(
   pi: ExtensionAPI,
   ctx: ExtensionContext,
@@ -461,7 +487,7 @@ function commandHelp(config: WorkflowConfig, options: WorkflowAdapterOptions): s
     `${command} resume — list resumable runs.`,
     `${command} resume <run-id|artifact-dir|workflow.json> — explicitly resume one.`,
     `Phases advance when their artifacts are written. Runs never auto-resume after reload.`,
-    `Only one run may be attached; ${options.toolNames.end} explicitly completes a terminal-ready run.`,
+    "Only one run may be attached; end_workflow explicitly completes a terminal-ready run.",
   ].join("\n");
 }
 
@@ -506,11 +532,10 @@ function registerSharedArtifactWriter(pi: ExtensionAPI): void {
           details: { mode: controller.config.mode, phase: snap.phase, path, persistenceError: true },
         };
       }
-      // Most workflows pause at a user-controlled artifact boundary. Task's
-      // plan → reuse → handoff → loop transitions queue the next phase prompt
-      // immediately when continueAfterArtifact is true.
-      const queueNextPhase = controller.config.continueAfterArtifact === true && eff.kind === "advanced";
-      applyControllerEffect(controller, ctx, eff, { queuePrompt: queueNextPhase });
+      // Every valid artifact boundary is an engine transition. Queue exactly
+      // one hidden continuation and terminate this assistant turn.
+      const transition = eff.kind === "advanced" || eff.kind === "terminalReady" || eff.kind === "terminalNeedsArtifacts";
+      applyControllerEffect(controller, ctx, eff, { queuePrompt: transition });
       if (eff.kind === "blocked" && eff.reason) {
         return {
           content: [{ type: "text", text: `Wrote ${path}, but it is not approved: ${eff.reason}. Re-write it via write_workflow_artifact to add the required marker.` }],
@@ -520,14 +545,10 @@ function registerSharedArtifactWriter(pi: ExtensionAPI): void {
       const advanced = eff.kind === "advanced";
       return {
         content: [{ type: "text", text: advanced
-          ? queueNextPhase
-            ? `Wrote ${path}. Phase advanced to ${eff.phase}; the next workflow phase is queued.`
-            : `Wrote ${path}. Phase advanced to ${eff.phase}; wait for the user to continue the workflow.`
+          ? `Wrote ${path}. Phase advanced to ${eff.phase}; the next workflow phase is queued.`
           : `Wrote ${path}.` }],
         details: { mode: controller.config.mode, phase: snap.phase, path, file, advanced },
-        // Stop only at user-controlled boundaries. Task deliberately queues
-        // its loop prompt, so terminating here would discard that continuation.
-        terminate: advanced && !queueNextPhase,
+        terminate: transition,
       };
     },
     renderResult(result, _options, theme) {
@@ -538,6 +559,156 @@ function registerSharedArtifactWriter(pi: ExtensionAPI): void {
   } satisfies ToolDefinition);
 }
 
+function controllerForMode(pi: ExtensionAPI, mode: string): WorkflowController | undefined {
+  return registry.controllers.find((controller) =>
+    controller.pi === pi && controller.config.mode === mode && isRegisteredController(controller),
+  );
+}
+
+function unknownMode(mode: string) {
+  return {
+    content: [{ type: "text" as const, text: `Unknown workflow mode: ${mode}. Use an installed mode (prototype, quick, or task).` }],
+    details: { rejected: true, mode },
+  };
+}
+
+async function startController(controller: WorkflowController, goal: string, ctx: ExtensionContext) {
+  const { pi, config, sm, deps } = controller;
+  const other = activeControllersFor(pi).find((candidate) => candidate.sm !== sm);
+  if (other) {
+    return {
+      content: [{ type: "text" as const, text: `A ${other.config.mode} workflow is already active (phase: ${other.sm.snapshot.phase}). Close it before starting ${config.mode}.` }],
+      details: { phase: other.sm.snapshot.phase, alreadyActive: true },
+    };
+  }
+  const before = checkpoint(controller);
+  const eff = await sm.start(goal, deps);
+  if (eff.kind === "started") {
+    controller.run = {
+      version: 1,
+      id: basename(sm.snapshot.artifactDir),
+      mode: config.mode,
+      status: "active",
+      goal: sm.snapshot.userPrompt,
+      artifactDir: sm.snapshot.artifactDir,
+      phase: sm.snapshot.phase,
+      autoArmed: sm.snapshot.autoArmed,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    };
+    try {
+      await persistAfter(controller, before);
+    } catch (error) {
+      return {
+        content: [{ type: "text" as const, text: `Could not start durable workflow: ${error instanceof Error ? error.message : String(error)}` }],
+        details: { persistenceError: true },
+      };
+    }
+    controller.seenToolCallIds.clear();
+    controller.lastBlockedKey = undefined;
+  }
+  applyControllerEffect(controller, ctx, eff, { queuePrompt: false });
+  if (eff.kind === "alreadyActive") {
+    return {
+      content: [{ type: "text" as const, text: `A ${config.mode} workflow is already active (phase: ${eff.phase}). Do not call start_workflow again. Phases auto-advance as artifacts land; call end_workflow only from the final phase.` }],
+      details: { phase: eff.phase, alreadyActive: true },
+    };
+  }
+  return {
+    content: [{ type: "text" as const, text: `${config.footerLabel} workflow started. ${eff.prompt}` }],
+    details: { mode: config.mode, phase: eff.phase },
+  };
+}
+
+async function endController(controller: WorkflowController, ctx: ExtensionContext) {
+  const { config, sm, deps } = controller;
+  const before = checkpoint(controller);
+  const eff = await sm.end(deps);
+  if (eff.kind === "closed") {
+    try {
+      await persistAfter(controller, before);
+    } catch (error) {
+      return {
+        content: [{ type: "text" as const, text: `Cannot end: workflow state could not be persisted: ${error instanceof Error ? error.message : String(error)}` }],
+        details: { persistenceError: true },
+      };
+    }
+  }
+  applyControllerEffect(controller, ctx, eff);
+  if (eff.kind === "closed") {
+    controller.seenToolCallIds.clear();
+    controller.lastBlockedKey = undefined;
+    return {
+      content: [{ type: "text" as const, text: `Workflow ended and closed. It can no longer be used. Artifacts saved at ${eff.artifactDir}.` }],
+      details: { closed: true, mode: config.mode, phase: eff.phase, artifactDir: eff.artifactDir },
+      terminate: true,
+    };
+  }
+  if (eff.kind === "endBlocked") {
+    if (eff.reason) {
+      return {
+        content: [{ type: "text" as const, text: `Cannot end: ${eff.missing} is incomplete: ${eff.reason}.` }],
+        details: { mode: config.mode, phase: eff.phase, blocked: eff.missing, reason: eff.reason },
+      };
+    }
+    const isArtifactFile = !eff.missing.includes(" ") && eff.missing.includes(".");
+    const hint = isArtifactFile
+      ? ` Write ${sm.snapshot.artifactDir}/${eff.missing} first.`
+      : ` Continue through the phases to ${config.phases[config.phases.length - 1]}.`;
+    return {
+      content: [{ type: "text" as const, text: `Cannot end: ${eff.missing}.${hint}` }],
+      details: { mode: config.mode, phase: eff.phase, blocked: eff.missing },
+    };
+  }
+  return {
+    content: [{ type: "text" as const, text: `No active ${config.mode} workflow to end.` }],
+    details: { active: false, mode: config.mode },
+  };
+}
+
+function registerSharedWorkflowTools(pi: ExtensionAPI): void {
+  if (registry.toolsRegisteredFor.has(pi)) return;
+  registry.toolsRegisteredFor.add(pi);
+  pi.registerTool({
+    name: "start_workflow",
+    label: "Start Workflow",
+    description: "Start a durable workflow. Select prototype, quick, or task; do not call while another workflow is active.",
+    parameters: Type.Object({
+      mode: Type.String({ description: "Workflow mode: prototype, quick, task, or another installed mode." }),
+      goal: Type.String(),
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const controller = controllerForMode(pi, params.mode);
+      return controller ? startController(controller, params.goal, ctx) : unknownMode(params.mode);
+    },
+  } satisfies ToolDefinition);
+  pi.registerTool({
+    name: "resume_workflow",
+    label: "Resume Workflow",
+    description: "Resume a durable workflow by mode and selected run id, artifact directory, or workflow.json path.",
+    parameters: Type.Object({
+      mode: Type.String({ description: "Workflow mode: prototype, quick, task, or another installed mode." }),
+      run: Type.String(),
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const controller = controllerForMode(pi, params.mode);
+      return controller ? resumeController(controller, ctx, params.run, "end_workflow") : unknownMode(params.mode);
+    },
+  } satisfies ToolDefinition);
+  pi.registerTool({
+    name: "end_workflow",
+    label: "End Workflow",
+    description: "Close a terminal-ready durable workflow. Select its mode.",
+    parameters: Type.Object({
+      mode: Type.String({ description: "Workflow mode: prototype, quick, task, or another installed mode." }),
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const controller = controllerForMode(pi, params.mode);
+      return controller ? endController(controller, ctx) : unknownMode(params.mode);
+    },
+  } satisfies ToolDefinition);
+}
+
 export function createWorkflowExtension(
   config: WorkflowConfig,
   options: WorkflowAdapterOptions,
@@ -558,171 +729,12 @@ export function createWorkflowExtension(
     const controller: WorkflowController = { pi, config, sm, deps, seenToolCallIds: new Set() };
     registry.controllers.push(controller);
     registerSharedArtifactWriter(pi);
-    const { start, resume, end } = options.toolNames;
+    registerSharedWorkflowTools(pi);
     const { mode, footerLabel } = config;
+    const end = "end_workflow";
 
-    // ── start tool ──
-    pi.registerTool({
-      name: start,
-      label: options.toolLabels.start,
-      description: `Start the ${mode} workflow for the given goal. Sets up ${config.phases[0]} as the first phase and returns its prompt. Do not call if a workflow is already active.`,
-      parameters: Type.Object({
-        goal: Type.String({
-          description: `What the user wants the ${mode} workflow to build or accomplish.`,
-        }),
-      }),
-      async execute(_id, params, _signal, _onUpdate, ctx) {
-        const other = activeControllersFor(pi).find((c) => c.sm !== sm);
-        if (other) {
-          return {
-            content: [{ type: "text", text: `A ${other.config.mode} workflow is already active (phase: ${other.sm.snapshot.phase}). Close it before starting ${mode}.` }],
-            details: { phase: other.sm.snapshot.phase, alreadyActive: true },
-          };
-        }
-        const before = checkpoint(controller);
-        const eff = await sm.start(params.goal, deps);
-        if (eff.kind === "started") {
-          controller.run = {
-            version: 1,
-            id: basename(sm.snapshot.artifactDir),
-            mode,
-            status: "active",
-            goal: sm.snapshot.userPrompt,
-            artifactDir: sm.snapshot.artifactDir,
-            phase: sm.snapshot.phase,
-            autoArmed: sm.snapshot.autoArmed,
-            createdAt: new Date().toISOString(),
-            updatedAt: new Date().toISOString(),
-          };
-          try {
-            await persistAfter(controller, before);
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Could not start durable workflow: ${error instanceof Error ? error.message : String(error)}` }],
-              details: { persistenceError: true },
-            };
-          }
-          controller.seenToolCallIds.clear();
-          controller.lastBlockedKey = undefined;
-        }
-        // The start tool result already contains the grilling prompt. Queueing
-        // it again creates a duplicate autonomous turn.
-        applyControllerEffect(controller, ctx, eff, { queuePrompt: false });
-        if (eff.kind === "alreadyActive") {
-          return {
-            content: [
-              {
-                type: "text",
-                text: `A ${mode} workflow is already active (phase: ${eff.phase}). Do not call ${start} again. Phases auto-advance as artifacts land; call ${end} only from the final phase.`,
-              },
-            ],
-            details: { phase: eff.phase, alreadyActive: true },
-          };
-        }
-        return {
-          content: [
-            { type: "text", text: `${footerLabel} workflow started. ${eff.prompt}` },
-          ],
-          details: { phase: eff.phase },
-        };
-      },
-      renderResult(_result, _options, theme) {
-        return new Text(
-          theme.fg("warning", `● ${footerLabel} started · 1/${config.phases.length} ${config.phases[0]}`),
-          0,
-          0,
-        );
-      },
-    } satisfies ToolDefinition);
-
-    // ── explicit resume tool ──
-    pi.registerTool({
-      name: resume,
-      label: options.toolLabels.resume,
-      description: `Resume an explicitly selected ${mode} workflow run. Pass a run id, artifact directory, or workflow.json path.`,
-      parameters: Type.Object({ run: Type.String({ description: "Run id, artifact directory, or workflow.json path." }) }),
-      async execute(_id, params, _signal, _onUpdate, ctx) {
-        return resumeController(controller, ctx, params.run, end);
-      },
-      renderResult(result, _options, theme) {
-        const d = result.details as { rejected?: boolean; persistenceError?: boolean; phase?: string };
-        const failed = d.rejected || d.persistenceError;
-        return new Text(theme.fg(failed ? "warning" : "success", failed ? "○ workflow resume rejected" : `✓ workflow resumed · ${d.phase}`), 0, 0);
-      },
-    } satisfies ToolDefinition);
-
-    // ── end tool ──
-    pi.registerTool({
-      name: end,
-      label: options.toolLabels.end,
-      description: `Close the ${mode} workflow. Must be called when the final phase is complete. Marks the workflow finished and stops the agent loop.`,
-      parameters: Type.Object({}),
-      async execute(_id, _params, _signal, _onUpdate, ctx) {
-        const before = checkpoint(controller);
-        const eff = await sm.end(deps);
-        if (eff.kind === "closed") {
-          try {
-            await persistAfter(controller, before);
-          } catch (error) {
-            return {
-              content: [{ type: "text", text: `Cannot end: workflow state could not be persisted: ${error instanceof Error ? error.message : String(error)}` }],
-              details: { persistenceError: true },
-            };
-          }
-        }
-        applyControllerEffect(controller, ctx, eff);
-        if (eff.kind === "closed") {
-          controller.seenToolCallIds.clear();
-          controller.lastBlockedKey = undefined;
-        }
-        switch (eff.kind) {
-          case "closed":
-            return {
-              content: [{ type: "text", text: `Workflow ended and closed. It can no longer be used. Artifacts saved at ${eff.artifactDir}.` }],
-              details: { closed: true, phase: eff.phase, artifactDir: eff.artifactDir },
-              terminate: true,
-            };
-          case "endBlocked": {
-            // ponytail: missing is either a filename (existence failure),
-            // a phase description like "not at terminal (audit)", or — Plan 4 —
-            // a filename whose validator failed (reason set). Only suggest
-            // writing when it's an actual artifact file existence miss.
-            if (eff.reason) {
-              return {
-                content: [{ type: "text", text: `Cannot end: ${eff.missing} is incomplete: ${eff.reason}.` }],
-                details: { phase: eff.phase, blocked: eff.missing, reason: eff.reason },
-              };
-            }
-            const isArtifactFile =
-              !eff.missing.includes(" ") && eff.missing.includes(".");
-            const hint = isArtifactFile
-              ? ` Write ${sm.snapshot.artifactDir}/${eff.missing} first.`
-              : ` Continue through the phases to ${config.phases[config.phases.length - 1]}.`;
-            return {
-              content: [{ type: "text", text: `Cannot end: ${eff.missing}.${hint}` }],
-              details: { phase: eff.phase, blocked: eff.missing },
-            };
-          }
-          default:
-            return {
-              content: [{ type: "text", text: `No active ${mode} workflow to end.` }],
-              details: { active: false },
-            };
-        }
-      },
-      renderResult(result, _options, theme) {
-        const d = result.details as { closed?: boolean; artifactDir?: string };
-        if (!d.closed) {
-          return new Text(theme.fg("dim", "○ no workflow to end"), 0, 0);
-        }
-        return new Text(
-          theme.fg("success", `✓ ${footerLabel} closed · ${d.artifactDir}`),
-          0,
-          0,
-        );
-      },
-    } satisfies ToolDefinition);
-
+    // Workflow lifecycle tools are registered once per Pi instance below.
+    // They dispatch by `mode`; mode-specific tool aliases are intentionally absent.
     // ── session_start: disk state is never auto-attached. A session entry is
     // merely a convenience pointer for rendering a stale-but-useful footer. ──
     pi.on("session_start", async (_event: any, ctx: ExtensionContext) => {
@@ -747,13 +759,23 @@ export function createWorkflowExtension(
       }
     });
 
-    // ── tool_call: enforce parent-owned artifact boundaries. ──
-    pi.on("tool_call", (event: any, _ctx: ExtensionContext) => {
+    // ── tool_call: enforce parent-owned artifact boundaries and exclusive
+    // transition calls. The session manager exposes the current assistant
+    // message, so fail closed when its sole-call shape cannot be proven. ──
+    pi.on("tool_call", (event: any, ctx: ExtensionContext) => {
       if (!isRegisteredController(controller)) return;
       const tool = event.toolName;
-      if (tool !== "subagent" && tool !== "write" && tool !== "edit") return;
       const snap = sm.snapshot;
       if (!snap.active) return;
+      const commentatorTransition = tool === "subagent" &&
+        event.input?.agent === "commentator" && snap.phase === "loop" &&
+        !isSubagentManagementAction(event.input);
+      const endTransition = tool === "end_workflow" && event.input?.mode === mode;
+      if (tool === WORKFLOW_ARTIFACT_TOOL || endTransition || commentatorTransition) {
+        const blocked = transitionBatchBlock(ctx, event.toolCallId);
+        if (blocked) return blocked;
+      }
+      if (tool !== "subagent" && tool !== "write" && tool !== "edit") return;
       if (tool === "write" || tool === "edit") {
         return {
           block: true,
@@ -846,8 +868,11 @@ export function createWorkflowExtension(
       }
       // The only artifact written in this handler is loop-complete.md, which
       // is engine-owned. Parent-written phase artifacts advance inside
-      // write_workflow_artifact instead.
-      applyControllerEffect(controller, ctx, eff);
+      // write_workflow_artifact instead. A clean review is an exclusive
+      // transition boundary, so terminate and let the hidden steer continue.
+      const transition = eff.kind === "advanced" || eff.kind === "terminalReady" || eff.kind === "terminalNeedsArtifacts";
+      applyControllerEffect(controller, ctx, eff, { queuePrompt: transition });
+      return transition ? { terminate: true } : undefined;
     });
 
     // ── /<command> ──
@@ -932,7 +957,7 @@ export function createWorkflowExtension(
           const closed = sm.closeCurrent();
           if (closed) {
             // Detach only: the on-disk active record remains resumable. Only
-            // end_*_workflow writes status: completed.
+            // end_workflow({ mode }) writes status: completed.
             applyEntry(pi, config, { ...closed, done: false }, controller.run);
             ctx.ui.notify(`Detached ${mode} workflow at ${closed.artifactDir}; it remains resumable.`, "info");
           }

package/dist/extensions/workflow/extension.ts

@@ -16,8 +16,6 @@ const MODES = [prototypeMode, quickMode, taskMode] as const;
 export default function workflowModesExtension(pi: ExtensionAPI): void {
   for (const mode of MODES) {
     createWorkflowExtension(mode.config, {
-      toolNames: mode.toolNames,
-      toolLabels: mode.toolLabels,
       commandName: mode.commandName,
       commandDescription: mode.commandDescription,
     })(pi);

package/dist/extensions/workflow/modes/prototype.ts

@@ -135,7 +135,7 @@ Review uncommitted changes for correctness, plan adherence, and over-engineering
 2. If that review lists actionable issues, call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Instruct it to fix every issue in the workspace, never in ${artifactDir}, then return its completion summary inline.
 3. Re-dispatch the commentator and overwrite the parent-owned review artifact through write_workflow_artifact until it ends with WORKFLOW_REVIEW_STATUS: clean.
 
-Once ${artifactDir}/review.md exists and ends with the WORKFLOW_REVIEW_STATUS: clean marker, call end_workflow to complete the workflow.`,
+Once ${artifactDir}/review.md exists and ends with the WORKFLOW_REVIEW_STATUS: clean marker, call end_workflow with { mode: "prototype" } to complete the workflow.`,
 };
 
 const config: WorkflowConfig = {
@@ -172,8 +172,6 @@ export const prototypeMode: WorkflowModeRegistration = {
   commandName: "workflow-prototype",
   commandDescription:
     "Run the prototype workflow (grill → research → plan → reuse → handoff → loop → audit)",
-  toolNames: { start: "start_workflow", resume: "resume_workflow", end: "end_workflow" },
-  toolLabels: { start: "Start Workflow", resume: "Resume Workflow", end: "End Workflow" },
 };
 
 export default prototypeMode;

package/dist/extensions/workflow/modes/quick.ts

@@ -118,7 +118,7 @@ Review uncommitted changes for correctness, plan adherence, and over-engineering
 2. If that review lists actionable issues, call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Instruct it to fix every issue in the workspace, never in ${artifactDir}, then return its completion summary inline.
 3. Re-run the commentator and overwrite the parent-owned review artifact through write_workflow_artifact until it ends with WORKFLOW_REVIEW_STATUS: clean.
 
-Once ${artifactDir}/review.md exists and ends with the WORKFLOW_REVIEW_STATUS: clean marker, call end_quick_workflow to complete the workflow.`,
+Once ${artifactDir}/review.md exists and ends with the WORKFLOW_REVIEW_STATUS: clean marker, call end_workflow with { mode: "quick" } to complete the workflow.`,
 };
 
 const config: WorkflowConfig = {
@@ -152,8 +152,6 @@ export const quickMode: WorkflowModeRegistration = {
   commandName: "workflow-quick",
   commandDescription:
     "Run the quick workflow (grill → plan → reuse → handoff → loop → audit)",
-  toolNames: { start: "start_quick_workflow", resume: "resume_quick_workflow", end: "end_quick_workflow" },
-  toolLabels: { start: "Start Quick Workflow", resume: "Resume Quick Workflow", end: "End Quick Workflow" },
 };
 
 export default quickMode;

package/dist/extensions/workflow/modes/task.ts

@@ -68,7 +68,7 @@ After the builder returns, call the subagent tool with { agent: "commentator", t
   OR
   WORKFLOW_REVIEW_STATUS: blocking
 
-If a review is blocking, call the builder again with the recorded issues. This repeats up to ${loopMaxIterations ?? 3} round(s). When a review is clean, the engine writes loop-complete.md and the workflow becomes terminal-ready. Do NOT write loop-complete.md yourself. Call end_task_workflow to complete the workflow.`,
+If a review is blocking, call the builder again with the recorded issues. This repeats up to ${loopMaxIterations ?? 3} round(s). When a review is clean, the engine writes loop-complete.md and the workflow becomes terminal-ready. Do NOT write loop-complete.md yourself. Call end_workflow with { mode: "task" } to complete the workflow.`,
 };
 
 const config: WorkflowConfig = {
@@ -90,8 +90,6 @@ const config: WorkflowConfig = {
   closeValidators: { "loop-complete.md": loopCompleteValidator },
   closeArtifacts: ["loop-complete.md"],
   loopMaxIterations: 3,
-  // Each parent-owned artifact automatically queues the next phase prompt.
-  continueAfterArtifact: true,
   statusKey: "task",
   entryType: "task-phase",
   footerLabel: "task",
@@ -102,16 +100,6 @@ export const taskMode: WorkflowModeRegistration = {
   commandName: "workflow-task",
   commandDescription:
     "Run the task workflow (plan → reuse → handoff → build↔review loop)",
-  toolNames: {
-    start: "start_task_workflow",
-    resume: "resume_task_workflow",
-    end: "end_task_workflow",
-  },
-  toolLabels: {
-    start: "Start Task Workflow",
-    resume: "Resume Task Workflow",
-    end: "End Task Workflow",
-  },
 };
 
 export default taskMode;

package/dist/extensions/workflow/state-machine.ts

@@ -1,7 +1,7 @@
 // ponytail: pure workflow state machine. No node:fs, no pi API, no pi-tui,
 // no typebox. Transitions are pure given two injected predicates
 // (artifactExists, shouldSkip). Side effects (appendEntry, setStatus,
-// sendUserMessage) are NOT called here — every method returns a domain
+// sendMessage) are NOT called here — every method returns a domain
 // Effect the adapter pattern-matches on and applies. The adapter owns
 // all pi/fs wiring; this module owns the phase graph + gating + reentrancy.
 
@@ -47,8 +47,6 @@ export interface WorkflowModeRegistration {
   config: WorkflowConfig;
   commandName: string;
   commandDescription: string;
-  toolNames: { start: string; resume: string; end: string };
-  toolLabels: { start: string; resume: string; end: string };
 }
 
 export interface WorkflowConfig {
@@ -82,9 +80,6 @@ export interface WorkflowConfig {
   // ponytail: Plan 3 — engine-owned loop. Max review rounds before the loop
   // stops and asks the user instead of silently passing. Default 3.
   loopMaxIterations?: number;
-  // Most workflows pause at artifact boundaries. A mode can opt into queuing
-  // the next phase prompt after the parent writes a valid artifact.
-  continueAfterArtifact?: boolean;
 }
 
 export interface WorkflowDeps {