@selesai/code 0.5.16 → 0.5.17

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;
 }
@@ -112,10 +110,15 @@ const WORKFLOW_ARTIFACT_TOOL = "write_workflow_artifact";
 // 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
@@ -461,7 +464,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");
 }
 
@@ -538,6 +541,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 +711,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) => {
@@ -932,7 +926,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 = {
@@ -102,16 +102,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

@@ -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 {

package/dist/skills/workflow-creation/SKILL.md

@@ -33,7 +33,7 @@ Done when every proposed behavior has one owner: state machine, shared adapter,
 For a new mode, add `src/extensions/workflow/modes/<name>.ts`, modeled on `quick.ts`, with only `WorkflowConfig` and `WorkflowModeRegistration`:
 
 - ordered phases, phase artifacts, prompts, validators, close artifacts/validators;
-- unique mode/status/entry identities and start/resume/end tool plus slash-command names;
+- unique mode/status/entry identities and slash-command name; shared start/resume/end tools select the mode;
 - prompts that name exact artifact paths and use `write_workflow_artifact` only for workflow artifacts.
 
 Register the mode once in `MODES` in `extension.ts`; document its lifecycle and commands in `docs/workflows.md`.
@@ -47,7 +47,7 @@ The shared adapter owns UUID artifact directories, atomic saves, resume, loop re
 - Persisted state changes after start, artifact/loop transition, resume reconciliation, and explicit end.
 - Never auto-resume on `session_start`; an explicit selector attaches a run.
 - Artifact completion advances durable state then stops the parent turn; the user deliberately continues the attached mode.
-- Terminal-ready stays active. Only `end_<mode>_workflow` marks the record completed and terminates.
+- Terminal-ready stays active. Only `end_workflow({ mode })` marks the record completed and terminates.
 - One `ExtensionAPI` hosts all modes: shared writer once, stale reload handlers inert, one attached run total.
 - Builder/reviewer loops use adapter-owned rounds, review files, markers, and max-iteration pause.
 

package/docs/workflows.md

@@ -20,8 +20,8 @@ src/extensions/workflow/
 - **`state-machine.ts`** is the deep module. It owns the phase graph, artifact gating, skip rules, the terminal close gate, and the reentrancy guard. It imports nothing external — no `node:fs`, no pi API, no `pi-tui`, no `typebox`. Every method returns a `WorkflowEffect` (a discriminated union in domain vocabulary) that the adapter pattern-matches on.
 - **`adapter.ts`** is the thin glue. It owns Pi/fs wiring, durable state, explicit resume, loop review persistence, and the git-based `reuse` skip predicate. Parent-written artifacts advance durable phase state. `prototype` and `quick` stop at user-controlled boundaries; `task` queues its build loop as soon as its plan is ready.
 - **`workflow.json`** in each artifact directory is the canonical, versioned run record. It is atomically replaced after state changes; session custom entries are only pointers for UI/history and never reconstruct an active run.
-- **`extension.ts`** imports each mode's registration object and calls `createWorkflowExtension(config, options)(pi)` for each, so one extension load resolves a single shared writer tool + one start/end tool pair per mode.
-- **A mode file** is pure data: the phase list, the per-phase artifact filenames, the per-phase prompt generators, the terminal close artifacts, and identity strings (tool names, command name, status key, entry type). Prompts are functions that receive `{ artifactDir, userPrompt }` and return a string. Each mode exports a `WorkflowModeRegistration` object (e.g. `prototypeMode`, `quickMode`); it does not call `createWorkflowExtension` itself.
+- **`extension.ts`** imports each mode's registration object and calls `createWorkflowExtension(config, options)(pi)` for each. One extension load registers one shared writer plus `start_workflow`, `resume_workflow`, and `end_workflow`; each lifecycle call selects a mode.
+- **A mode file** is pure data: the phase list, per-phase artifact filenames, prompt generators, terminal close artifacts, and command/status/entry identities. Prompts receive `{ artifactDir, userPrompt }`. Each mode exports a `WorkflowModeRegistration` object (e.g. `prototypeMode`, `quickMode`); it does not call `createWorkflowExtension` itself.
 
 ## To add a future mode
 
@@ -91,16 +91,6 @@ export const rigorousMode: WorkflowModeRegistration = {
   commandName: "rigorous",
   commandDescription:
     "Run the rigorous workflow (grill → spec → research → plan → reuse → handoff → loop → audit → sign-off)",
-  toolNames: {
-    start: "start_rigorous_workflow",
-    resume: "resume_rigorous_workflow",
-    end: "end_rigorous_workflow",
-  },
-  toolLabels: {
-    start: "Start Rigorous Workflow",
-    resume: "Resume Rigorous Workflow",
-    end: "End Rigorous Workflow",
-  },
 };
 
 export default rigorousMode;
@@ -116,15 +106,15 @@ import { rigorousMode } from "./modes/rigorous.ts";
 const MODES = [prototypeMode, quickMode, rigorousMode] as const;
 ```
 
-That's it. The loader picks it up at boot (`package.json` loads only `./extension.ts`); start/resume/end tools and the `/rigorous` command are registered automatically. There is no `next` tool — phases auto-advance as artifacts land and only the `end` tool completes the terminal phase.
+That's it. The loader picks it up at boot (`package.json` loads only `./extension.ts`); the shared lifecycle tools accept `mode: "rigorous"`, and the `/rigorous` command is registered automatically. There is no `next` tool — phases auto-advance as artifacts land and only `end_workflow({ mode: "rigorous" })` completes the terminal phase.
 
 ## Built-in modes
 
 ### `task` — plan → codebase exploration → handoff → build/review loop
 
-Task now follows the same phase shape as the other modes, minus grilling/research/audit: an architect subagent produces a validated `plan.md`, an optional explorer subagent produces `reuse.md`, a recapper subagent produces a validated `handoff.md`, and then a builder↔commentator review loop runs (max 3 blocking rounds). A clean review makes the workflow terminal-ready; `end_task_workflow` completes it.
+Task now follows the same phase shape as the other modes, minus grilling/research/audit: an architect subagent produces a validated `plan.md`, an optional explorer subagent produces `reuse.md`, a recapper subagent produces a validated `handoff.md`, and then a builder↔commentator review loop runs (max 3 blocking rounds). A clean review makes the workflow terminal-ready; `end_workflow({ mode: "task" })` completes it.
 
-Lifecycle: `plan → reuse → handoff → loop (build ↔ review) → terminal-ready → end_task_workflow`
+Lifecycle: `plan → reuse → handoff → loop (build ↔ review) → terminal-ready → end_workflow({ mode: "task" })`
 
 - `/workflow-task <goal>` — start a new run
 - `/workflow-task resume` — list and resume active runs
@@ -154,8 +144,6 @@ The second argument to `createWorkflowExtension`:
 
 | Field | Description |
 |---|---|
-| `toolNames` | `{ start, resume, end }` — registered tool names. Artifacts advance phase state; the user explicitly continues the attached run. |
-| `toolLabels` | Human-readable labels for the tools. |
 | `commandName` | The `/<command>` name users type to kick off the workflow. |
 | `commandDescription` | Description shown in the command list. |
 
@@ -165,14 +153,14 @@ Each started workflow receives a UUID artifact directory under `.selesai/artifac
 
 Runs are **never** auto-resumed on session start. At most one run can be attached to a Pi instance, but older active runs remain resumable:
 
-- `resume_workflow({ run: "<id-or-path>" })` / `resume_quick_workflow(...)` / `resume_task_workflow(...)`
+- `start_workflow({ mode, goal })`, `resume_workflow({ mode, run: "<id-or-path>" })`, and `end_workflow({ mode })`, where `mode` is `prototype`, `quick`, or `task`
 - `/workflow-prototype resume <id-or-artifact-dir-or-workflow.json>` / `/workflow-quick resume ...` / `/workflow-task resume ...`
 - `/workflow-prototype resume`, `/workflow-quick resume`, or `/workflow-task resume` lists active runs (and offers a UI picker when available).
 - `/workflow-prototype help`, `/workflow-quick help`, or `/workflow-task help` shows the start, resume, continue, and explicit-completion lifecycle.
 
 Resume validates the selected file is under the artifacts base, belongs to that mode, is active, and matches its containing directory. It reconciles the current expected artifact once before emitting the current prompt, covering a crash after `write_workflow_artifact` writes the file but before the phase-state write. Artifact writes do not inject the next phase prompt or launch the next subagent; they terminate the parent turn and wait for the user to continue. A mode can opt out of that pause after a parent artifact write; `task` does so at every parent-owned artifact boundary (`plan.md`, `reuse.md`, `handoff.md`) so the build loop starts immediately after a valid handoff. Corrupt records are skipped during discovery.
 
-A valid terminal artifact makes a workflow **terminal-ready**; it does not complete the run. Call the mode-specific `end_*_workflow` tool to write `status: "completed"`, append the done entry, and terminate. This is the only completion path.
+A valid terminal artifact makes a workflow **terminal-ready**; it does not complete the run. Call `end_workflow({ mode })` to write `status: "completed"`, append the done entry, and terminate. This is the only completion path.
 
 ## Artifact ownership
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@selesai/code",
-	"version": "0.5.16",
+	"version": "0.5.17",
 	"description": "Maintained, extension-first Pi coding agent with built-in workflows, subagents, web research, questions, skills, and an enhanced terminal UI.",
 	"type": "module",
 	"repository": {