@selesai/code 0.4.0 → 0.5.1

package/dist/extensions/workflow/adapter.ts

@@ -13,7 +13,7 @@ import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { access, mkdir, readFile, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
-import { basename, isAbsolute, resolve } from "node:path";
+import { basename, resolve } from "node:path";
 
 import {
   WorkflowStateMachine,
@@ -22,7 +22,6 @@ import {
   type WorkflowEffect,
   type WorkflowEntry,
   type FooterState,
-  type Phase,
   type WorkflowSnapshot,
 } from "./state-machine.ts";
 import {
@@ -53,18 +52,6 @@ async function realFileExists(path: string): Promise<boolean> {
   }
 }
 
-// ponytail: phases where one spawned subagent owns the phase artifact. Force
-// the child `output` path; child processes do not share the parent's workflow
-// state, so the parent-scoped write_workflow_artifact tool cannot help there.
-// Plan 5: these are also the single-owner phases — parallel/chain calls are
-// blocked here because one agent must own plan.md / reuse.md / handoff.md /
-// review.md. Loop is engine-owned (Plan 3) and may fan out.
-const FORCE_OUTPUT_PHASES = new Set<Phase>(["plan", "reuse", "handoff", "audit"]);
-
-// ponytail: phases where the parent can save subagent text as the artifact
-// when the child did not write the file itself (dumb/local models).
-const SUBAGENT_FALLBACK_PHASES = new Set<Phase>(["plan", "reuse", "handoff", "audit"]);
-
 function textFromToolResultContent(content: unknown): string | undefined {
   if (!Array.isArray(content)) return undefined;
   const parts: string[] = [];
@@ -77,75 +64,23 @@ function textFromToolResultContent(content: unknown): string | undefined {
   return joined || undefined;
 }
 
-function validatorForPhaseArtifact(config: WorkflowConfig, phase: Phase) {
-  const phaseValidator = config.artifactValidators?.[phase];
-  if (phaseValidator) return phaseValidator;
-  const file = config.phaseArtifacts[phase];
-  if (!file) return undefined;
-  const isTerminal = config.phases[config.phases.length - 1] === phase;
-  if (!isTerminal || !config.closeArtifacts.includes(file)) return undefined;
-  return config.closeValidators?.[file];
-}
-
-function shouldReplaceInvalidArtifact(
-  config: WorkflowConfig,
-  phase: Phase,
-  currentContent: string,
-  fallbackContent: string,
-): boolean {
-  const validator = validatorForPhaseArtifact(config, phase);
-  if (!validator) return false;
-  return !validator(currentContent).ok && validator(fallbackContent).ok;
-}
-
-// ponytail: rewrite the subagent tool input so the child writes its output
-// directly to ${artifactDir}/${file} as an absolute path. Absolute paths pass
-// through resolveSingleOutputPath verbatim, so injectOutputPathSystemPrompt
-// then forces the child to the correct location instead of repo root.
-// Mutates `input` in place (tool_call handlers can patch event.input).
-// No-op unless the workflow is active, in a force-output phase, and the call
-// targets the `subagent` tool. Respects an explicit absolute caller output.
-function forceSubagentOutputToArtifactDir(
-  input: Record<string, unknown>,
-  artifactDir: string,
-  file: string,
-  onlyAgents?: Set<string>,
-): void {
-  const dest = resolve(artifactDir, file);
-  const shouldForce = (agent: string) => !onlyAgents || onlyAgents.has(agent);
-  // Single-agent call: { agent, task, output?, ... }
-  if (typeof input.agent === "string") {
-    if (!shouldForce(input.agent)) return;
-    const existing = input.output;
-    if (typeof existing === "string" && isAbsolute(existing)) return; // caller pinned it
-    input.output = dest;
-    return;
-  }
-  // Top-level parallel: { tasks: [{ agent, output? }, ...] }
+// Mutates a workflow subagent invocation to suppress both its configured
+// default output and any caller-provided child output path. `output: false`
+// preserves the normal inline result, which the parent must write explicitly.
+function disableSubagentOutput(input: Record<string, unknown>): void {
+  if (typeof input.agent === "string") input.output = false;
   if (Array.isArray(input.tasks)) {
     for (const task of input.tasks) {
-      if (task && typeof task === "object" && typeof task.agent === "string" && shouldForce(task.agent)) {
-        const ex = task.output;
-        if (typeof ex === "string" && isAbsolute(ex)) continue;
-        task.output = dest;
-      }
+      if (task && typeof task === "object") task.output = false;
     }
-    return;
   }
-  // Chain: { chain: [{ agent, output?, parallel: [{ agent, output? }] }] }
   if (Array.isArray(input.chain)) {
     for (const step of input.chain) {
       if (!step || typeof step !== "object") continue;
-      if (typeof step.agent === "string" && shouldForce(step.agent)) {
-        const ex = step.output;
-        if (!(typeof ex === "string" && isAbsolute(ex))) step.output = dest;
-      }
+      step.output = false;
       if (Array.isArray(step.parallel)) {
         for (const task of step.parallel) {
-          if (task && typeof task === "object" && typeof task.agent === "string" && shouldForce(task.agent)) {
-            const ex = task.output;
-            if (!(typeof ex === "string" && isAbsolute(ex))) task.output = dest;
-          }
+          if (task && typeof task === "object") task.output = false;
         }
       }
     }
@@ -546,9 +481,10 @@ function registerSharedArtifactWriter(pi: ExtensionAPI): void {
           details: { mode: controller.config.mode, phase: snap.phase, path, persistenceError: true },
         };
       }
-      // A phase boundary is user-controlled: persist and show the new phase,
-      // but do not inject a follow-up turn that immediately starts it.
-      applyControllerEffect(controller, ctx, eff, { queuePrompt: false });
+      // Most workflows pause at a user-controlled artifact boundary. Task's
+      // plan → loop transition queues the builder/review prompt immediately.
+      const queueNextPhase = controller.config.continueAfterArtifact === true && eff.kind === "advanced";
+      applyControllerEffect(controller, ctx, eff, { queuePrompt: queueNextPhase });
       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.` }],
@@ -558,12 +494,14 @@ function registerSharedArtifactWriter(pi: ExtensionAPI): void {
       const advanced = eff.kind === "advanced";
       return {
         content: [{ type: "text", text: advanced
-          ? `Wrote ${path}. Phase advanced to ${eff.phase}; wait for the user to continue the workflow.`
+          ? 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}.` }],
         details: { mode: controller.config.mode, phase: snap.phase, path, file, advanced },
-        // Stop the parent turn at a user-approved artifact boundary. Without
-        // this, the queued phase prompt can immediately launch the next agent.
-        terminate: advanced,
+        // Stop only at user-controlled boundaries. Task deliberately queues
+        // its loop prompt, so terminating here would discard that continuation.
+        terminate: advanced && !queueNextPhase,
       };
     },
     renderResult(result, _options, theme) {
@@ -797,117 +735,38 @@ export function createWorkflowExtension(
       }
     });
 
