@selesai/code 0.8.3 → 0.8.4

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

@@ -1,74 +0,0 @@
-import type {
-  Phase,
-  PromptContext,
-  WorkflowConfig,
-  WorkflowModeRegistration,
-} from "../state-machine.ts";
-import { handoffValidator, loopCompleteValidator } from "../validators.ts";
-
-// Direct build↔review mode with a parent-persisted handoff artifact. The handoff
-// lets fresh builder/commentator subagents work from a self-contained document
-// instead of relying on the parent conversation.
-const phases: Phase[] = ["handoff", "loop"];
-
-const prompts: Partial<Record<Phase, (ctx: PromptContext) => string>> = {
-  handoff: ({ artifactDir, userPrompt }) =>
-    `You are in the HANDOFF phase of a LOOP workflow.
-
-Original goal:
-${userPrompt}
-
-Compile a self-contained handoff document so loop-phase sub-agents understand the goal, constraints, acceptance criteria, and relevant workspace context without re-grilling or re-planning.
-
-Call the subagent tool with { agent: "recapper", task: "...", output: false } (do NOT pass a model parameter). Point it at the original goal above and instruct it to use the inherited conversation to produce a concise, self-contained handoff for fresh agents. It must return the complete handoff inline; do not tell it to write any artifact.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_HANDOFF_STATUS: ready
-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, userPrompt, loopMaxIterations }) =>
-    `You are in the LOOP phase of a LOOP workflow. The workflow ENGINE owns build→review rounds and persists review feedback.
-
-Original goal:
-${userPrompt}
-
-Use read to inspect ${artifactDir}/handoff.md. Using that handoff context — not the parent conversation — generate your own delegation prompt.
-
-1. Call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Give it the handoff context. Instruct it to implement the agreed work in the workspace only, run relevant checks, and return an inline completion summary with checks run. If a previous blocking review exists (e.g. ${artifactDir}/loop-review-1.md), direct the builder to read the persisted review and address every issue before returning.
-2. Call the subagent tool with { agent: "commentator", task: "...", output: false }. Give it the handoff context. Require independent validation: inspect the current uncommitted diff, verify the handoff acceptance criteria and correctness, run relevant checks where feasible, and report evidence. Its review must end with exactly one machine-readable line:
-   WORKFLOW_REVIEW_STATUS: clean
-   OR
-   WORKFLOW_REVIEW_STATUS: blocking
-3. For blocking feedback, call the builder again with the persisted issues and required fixes. Do not declare success yourself. The engine repeats this for up to ${loopMaxIterations ?? 3} blocking review round(s), then pauses for inspection.
-
-When review is clean, the engine writes ${artifactDir}/loop-complete.md and makes the workflow terminal-ready. Do NOT write that file. Verify the result, then call end_workflow with { mode: "loop" } to complete the workflow.`,
-};
-
-const config: WorkflowConfig = {
-  mode: "loop",
-  phases,
-  phaseArtifacts: {
-    handoff: "handoff.md",
-    loop: "loop-complete.md",
-  },
-  prompts,
-  skipRules: [],
-  artifactValidators: {
-    handoff: handoffValidator,
-    loop: loopCompleteValidator,
-  },
-  closeValidators: { "loop-complete.md": loopCompleteValidator },
-  closeArtifacts: ["loop-complete.md"],
-  loopMaxIterations: 3,
-  statusKey: "loop",
-  entryType: "loop-phase",
-  footerLabel: "loop",
-};
-
-export const loopMode: WorkflowModeRegistration = {
-  config,
-  commandName: "workflow-loop",
-  commandDescription:
-    "Run the direct build↔review workflow for an already-agreed plan",
-};
-
-export default loopMode;

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

@@ -1,170 +0,0 @@
-import type {
-  Phase,
-  PromptContext,
-  WorkflowConfig,
-  WorkflowModeRegistration,
-} from "../state-machine.ts";
-import {
-  handoffValidator,
-  loopCompleteValidator,
-  planValidator,
-  reviewValidator,
-} from "../validators.ts";
-
-// ponytail: prototype workflow — full 7-phase tool-driven loop:
-// grill → research → plan → reuse → handoff → loop → audit.
-// skipRules + closeArtifacts are wired by the adapter (git reuse-skip is
-// shared by every mode today); this file is pure phase/prompt config.
-
-const phases: Phase[] = [
-  "grilling",
-  "research",
-  "plan",
-  "reuse",
-  "handoff",
-  "loop",
-  "audit",
-];
-
-const prompts: Partial<Record<Phase, (ctx: PromptContext) => string>> = {
-  grilling: ({ artifactDir, userPrompt }) =>
-    `You are in the GRILLING phase of a prototype workflow.
-
-User request:
-${userPrompt}
-
-Map requirements as a design tree: every decision branches into dependent decisions. Work the tree in rounds. The frontier contains every decision whose prerequisites are settled; do not ask questions that depend on answers still open in the current round.
-
-For each round, use one question tool call to ask the ENTIRE frontier. Number every question, give a recommended answer, and wait for the user's answers before the next round. Recompute the frontier after every response. Cover scope, constraints, success criteria, and edge cases; leave no branch silently assumed.
-
-Facts are yours to find, never the user's. When a frontier question needs a fact from the workspace or available tools, dispatch a sub-agent to investigate rather than asking the user. Do not block on it: ask other frontier decisions now; defer only decisions that depend on the pending finding.
-
-For each question tool call:
-- State all numbered frontier questions concisely, including a recommendation for each.
-- Pass a short context summary when it depends on prior findings.
-- Prefer options when one shared option set fits the whole round. Give each option a clear label and brief description.
-- Always set allowFreeform=true so the user can answer each numbered decision or provide a custom answer.
-- Keep allowMultiple=false unless multiple selections genuinely apply.
-
-Only when the frontier is empty, show a concise requirements summary draft and ask exactly: "Approve writing this requirements summary to ${artifactDir}/requirements.md?" This approval confirms shared understanding. Allow "keep grilling" or added details; do not write or otherwise act on the requirements before explicit approval.
-
-Artifact target: ${artifactDir}/requirements.md
-- Name that exact full path in the approval question.
-- Do NOT shorten, translate, censor, sanitize, or invent a different path.
-- Only after explicit approval, call write_workflow_artifact with content only. Do not use write.
-
-The workflow advances once ${artifactDir}/requirements.md exists.`,
-  research: ({ artifactDir }) =>
-    `You are in the RESEARCH phase (optional).
-
-Only research if the task depends on fast-changing external knowledge (libraries, frameworks, languages/SDKs, APIs, or unfamiliar alternatives). Skip what you already know well.
-
-Decide: is research needed?
-- If YES: use web_search_exa or webfetch via bash to gather current, authoritative information, then synthesize actionable findings (versions, APIs, pitfalls, recommended approaches).
-- If NO: skip real research.
-
-Either way, call write_workflow_artifact with research.md content. If skipped, state briefly why. If researched, record findings the plan can rely on.
-
-The workflow advances once ${artifactDir}/research.md exists.`,
-  plan: ({ artifactDir }) =>
-    `You are in the PLAN phase.
-
-Produce the concrete build plan for the actual prototype/output — not a plan for research. Use ${artifactDir}/requirements.md and ${artifactDir}/research.md (if it contains real findings). Cover what to build, how, in what order, which components, and what the finished prototype looks like.
-
-If research was skipped, proceed directly — you already understand the user's intent from grilling.
-
-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.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_PLAN_STATUS: ready
-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).
-
-Decide whether codebase exploration is useful. Skip if the project is empty, the task creates something wholly new, or there is clearly nothing to reuse.
-
-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: "...", 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.
-
-The workflow advances once ${artifactDir}/reuse.md exists.`,
-  handoff: ({ artifactDir }) =>
-    `You are in the HANDOFF phase.
-
-Compile a self-contained handoff document so loop-phase sub-agents understand full project context without re-grilling.
-
-Draw from all prior phases:
-- ${artifactDir}/requirements.md (grilling outcomes)
-- ${artifactDir}/research.md (research, or the skip note)
-- ${artifactDir}/plan.md (the build plan)
-- ${artifactDir}/reuse.md (codebase exploration findings)
-
-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.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_HANDOFF_STATUS: ready
-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: "...", 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 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
-
-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 advances to audit. Do NOT write loop-complete.md yourself.`,
-  audit: ({ artifactDir }) =>
-    `You are in the AUDIT (review) phase.
-
-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: "...", 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 with { mode: "prototype" } to complete the workflow.`,
-};
-
-const config: WorkflowConfig = {
-  mode: "prototype",
-  phases,
-  phaseArtifacts: {
-    grilling: "requirements.md",
-    research: "research.md",
-    plan: "plan.md",
-    reuse: "reuse.md",
-    handoff: "handoff.md",
-    loop: "loop-complete.md",
-    audit: "review.md",
-  },
-  prompts,
-  // ponytail: Plan 4 — semantic gates for the critical phases. Existence
-  // is still required, but the file content must also carry its marker line
-  // so an empty/stub file cannot silently advance the workflow.
-  artifactValidators: {
-    plan: planValidator,
-    handoff: handoffValidator,
-    loop: loopCompleteValidator,
-  },
-  closeValidators: { "review.md": reviewValidator },
-  closeArtifacts: ["review.md"],
-  loopMaxIterations: 3,
-  statusKey: "prototype",
-  entryType: "prototype-phase",
-  footerLabel: "prototype",
-};
-
-export const prototypeMode: WorkflowModeRegistration = {
-  config,
-  commandName: "workflow-prototype",
-  commandDescription:
-    "Run the prototype workflow (grill → research → plan → reuse → handoff → loop → audit)",
-};
-
-export default prototypeMode;

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

@@ -1,150 +0,0 @@
-import type {
-  Phase,
-  PromptContext,
-  WorkflowConfig,
-  WorkflowModeRegistration,
-} from "../state-machine.ts";
-import {
-  handoffValidator,
-  loopCompleteValidator,
-  planValidator,
-  reviewValidator,
-} from "../validators.ts";
-
-// ponytail: quicktype workflow — same tool-driven loop as prototype, without research:
-// grill → plan → reuse → handoff → loop → audit.
-// No research phase. skipRules + closeArtifacts wired by the adapter.
-
-const phases: Phase[] = [
-  "grilling",
-  "plan",
-  "reuse",
-  "handoff",
-  "loop",
-  "audit",
-];
-
-const prompts: Partial<Record<Phase, (ctx: PromptContext) => string>> = {
-  grilling: ({ artifactDir, userPrompt }) =>
-    `You are in the GRILLING phase of a QUICKTYPE workflow.
-
-User request:
-${userPrompt}
-
-Map requirements as a design tree: every decision branches into dependent decisions. Work the tree in rounds. The frontier contains every decision whose prerequisites are settled; do not ask questions that depend on answers still open in the current round.
-
-For each round, use one question tool call to ask the ENTIRE frontier. Number every question, give a recommended answer, and wait for the user's answers before the next round. Recompute the frontier after every response. Cover scope, constraints, success criteria, and edge cases; leave no branch silently assumed.
-
-Facts are yours to find, never the user's. When a frontier question needs a fact from the workspace or available tools, dispatch a sub-agent to investigate rather than asking the user. Do not block on it: ask other frontier decisions now; defer only decisions that depend on the pending finding.
-
-For each question tool call:
-- State all numbered frontier questions concisely, including a recommendation for each.
-- Pass a short context summary when it depends on prior findings.
-- Prefer options when one shared option set fits the whole round. Give each option a clear label and brief description.
-- Always set allowFreeform=true so the user can answer each numbered decision or provide a custom answer.
-- Keep allowMultiple=false unless multiple selections genuinely apply.
-
-Only when the frontier is empty, show a concise requirements summary draft and ask exactly: "Approve writing this requirements summary to ${artifactDir}/requirements.md?" This approval confirms shared understanding. Allow "keep grilling" or added details; do not write or otherwise act on the requirements before explicit approval.
-
-Artifact target: ${artifactDir}/requirements.md
-- Name that exact full path in the approval question.
-- Do NOT shorten, translate, censor, sanitize, or invent a different path.
-- Only after explicit approval, call write_workflow_artifact with content only. Do not use write.
-
-The workflow advances once ${artifactDir}/requirements.md exists.`,
-  plan: ({ artifactDir }) =>
-    `You are in the PLAN phase.
-
-This is a QUICKTYPE 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: "...", 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.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_PLAN_STATUS: ready
-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).
-
-Decide whether codebase exploration is useful. Skip if the project is empty, the task creates something wholly new, or there is clearly nothing to reuse.
-
-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: "...", 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.
-
-The workflow advances once ${artifactDir}/reuse.md exists.`,
-  handoff: ({ artifactDir }) =>
-    `You are in the HANDOFF phase.
-
-Compile a self-contained handoff document so loop-phase sub-agents understand full project context without re-grilling.
-
-Draw from all prior phases:
-- ${artifactDir}/requirements.md
-- ${artifactDir}/plan.md
-- ${artifactDir}/reuse.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.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_HANDOFF_STATUS: ready
-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: "...", 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 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
-
-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 advances to audit. Do NOT write loop-complete.md yourself.`,
-  audit: ({ artifactDir }) =>
-    `You are in the AUDIT (review) phase.
-
-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: "...", 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_workflow with { mode: "quicktype" } to complete the workflow.`,
-};
-
-const config: WorkflowConfig = {
-  mode: "quicktype",
-  phases,
-  phaseArtifacts: {
-    grilling: "requirements.md",
-    plan: "plan.md",
-    reuse: "reuse.md",
-    handoff: "handoff.md",
-    loop: "loop-complete.md",
-    audit: "review.md",
-  },
-  prompts,
-  // ponytail: Plan 4 — semantic gates for the critical phases.
-  artifactValidators: {
-    plan: planValidator,
-    handoff: handoffValidator,
-    loop: loopCompleteValidator,
-  },
-  closeValidators: { "review.md": reviewValidator },
-  closeArtifacts: ["review.md"],
-  loopMaxIterations: 3,
-  statusKey: "quicktype",
-  entryType: "quicktype-phase",
-  footerLabel: "quicktype",
-};
-
-export const quicktypeMode: WorkflowModeRegistration = {
-  config,
-  commandName: "workflow-quicktype",
-  commandDescription:
-    "Run the quicktype workflow (grill → plan → reuse → handoff → loop → audit)",
-};
-
-export default quicktypeMode;

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

@@ -1,105 +0,0 @@
-import type {
-  Phase,
-  PromptContext,
-  WorkflowConfig,
-  WorkflowModeRegistration,
-} from "../state-machine.ts";
-import {
-  handoffValidator,
-  loopCompleteValidator,
-  planValidator,
-} from "../validators.ts";
-
-// ponytail: task workflow is now plan → reuse → handoff → loop. Each parent-
-// owned artifact (plan.md, reuse.md, handoff.md) advances automatically, and
-// the loop's clean marker makes the workflow terminal-ready. The explicit end
-// tool is the only completion.
-const phases: Phase[] = ["plan", "reuse", "handoff", "loop"];
-
-const prompts: Partial<Record<Phase, (ctx: PromptContext) => string>> = {
-  plan: ({ artifactDir, userPrompt }) =>
-    `You are in the PLAN phase of a TASK workflow.
-
-User request:
-${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: "...", 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.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_PLAN_STATUS: ready
-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 of a TASK workflow (optional).
-
-The adapter automatically skips this phase when the project has no git history, so codebase exploration is only useful when commits already exist. Decide whether exploration is still useful; skip if the task creates something wholly new or there is clearly nothing to reuse.
-
-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: "...", output: false } (do NOT pass a model parameter). Craft the task from ${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.
-
-The workflow advances once ${artifactDir}/reuse.md exists.`,
-  handoff: ({ artifactDir }) =>
-    `You are in the HANDOFF phase of a TASK workflow.
-
-Compile a self-contained handoff document so loop-phase sub-agents understand full project context without re-grilling.
-
-Draw from all prior phases:
-- ${artifactDir}/plan.md
-- ${artifactDir}/reuse.md
-
-Call the subagent tool with { agent: "recapper", task: "...", output: false } (do NOT pass a model parameter). Craft the task pointing the recapper at both artifact files and telling it what the task is about. It must return the complete handoff inline; do not tell it to write any artifact.
-
-Inspect that result, verify it ends with exactly one machine-readable line on its own:
-  WORKFLOW_HANDOFF_STATUS: ready
-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 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, ${artifactDir}/reuse.md, and ${artifactDir}/handoff.md. Using that context, GENERATE YOUR OWN delegation prompt:
-
-Call the subagent tool with { agent: "builder", task: "...", output: false } (do NOT pass a model parameter). Give it plan + reuse + handoff 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 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
-
-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 = {
-  mode: "task",
-  phases,
-  phaseArtifacts: {
-    plan: "plan.md",
-    reuse: "reuse.md",
-    handoff: "handoff.md",
-    loop: "loop-complete.md",
-  },
-  prompts,
-  skipRules: [],
-  artifactValidators: {
-    plan: planValidator,
-    handoff: handoffValidator,
-    loop: loopCompleteValidator,
-  },
-  closeValidators: { "loop-complete.md": loopCompleteValidator },
-  closeArtifacts: ["loop-complete.md"],
-  loopMaxIterations: 3,
-  statusKey: "task",
-  entryType: "task-phase",
-  footerLabel: "task",
-};
-
-export const taskMode: WorkflowModeRegistration = {
-  config,
-  commandName: "workflow-task",
-  commandDescription:
-    "Run the task workflow (plan → reuse → handoff → build↔review loop)",
-};
-
-export default taskMode;

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

@@ -1,124 +0,0 @@
-import { mkdir, readFile, readdir, rename, writeFile } from "node:fs/promises";
-import { basename, dirname, relative, resolve } from "node:path";
-import { withFileMutationQueue } from "@selesai/code";
-
-import type { Phase } from "./state-machine.ts";
-
-export const WORKFLOW_STATE_FILENAME = "workflow.json";
-
-export interface LoopState {
-  reviewRound: number;
-  maxIterations: number;
-  stage: "building" | "reviewing" | "clean" | "maxed";
-  reviewPath?: string;
-}
-
-export interface PersistedWorkflowRun {
-  version: 1;
-  id: string;
-  mode: string;
-  status: "active" | "completed";
-  goal: string;
-  artifactDir: string;
-  phase: Phase;
-  autoArmed: boolean;
-  loopState?: LoopState;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export type WorkflowModes = Record<string, readonly Phase[]>;
-export interface ListedWorkflowRun { statePath: string; run: PersistedWorkflowRun }
-
-function isInside(base: string, path: string): boolean {
-  const rel = relative(resolve(base), resolve(path));
-  return rel === "" || (!rel.startsWith("..") && !rel.includes(`..${process.platform === "win32" ? "\\" : "/"}`));
-}
-
-function invalid(message: string): never {
-  throw new Error(`Invalid ${WORKFLOW_STATE_FILENAME}: ${message}`);
-}
-
-function validateLoopState(value: unknown): LoopState | undefined {
-  if (value === undefined) return undefined;
-  if (!value || typeof value !== "object") invalid("loopState must be an object");
-  const loop = value as Record<string, unknown>;
-  if (!Number.isInteger(loop.reviewRound) || (loop.reviewRound as number) < 0) invalid("loopState.reviewRound must be a non-negative integer");
-  if (!Number.isInteger(loop.maxIterations) || (loop.maxIterations as number) < 1) invalid("loopState.maxIterations must be a positive integer");
-  if (!(["building", "reviewing", "clean", "maxed"] as string[]).includes(loop.stage as string)) invalid("loopState.stage is invalid");
-  if (loop.reviewPath !== undefined && (typeof loop.reviewPath !== "string" || !/^loop-review-\d+\.md$/.test(loop.reviewPath))) invalid("loopState.reviewPath is invalid");
-  return loop as unknown as LoopState;
-}
-
-export function validateWorkflowRun(value: unknown, statePath: string, modes: WorkflowModes): PersistedWorkflowRun {
-  if (!value || typeof value !== "object") invalid("record must be an object");
-  const run = value as Record<string, unknown>;
-  if (run.version !== 1) invalid("unsupported version");
-  if (typeof run.id !== "string" || !run.id || run.id !== basename(dirname(resolve(statePath)))) invalid("id must match its containing directory");
-  if (typeof run.mode !== "string" || !modes[run.mode]) invalid("unknown mode");
-  if (run.status !== "active" && run.status !== "completed") invalid("status is invalid");
-  if (typeof run.goal !== "string") invalid("goal must be a string");
-  if (typeof run.artifactDir !== "string" || resolve(run.artifactDir) !== dirname(resolve(statePath))) invalid("artifactDir does not match its containing directory");
-  if (typeof run.phase !== "string" || !modes[run.mode].includes(run.phase)) invalid("phase is not valid for the selected mode");
-  if (typeof run.autoArmed !== "boolean") invalid("autoArmed must be boolean");
-  if (typeof run.createdAt !== "string" || typeof run.updatedAt !== "string") invalid("timestamps must be strings");
-  validateLoopState(run.loopState);
-  return run as unknown as PersistedWorkflowRun;
-}
-
-export async function loadWorkflowRun(statePath: string, modes: WorkflowModes): Promise<PersistedWorkflowRun> {
-  let parsed: unknown;
-  try {
-    parsed = JSON.parse(await readFile(statePath, "utf8"));
-  } catch (error) {
-    throw new Error(`Cannot read ${statePath}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  return validateWorkflowRun(parsed, statePath, modes);
-}
-
-export async function saveWorkflowRun(run: PersistedWorkflowRun): Promise<void> {
-  const statePath = resolve(run.artifactDir, WORKFLOW_STATE_FILENAME);
-  await withFileMutationQueue(statePath, async () => {
-    await mkdir(dirname(statePath), { recursive: true });
-    const tempPath = `${statePath}.${process.pid}.${Date.now()}.tmp`;
-    await writeFile(tempPath, `${JSON.stringify(run, null, 2)}\n`, "utf8");
-    await rename(tempPath, statePath);
-  });
-}
-
-export async function listResumableWorkflowRuns(base: string, modes: WorkflowModes): Promise<ListedWorkflowRun[]> {
-  let entries;
-  try {
-    entries = await readdir(resolve(base), { withFileTypes: true });
-  } catch (error: any) {
-    if (error?.code === "ENOENT") return [];
-    throw error;
-  }
-  const listed: ListedWorkflowRun[] = [];
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const statePath = resolve(base, entry.name, WORKFLOW_STATE_FILENAME);
-    try {
-      const run = await loadWorkflowRun(statePath, modes);
-      if (run.status === "active") listed.push({ statePath, run });
-    } catch {
-      // A corrupt or unrelated artifact is not a resumable run.
-    }
-  }
-  return listed.sort((a, b) => b.run.updatedAt.localeCompare(a.run.updatedAt));
-}
-
-export async function resolveWorkflowRun(selector: string, base: string, modes: WorkflowModes): Promise<ListedWorkflowRun> {
-  const root = resolve(base);
-  const candidate = resolve(root, selector);
-  if (selector.includes("/") || selector.includes("\\") || selector.endsWith(".json") || selector.startsWith(".")) {
-    if (!isInside(root, candidate)) throw new Error("Workflow run path must be inside the artifacts directory.");
-    const statePath = candidate.endsWith(WORKFLOW_STATE_FILENAME) ? candidate : resolve(candidate, WORKFLOW_STATE_FILENAME);
-    const run = await loadWorkflowRun(statePath, modes);
-    return { statePath, run };
-  }
-  const runs = await listResumableWorkflowRuns(root, modes);
-  const found = runs.find(({ run }) => run.id === selector);
-  if (!found) throw new Error(`No resumable workflow run with id ${selector}.`);
-  return found;
-}