-    // ── tool_call: enforce workflow boundaries. ──
+    // ── tool_call: enforce parent-owned artifact boundaries. ──
     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;
-      if (tool === "subagent" && isSubagentManagementAction(event.input)) return;
-      const file = config.phaseArtifacts[snap.phase];
       if (tool === "write" || tool === "edit") {
         return {
           block: true,
           reason: `Workflow is active (${mode}/${snap.phase}). Use ${WORKFLOW_ARTIFACT_TOOL} for workflow artifacts; workspace edits must be delegated to subagents.`,
         };
       }
-      if (!file || !event.input || !FORCE_OUTPUT_PHASES.has(snap.phase)) return;
-      // ponytail: Plan 5 — single-owner phases reject parallel/chain. One agent
-      // must own the artifact; tasks/chain split ownership and the output
-      // injector cannot pin one file per agent. Loop is exempt (engine-owned).
-      if (Array.isArray(event.input.tasks) || Array.isArray(event.input.chain)) {
-        return {
-          block: true,
-          reason: `Workflow phase ${snap.phase} expects one subagent owner for ${file}; use a single { agent, task } call, not tasks/chain.`,
-        };
-      }
-      // ponytail: Plan 5 — workflow-spawned subagents run fresh by default so
-      // no hidden parent context leaks into the phase owner. Only override
-      // when the caller explicitly pins a context.
-      if (typeof event.input.context !== "string") {
-        event.input.context = "fresh";
+      if (!isSubagentManagementAction(event.input) && event.input) {
+        // All child results return inline. The parent persists normal phase
+        // artifacts; the loop engine persists its own review files/marker.
+        disableSubagentOutput(event.input);
       }
-      // ponytail: Plan 5 — ban model override on workflow-owned phases. The
-      // workflow, not the parent model, picks the agent; a model pin would
-      // silently change cost/quality without the workflow knowing.
-      if (typeof event.input.model === "string") {
-        return {
-          block: true,
-          reason: `Workflow phase ${snap.phase} does not allow a model override on subagent calls; remove the model parameter.`,
-        };
-      }
-      const onlyAgents = snap.phase === "audit" ? new Set(["commentator", "reviewer"]) : undefined;
-      forceSubagentOutputToArtifactDir(event.input, snap.artifactDir, file, onlyAgents);
     });
 
-    // ── tool_result: auto-advance after subagent/bash artifacts. ──
+    // ── tool_result: only the engine-owned loop persists subagent output. ──
     pi.on("tool_result", async (event: any, ctx: ExtensionContext) => {
       if (!isRegisteredController(controller)) return;
-      if (event.toolName !== "bash" && event.toolName !== "subagent") return;
-      // Both modes receive every tool result. Inactive controllers have no
-      // attached run and must not try to persist ordinary agent activity.
-      if (!sm.snapshot.active) return;
+      if (event.toolName !== "subagent" || event.isError) return;
+      // Parent-owned phases intentionally do nothing here: the main agent must
+      // inspect the inline child result and call write_workflow_artifact.
+      if (!sm.snapshot.active || sm.snapshot.phase !== "loop" || isSubagentManagementAction(event.input)) return;
       const eventBefore = checkpoint(controller);
-      if (sm.snapshot.active && typeof event.toolCallId === "string") {
+      if (typeof event.toolCallId === "string") {
         if (controller.seenToolCallIds.has(event.toolCallId)) return;
         controller.seenToolCallIds.add(event.toolCallId);
       }
-      // Re-check after an error in case the tool wrote its artifact before
-      // failing. The normal tool-result continuation receives the error; do
-      // not inject another parent turn.
-      if (event.isError && sm.snapshot.active) {
-        if (event.toolName === "subagent" && isSubagentManagementAction(event.input)) return;
-        const eff = await sm.onArtifactMaybe(deps);
-        try {
-          await persistAfter(controller, eventBefore);
-        } catch (error) {
-          ctx.ui.notify(`Workflow state was not saved: ${error instanceof Error ? error.message : String(error)}`, "warning");
-          return;
-        }
-        applyControllerEffect(controller, ctx, eff, { queuePrompt: false });
-        if (sm.snapshot.phase !== "loop") {
-          controller.loopState = undefined;
-        }
-        return;
-      }
-      // ponytail: if a subagent returned text but did not write the expected
-      // artifact (common with dumb/local models), save the returned text as
-      // the artifact so the workflow can still advance.
-      if (event.toolName === "subagent" && sm.snapshot.active && SUBAGENT_FALLBACK_PHASES.has(sm.snapshot.phase)) {
-        const phase = sm.snapshot.phase;
-        const file = config.phaseArtifacts[phase];
-        if (file) {
-          // ponytail: management actions (list/get/models/doctor/status/...)
-          // return text but are NOT the architect/recapper/... execution
-          // result. Writing their text to plan.md would advance the workflow
-          // on agent-listing output (the `subagent list` result is plain
-          // text). Execution calls set `agent`/`chain`/`tasks`; management
-          // calls set `action`. Only fall back for execution calls.
-          if (!isSubagentManagementAction(event.input)) {
-            const expectedPath = resolve(sm.snapshot.artifactDir, file);
-            const text = textFromToolResultContent(event.content);
-            if (text) {
-              const validator = validatorForPhaseArtifact(config, phase);
-              let shouldWrite = false;
-              if (!(await realFileExists(expectedPath))) {
-                shouldWrite = !validator || validator(text).ok;
-              } else {
-                try {
-                  const current = await readFile(expectedPath, "utf8");
-                  shouldWrite = shouldReplaceInvalidArtifact(config, phase, current, text);
-                } catch {
-                  shouldWrite = false;
-                }
-              }
-              if (shouldWrite) {
-                await mkdir(sm.snapshot.artifactDir, { recursive: true });
-                await writeFile(expectedPath, text, "utf8");
-              }
-            }
-          }
-        }
-      }
       // The adapter owns durable loop state; the normal subagent tool-result
       // continuation lets the parent choose the next builder/commentator call.
       // No synthetic follow-up chat is queued. loopState clears when the phase
@@ -973,9 +832,10 @@ export function createWorkflowExtension(
         ctx.ui.notify(`Workflow state was not saved: ${error instanceof Error ? error.message : String(error)}`, "warning");
         return;
       }
-      // Do not turn an artifact/subagent result into a new parent turn.
-      // The user resumes the next phase deliberately via the workflow command.
-      applyControllerEffect(controller, ctx, eff, { queuePrompt: false });
+      // 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);
     });
 
     // ── /<command> ──

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

@@ -80,11 +80,11 @@ Produce the concrete build plan for the actual prototype/output — not a plan f
 
 If research was skipped, proceed directly — you already understand the user's intent from grilling.
 
-Call the subagent tool with { agent: "architect", task: "..." } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md and ${artifactDir}/research.md so the architect plans for THIS task. The architect returns the plan; the workflow saves it to ${artifactDir}/plan.md.
+Call the subagent tool with { agent: "architect", task: "...", output: false } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md and ${artifactDir}/research.md so the architect plans for THIS task. It must return the complete plan inline; do not tell it to write any artifact.
 
-The plan MUST end with exactly one machine-readable line on its own:
+Inspect that result, verify it ends with exactly one machine-readable line on its own:
   WORKFLOW_PLAN_STATUS: ready
-The workflow will NOT advance until ${artifactDir}/plan.md contains that marker.`,
+Then immediately call write_workflow_artifact with the complete validated plan as content. Only that parent tool call writes ${artifactDir}/plan.md and advances the workflow.`,
   reuse: ({ artifactDir }) =>
     `You are in the REUSE phase (optional).
 
@@ -92,7 +92,7 @@ Decide whether codebase exploration is useful. Skip if the project is empty, the
 
 If unsure, ask the user one focused question: "Should I explore the existing codebase for reusable patterns before implementing?" Then follow their answer.
 
-If YES (or user confirms): call the subagent tool with { agent: "explorer", task: "..." } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md and ${artifactDir}/plan.md pointing it at relevant areas, patterns, and dependencies (e.g., Tailwind setup, state-machine usage). Synthesize the findings into ${artifactDir}/reuse.md: what is reusable, where, and how to leverage it.
+If YES (or user confirms): call the subagent tool with { agent: "explorer", task: "...", output: false } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md and ${artifactDir}/plan.md pointing it at relevant areas, patterns, and dependencies (e.g., Tailwind setup, state-machine usage). It must return the reuse findings inline; do not tell it to write any artifact. Immediately call write_workflow_artifact with those findings as content for ${artifactDir}/reuse.md.
 
 If NO: call write_workflow_artifact with a brief skip note explaining why.
 
@@ -108,19 +108,19 @@ Draw from all prior phases:
 - ${artifactDir}/plan.md (the build plan)
 - ${artifactDir}/reuse.md (codebase exploration findings)
 
-Call the subagent tool with { agent: "recapper", task: "..." } (do NOT pass a model parameter). Craft the task pointing the recapper at all four artifact files and telling it what the prototype is about. The recapper returns the handoff; the workflow saves it to ${artifactDir}/handoff.md.
+Call the subagent tool with { agent: "recapper", task: "...", output: false } (do NOT pass a model parameter). Craft the task pointing the recapper at all four artifact files and telling it what the prototype is about. It must return the complete handoff inline; do not tell it to write any artifact.
 
-The handoff MUST end with exactly one machine-readable line on its own:
+Inspect that result, verify it ends with exactly one machine-readable line on its own:
   WORKFLOW_HANDOFF_STATUS: ready
-The workflow will NOT advance until ${artifactDir}/handoff.md contains that marker.`,
+Then immediately call write_workflow_artifact with the complete validated handoff as content. Only that parent tool call writes ${artifactDir}/handoff.md and advances the workflow.`,
   loop: ({ artifactDir, loopMaxIterations }) =>
     `You are in the LOOP (orchestration) phase. The workflow ENGINE owns the implement→review loop — you do NOT track iterations or decide when the loop is clean.
 
 Use read to inspect ${artifactDir}/plan.md, ${artifactDir}/handoff.md, ${artifactDir}/research.md, and ${artifactDir}/reuse.md. Using that context, GENERATE YOUR OWN delegation prompt (no static template):
 
-Call the subagent tool with { agent: "builder", task: "..." } (do NOT pass a model parameter). Give it plan + handoff + any research/reuse context, tailored to this task. Instruct it to implement every task in plan.md in order. All code changes go in the workspace, never in ${artifactDir}.
+Call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Give it plan + handoff + any research/reuse context, tailored to this task. Instruct it to implement every task in plan.md in order. All code changes go in the workspace, never in ${artifactDir}. The builder must return its completion summary inline.
 
-After the builder returns, call the commentator. Craft the review task YOURSELF based on what matters for this task. Each commentator review MUST end with exactly one machine-readable line:
+After the builder returns, call the subagent tool with { agent: "commentator", task: "...", output: false }. Craft the review task YOURSELF based on what matters for this task. The commentator must return its review inline. Each commentator review MUST end with exactly one machine-readable line:
   WORKFLOW_REVIEW_STATUS: clean
   OR
   WORKFLOW_REVIEW_STATUS: blocking
@@ -131,11 +131,9 @@ If a review is blocking, call the builder again with the recorded issues. This r
 
 Review uncommitted changes for correctness, plan adherence, and over-engineering. Use ponytail-review style: cut bloat, unnecessary abstractions, dead flexibility, and reinvented stdlib/native behavior.
 
-1. Call the subagent tool with { agent: "commentator", task: "..." } (do NOT pass a model parameter). Craft the task from the full uncommitted diff and ${artifactDir}/plan.md. The commentator returns its review; the workflow saves it to ${artifactDir}/review.md. The review MUST end with exactly one machine-readable line on its own:
-  WORKFLOW_REVIEW_STATUS: clean
-  (use WORKFLOW_REVIEW_STATUS: blocking if actionable issues remain)
-2. If ${artifactDir}/review.md lists actionable issues, call the subagent tool with { agent: "builder", task: "..." } (do NOT pass a model parameter). Instruct it to fix every issue in the workspace, never in ${artifactDir}.
-3. Re-dispatch the commentator until ${artifactDir}/review.md ends with WORKFLOW_REVIEW_STATUS: clean.
+1. Call the subagent tool with { agent: "commentator", task: "...", output: false } (do NOT pass a model parameter). Craft the task from the full uncommitted diff and ${artifactDir}/plan.md. It must return the review inline; do not tell it to write any artifact. Verify the review ends with exactly one machine-readable line, WORKFLOW_REVIEW_STATUS: clean or WORKFLOW_REVIEW_STATUS: blocking, then immediately call write_workflow_artifact with that review as content for ${artifactDir}/review.md.
+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.`,
 };

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

@@ -64,11 +64,11 @@ The workflow advances once ${artifactDir}/requirements.md exists.`,
 
 This is a QUICK workflow — no separate research phase. Use ${artifactDir}/requirements.md to produce the concrete build plan: what to build, how, in order, components, and what the finished prototype looks like.
 
-Call the subagent tool with { agent: "architect", task: "..." } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md so the architect plans for THIS task. The architect returns the plan; the workflow saves it to ${artifactDir}/plan.md.
+Call the subagent tool with { agent: "architect", task: "...", output: false } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md so the architect plans for THIS task. It must return the complete plan inline; do not tell it to write any artifact.
 
-The plan MUST end with exactly one machine-readable line on its own:
+Inspect that result, verify it ends with exactly one machine-readable line on its own:
   WORKFLOW_PLAN_STATUS: ready
-The workflow will NOT advance until ${artifactDir}/plan.md contains that marker.`,
+Then immediately call write_workflow_artifact with the complete validated plan as content. Only that parent tool call writes ${artifactDir}/plan.md and advances the workflow.`,
   reuse: ({ artifactDir }) =>
     `You are in the REUSE phase (optional).
 
@@ -76,7 +76,7 @@ Decide whether codebase exploration is useful. Skip if the project is empty, the
 
 If unsure, ask the user one focused question: "Should I explore the existing codebase for reusable patterns before implementing?" Then follow their answer.
 
-If YES (or user confirms): call the subagent tool with { agent: "explorer", task: "..." } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md and ${artifactDir}/plan.md pointing it at relevant areas, patterns, and dependencies. Synthesize the findings into ${artifactDir}/reuse.md: what is reusable, where, and how to leverage it.
+If YES (or user confirms): call the subagent tool with { agent: "explorer", task: "...", output: false } (do NOT pass a model parameter). Craft the task from ${artifactDir}/requirements.md and ${artifactDir}/plan.md pointing it at relevant areas, patterns, and dependencies. It must return the reuse findings inline; do not tell it to write any artifact. Immediately call write_workflow_artifact with those findings as content for ${artifactDir}/reuse.md.
 
 If NO: call write_workflow_artifact with a brief skip note explaining why.
 
@@ -91,19 +91,19 @@ Draw from all prior phases:
 - ${artifactDir}/plan.md
 - ${artifactDir}/reuse.md
 
-Call the subagent tool with { agent: "recapper", task: "..." } (do NOT pass a model parameter). Craft the task pointing the recapper at all three artifact files and telling it what the prototype is about. The recapper returns the handoff; the workflow saves it to ${artifactDir}/handoff.md.
+Call the subagent tool with { agent: "recapper", task: "...", output: false } (do NOT pass a model parameter). Craft the task pointing the recapper at all three artifact files and telling it what the prototype is about. It must return the complete handoff inline; do not tell it to write any artifact.
 
-The handoff MUST end with exactly one machine-readable line on its own:
+Inspect that result, verify it ends with exactly one machine-readable line on its own:
   WORKFLOW_HANDOFF_STATUS: ready
-The workflow will NOT advance until ${artifactDir}/handoff.md contains that marker.`,
+Then immediately call write_workflow_artifact with the complete validated handoff as content. Only that parent tool call writes ${artifactDir}/handoff.md and advances the workflow.`,
   loop: ({ artifactDir, loopMaxIterations }) =>
     `You are in the LOOP (orchestration) phase. The workflow ENGINE owns the implement→review loop — you do NOT track iterations or decide when the loop is clean.
 
 Use read to inspect ${artifactDir}/plan.md, ${artifactDir}/handoff.md, and ${artifactDir}/reuse.md. Using that context, GENERATE YOUR OWN delegation prompt:
 
-Call the subagent tool with { agent: "builder", task: "..." } (do NOT pass a model parameter). Give it plan + handoff + reuse context, tailored to this task. Instruct it to implement every task in plan.md in order. All code changes go in the workspace, never in ${artifactDir}.
+Call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Give it plan + handoff + reuse context, tailored to this task. Instruct it to implement every task in plan.md in order. All code changes go in the workspace, never in ${artifactDir}. The builder must return its completion summary inline.
 
-After the builder returns, call the commentator. Craft the review task YOURSELF. Each commentator review MUST end with exactly one machine-readable line:
+After the builder returns, call the subagent tool with { agent: "commentator", task: "...", output: false }. Craft the review task YOURSELF. The commentator must return its review inline. Each commentator review MUST end with exactly one machine-readable line:
   WORKFLOW_REVIEW_STATUS: clean
   OR
   WORKFLOW_REVIEW_STATUS: blocking
@@ -114,11 +114,9 @@ If a review is blocking, call the builder again with the recorded issues. This r
 
 Review uncommitted changes for correctness, plan adherence, and over-engineering. Use ponytail-review style: cut bloat, unnecessary abstractions, dead flexibility, and reinvented stdlib/native behavior.
 
-1. Call the subagent tool with { agent: "commentator", task: "..." } (do NOT pass a model parameter). Craft the task from the full uncommitted diff and ${artifactDir}/plan.md. The commentator returns its review; the workflow saves it to ${artifactDir}/review.md. The review MUST end with exactly one machine-readable line on its own:
-  WORKFLOW_REVIEW_STATUS: clean
-  (use WORKFLOW_REVIEW_STATUS: blocking if actionable issues remain)
-2. If ${artifactDir}/review.md lists actionable issues, call the subagent tool with { agent: "builder", task: "..." } (do NOT pass a model parameter). Instruct it to fix every issue in the workspace, never in ${artifactDir}.
-3. Re-run the commentator until ${artifactDir}/review.md ends with WORKFLOW_REVIEW_STATUS: clean.
+1. Call the subagent tool with { agent: "commentator", task: "...", output: false } (do NOT pass a model parameter). Craft the task from the full uncommitted diff and ${artifactDir}/plan.md. It must return the review inline; do not tell it to write any artifact. Verify the review ends with exactly one machine-readable line, WORKFLOW_REVIEW_STATUS: clean or WORKFLOW_REVIEW_STATUS: blocking, then immediately call write_workflow_artifact with that review as content for ${artifactDir}/review.md.
+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.`,
 };

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

@@ -19,19 +19,19 @@ ${userPrompt}
 
 Produce a concrete implementation plan: what to build, how, in what order, which files, components, and what the finished result looks like.
 
-Call the subagent tool with { agent: "architect", task: "..." } (do NOT pass a model parameter). Craft the task so the architect plans for THIS request. The architect returns the plan; the workflow saves it to ${artifactDir}/plan.md.
+Call the subagent tool with { agent: "architect", task: "...", output: false } (do NOT pass a model parameter). Craft the task so the architect plans for THIS request. It must return the complete plan inline; do not tell it to write any artifact.
 
-The plan MUST end with exactly one machine-readable line on its own:
+Inspect that result, verify it ends with exactly one machine-readable line on its own:
   WORKFLOW_PLAN_STATUS: ready
-The workflow will NOT advance until ${artifactDir}/plan.md contains that marker.`,
+Then immediately call write_workflow_artifact with the complete validated plan as content. Only that parent tool call writes ${artifactDir}/plan.md and advances the workflow.`,
   loop: ({ artifactDir, loopMaxIterations }) =>
     `You are in the LOOP (orchestration) phase of a TASK workflow. The workflow ENGINE owns the implement→review loop — you do NOT track iterations or decide when the loop is clean.
 
 Use read to inspect ${artifactDir}/plan.md. Using that context, GENERATE YOUR OWN delegation prompt:
 
-Call the subagent tool with { agent: "builder", task: "..." } (do NOT pass a model parameter). Give it the plan context, tailored to this task. Instruct it to implement every task in plan.md in order. All code changes go in the workspace, never in ${artifactDir}.
+Call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Give it the plan context, tailored to this task. Instruct it to implement every task in plan.md in order. All code changes go in the workspace, never in ${artifactDir}. The builder must return its completion summary inline.
 
-After the builder returns, call the commentator. Craft the review task YOURSELF. Each commentator review MUST end with exactly one machine-readable line:
+After the builder returns, call the subagent tool with { agent: "commentator", task: "...", output: false }. Craft the review task YOURSELF. The commentator must return its review inline. Each commentator review MUST end with exactly one machine-readable line:
   WORKFLOW_REVIEW_STATUS: clean
   OR
   WORKFLOW_REVIEW_STATUS: blocking
@@ -55,6 +55,9 @@ const config: WorkflowConfig = {
   closeValidators: { "loop-complete.md": loopCompleteValidator },
   closeArtifacts: ["loop-complete.md"],
   loopMaxIterations: 3,
+  // Task is plan → build. Continue directly into the loop when architect
+  // finishes, rather than requiring a second /workflow-task interaction.
+  continueAfterArtifact: true,
   statusKey: "task",
   entryType: "task-phase",
   footerLabel: "task",

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

@@ -82,6 +82,9 @@ 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 {

package/dist/extensions/workflow/task-validators.ts

@@ -0,0 +1,69 @@
+// ponytail: task-specific validators enforce the acceptance/verification
+// contract used only by task mode. Pure string functions; no fs/pi.
+
+import { markerValidator } from "./validators.ts";
+
+const PLAN_READY = markerValidator("WORKFLOW_PLAN_STATUS", "ready");
+const REVIEW_CLEAN = markerValidator("WORKFLOW_REVIEW_STATUS", "clean");
+
+const AC_ID_RE = /\bAC-(\d+)\b/gi;
+const ACCEPTANCE_CRITERIA_HEADING_RE = /^##\s+Acceptance Criteria\b/im;
+const IMPLEMENTATION_HEADING_RE = /^##\s+Implementation Outline\b/im;
+const VERIFICATION_RE = /\bVerification\s*:/gi;
+
+function extractACIds(text: string): string[] {
+  const ids: string[] = [];
+  let m: RegExpExecArray | null;
+  AC_ID_RE.lastIndex = 0;
+  while ((m = AC_ID_RE.exec(text)) !== null) {
+    ids.push(m[0]!.toUpperCase());
+  }
+  return ids;
+}
+
+export const taskPlanValidator = (content: string) => {
+  const marker = PLAN_READY(content);
+  if (!marker.ok) return marker;
+
+  if (!ACCEPTANCE_CRITERIA_HEADING_RE.test(content)) {
+    return { ok: false as const, reason: "missing `## Acceptance Criteria` section" };
+  }
+  const ids = extractACIds(content);
+  if (ids.length === 0) {
+    return { ok: false as const, reason: "acceptance criteria section must contain at least one AC-<n> ID" };
+  }
+  const unique = new Set(ids);
+  if (unique.size !== ids.length) {
+    return { ok: false as const, reason: "acceptance criteria AC-<n> IDs must be unique" };
+  }
+  if (!IMPLEMENTATION_HEADING_RE.test(content)) {
+    return { ok: false as const, reason: "missing `## Implementation Outline` section" };
+  }
+  const verifications = (content.match(VERIFICATION_RE) ?? []).length;
+  if (verifications < unique.size) {
+    return { ok: false as const, reason: "each AC-<n> must have a Verification: step" };
+  }
+  return { ok: true as const };
+};
+
+export function taskReviewValidator(
+  planContent: string | undefined,
+  reviewText: string,
+): { ok: true } | { ok: false; reason: string } {
+  const marker = REVIEW_CLEAN(reviewText);
+  if (!marker.ok) return marker;
+
+  const planIds = extractACIds(planContent ?? "");
+  if (planIds.length === 0) {
+    return { ok: false as const, reason: "plan contains no AC-<n> criteria; cannot verify coverage" };
+  }
+  const reviewIds = extractACIds(reviewText);
+  const missing = planIds.filter((id) => !reviewIds.includes(id));
+  if (missing.length > 0) {
+    return { ok: false as const, reason: `review is missing coverage for ${missing.join(", ")}` };
+  }
+  if (!/\bpassed\b/i.test(reviewText) || !/\bverification\b/i.test(reviewText)) {
+    return { ok: false as const, reason: "review must report that verification passed" };
+  }
+  return { ok: true as const };
+}

package/dist/index.d.ts

@@ -16,7 +16,7 @@ export type { ResourceCollision, ResourceDiagnostic, ResourceLoader } from "./co
 export { DefaultResourceLoader, loadProjectContextFiles } from "./core/resource-loader.ts";
 export { AgentSessionRuntime, type AgentSessionRuntimeDiagnostic, type AgentSessionServices, type CreateAgentSessionFromServicesOptions, type CreateAgentSessionOptions, type CreateAgentSessionResult, type CreateAgentSessionRuntimeFactory, type CreateAgentSessionRuntimeResult, type CreateAgentSessionServicesOptions, createAgentSession, createAgentSessionFromServices, createAgentSessionRuntime, createAgentSessionServices, createBashTool, createCodingTools, createEditTool, createFindTool, createGrepTool, createLsTool, createReadOnlyTools, createReadTool, createWriteTool, type PromptTemplate, } from "./core/sdk.ts";
 export { type BranchSummaryEntry, buildContextEntries, buildSessionContext, type CompactionEntry, CURRENT_SESSION_VERSION, type CustomEntry, type CustomMessageEntry, type FileEntry, getLatestCompactionEntry, type ModelChangeEntry, migrateSessionEntries, type NewSessionOptions, parseSessionEntries, type SessionContext, type SessionEntry, type SessionEntryBase, type SessionHeader, type SessionInfo, type SessionInfoEntry, SessionManager, type SessionMessageEntry, type SessionTreeNode, sessionEntryToContextMessages, type ThinkingLevelChangeEntry, } from "./core/session-manager.ts";
-export { type CompactionSettings, type DefaultProjectTrust, type ImageSettings, type PackageSource, type RetrySettings, SettingsManager, type SettingsManagerCreateOptions, } from "./core/settings-manager.ts";
+export { type AutoHandoffSettings, type CompactionSettings, type DefaultProjectTrust, type ImageSettings, type PackageSource, type RetrySettings, SettingsManager, type SettingsManagerCreateOptions, } from "./core/settings-manager.ts";
 export { formatSkillsForPrompt, type LoadSkillsFromDirOptions, type LoadSkillsResult, loadSkills, loadSkillsFromDir, type Skill, type SkillFrontmatter, } from "./core/skills.ts";
 export { createSyntheticSourceInfo } from "./core/source-info.ts";
 export { type EditDiffResult, generateDiffString, generateUnifiedPatch } from "./core/tools/edit-diff.ts";