@drisp/cli 0.5.22 → 0.5.24

package/dist/{WorkflowInstallWizard-IPLYZPLS.js → WorkflowInstallWizard-IMU47QWB.js}

@@ -8,7 +8,7 @@ import {
   installWorkflowPlugins,
   resolveWorkflow,
   writeGlobalConfig
-} from "./chunk-DSWRVUOO.js";
+} from "./chunk-7UUPLAP4.js";
 
 // src/setup/steps/WorkflowInstallWizard.tsx
 import { useState, useEffect, useCallback, useRef } from "react";
@@ -92,4 +92,4 @@ function WorkflowInstallWizard({ source, onDone }) {
 export {
   WorkflowInstallWizard as default
 };
-//# sourceMappingURL=WorkflowInstallWizard-IPLYZPLS.js.map
+//# sourceMappingURL=WorkflowInstallWizard-IMU47QWB.js.map

package/dist/athena-gateway.js

@@ -3,13 +3,14 @@ import {
   loadOrCreateToken,
   requireTokenForBind,
   timingSafeTokenEqual
-} from "./chunk-MRAM6EYI.js";
+} from "./chunk-7GEQJQMR.js";
 import {
   CHANNEL_REQUEST_ID_REGEX,
   createUdsServerTransport,
   generateChannelRequestId,
   isLoopbackHost,
   isValidChannelRequestId,
+  openVersionedDb,
   refreshDashboardAccessToken,
   resolveGatewayPaths,
   resolveListenSpec,
@@ -19,7 +20,7 @@ import {
   trackGatewayTransportConnect,
   trackGatewayTransportDisconnect,
   writeGatewayTrace
-} from "./chunk-BTY7MYYT.js";
+} from "./chunk-YU2WMPRC.js";
 
 // src/gateway/daemon.ts
 import fs4 from "fs";
@@ -2440,7 +2441,7 @@ var cachedVersion = null;
 function readVersion() {
   if (cachedVersion !== null) return cachedVersion;
   try {
-    const injected = "0.5.22";
+    const injected = "0.5.24";
     if (typeof injected === "string" && injected.length > 0) {
       cachedVersion = injected;
       return cachedVersion;
@@ -3758,31 +3759,9 @@ function questionFingerprint(req) {
 
 // src/gateway/state/db.ts
 import fs3 from "fs";
-import path3 from "path";
-import Database from "better-sqlite3";
 var GATEWAY_STATE_VERSION = 2;
-function openGatewayState(dbPath) {
-  if (dbPath !== ":memory:") {
-    fs3.mkdirSync(path3.dirname(dbPath), { recursive: true, mode: 448 });
-  }
-  const db = new Database(dbPath);
-  db.exec("PRAGMA journal_mode = WAL");
-  db.exec("PRAGMA foreign_keys = ON");
-  initGatewayStateSchema(db);
-  if (dbPath !== ":memory:" && process.platform !== "win32") {
-    try {
-      fs3.chmodSync(dbPath, 384);
-    } catch {
-    }
-  }
-  return db;
-}
-function initGatewayStateSchema(db) {
+var migrateGatewayState = (db, fromVersion) => {
   db.exec(`
-		CREATE TABLE IF NOT EXISTS schema_version (
-			version INTEGER NOT NULL
-		);
-
 		-- Inbound chat messages parked while no runtime is registered. Drained
 		-- in FIFO id order on session.register. Idempotency key prevents the
 		-- same provider message from being parked twice if an adapter retries.
@@ -3814,27 +3793,35 @@ function initGatewayStateSchema(db) {
 		CREATE INDEX IF NOT EXISTS ix_channel_outbox_due
 			ON channel_outbox(next_attempt_at);
 	`);
-  const existing = db.prepare("SELECT version FROM schema_version").get();
-  if (existing && existing.version > GATEWAY_STATE_VERSION) {
-    throw new Error(
-      `Gateway state DB has newer schema version ${existing.version} (expected <= ${GATEWAY_STATE_VERSION}). Update athena-cli.`
-    );
-  }
-  if (!existing) {
-    db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(
-      GATEWAY_STATE_VERSION
-    );
-    return;
-  }
+  if (fromVersion === void 0) return;
   const inboundColumns = db.prepare("PRAGMA table_info(inbound_queue)").all();
   if (!inboundColumns.some((column) => column.name === "attachment_id")) {
     db.prepare("ALTER TABLE inbound_queue ADD COLUMN attachment_id TEXT").run();
   }
-  if (existing.version < GATEWAY_STATE_VERSION) {
+  if (fromVersion < GATEWAY_STATE_VERSION) {
     db.prepare("UPDATE schema_version SET version = ?").run(
       GATEWAY_STATE_VERSION
     );
   }
+};
+function openGatewayState(dbPath) {
+  const db = openVersionedDb(dbPath, {
+    version: GATEWAY_STATE_VERSION,
+    migrate: migrateGatewayState,
+    foreignKeys: true,
+    ensureDir: true,
+    dirMode: 448,
+    onNewerVersion: (found, expected) => new Error(
+      `Gateway state DB has newer schema version ${found} (expected <= ${expected}). Update athena-cli.`
+    )
+  });
+  if (dbPath !== ":memory:" && process.platform !== "win32") {
+    try {
+      fs3.chmodSync(dbPath, 384);
+    } catch {
+    }
+  }
+  return db;
 }
 
 // src/gateway/transport/tlsWs.ts

package/dist/{chunk-MRAM6EYI.js → chunk-7GEQJQMR.js}

@@ -1,6 +1,6 @@
 import {
   isLoopbackHost
-} from "./chunk-BTY7MYYT.js";
+} from "./chunk-YU2WMPRC.js";
 
 // src/gateway/auth.ts
 import crypto from "crypto";
@@ -73,4 +73,4 @@ export {
   timingSafeTokenEqual,
   requireTokenForBind
 };
-//# sourceMappingURL=chunk-MRAM6EYI.js.map
+//# sourceMappingURL=chunk-7GEQJQMR.js.map

package/dist/{chunk-DSWRVUOO.js → chunk-7UUPLAP4.js}

@@ -1138,7 +1138,7 @@ import fs7 from "fs";
 import os4 from "os";
 import path5 from "path";
 
-// src/core/workflows/loopManager.ts
+// src/core/workflows/trackerReader.ts
 import fs6 from "fs";
 
 // src/core/workflows/templateVars.ts
@@ -1157,66 +1157,60 @@ function substituteVariables(text, ctx) {
   return result;
 }
 
-// src/core/workflows/loopManager.ts
+// src/core/workflows/trackerReader.ts
 var DEFAULT_COMPLETION_MARKER = "<!-- WORKFLOW_COMPLETE -->";
 var DEFAULT_BLOCKED_MARKER = "<!-- WORKFLOW_BLOCKED";
 var DEFAULT_TRACKER_PATH = ".athena/{sessionId}/tracker.md";
 var TRACKER_SKELETON_MARKER = "<!-- TRACKER_SKELETON -->";
-var DEFAULT_CONTINUE_PROMPT = "Continue the task. Read the tracker at {trackerPath} for current progress.";
-function createLoopManager(trackerPath, config) {
-  let iteration = 0;
-  let active = true;
-  const completionMarker = config.completionMarker ?? DEFAULT_COMPLETION_MARKER;
-  const blockedMarker = config.blockedMarker ?? DEFAULT_BLOCKED_MARKER;
-  function readTracker() {
-    try {
-      return fs6.readFileSync(trackerPath, "utf-8");
-    } catch {
-      return "";
-    }
-  }
-  function getTerminalLine(content) {
-    const lines = content.trimEnd().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-    return lines.at(-1);
-  }
-  function extractBlockedReason(line) {
-    if (!line.startsWith(blockedMarker)) return void 0;
-    const afterMarker = line.slice(blockedMarker.length);
-    const match = afterMarker.match(/^:\s*(.+?)(?:\s*-->|$)/);
-    return match?.[1]?.trim();
-  }
-  function getState() {
-    const content = readTracker();
-    const terminalLine = getTerminalLine(content);
-    const completed = terminalLine === completionMarker;
-    const blocked = terminalLine !== void 0 && (terminalLine === `${blockedMarker} -->` || terminalLine.startsWith(`${blockedMarker}:`));
-    const blockedReason = blocked && terminalLine ? extractBlockedReason(terminalLine) : void 0;
-    const reachedLimit = iteration >= config.maxIterations;
-    const skeletonNotReplaced = content.includes(TRACKER_SKELETON_MARKER);
-    return {
-      active,
-      iteration,
-      maxIterations: config.maxIterations,
-      completionMarker,
-      blockedMarker,
-      completed,
-      blocked,
-      blockedReason,
-      reachedLimit,
-      skeletonNotReplaced
-    };
-  }
-  function incrementIteration() {
-    iteration++;
+var DEFAULT_CONTINUE_PROMPT = "Continue the task. Read the tracker at {trackerPath} for current progress. If the work is complete or blocked, the terminal marker must be the final non-empty line of the tracker; do not write any prose after it.";
+function readTracker(trackerPath) {
+  try {
+    return fs6.readFileSync(trackerPath, "utf-8");
+  } catch {
+    return "";
   }
-  function deactivate() {
-    active = false;
+}
+function getNonEmptyLines(content) {
+  return content.trimEnd().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+}
+function isBlockedLine(line, blockedMarker) {
+  return line === `${blockedMarker} -->` || line.startsWith(`${blockedMarker}:`);
+}
+function isTerminalMarkerLine(line, completionMarker, blockedMarker) {
+  return line === completionMarker || isBlockedLine(line, blockedMarker);
+}
+function getMisplacedTerminalMarker(lines, completionMarker, blockedMarker) {
+  if (lines.length < 2) return void 0;
+  const terminalLine = lines.at(-1);
+  if (terminalLine && isTerminalMarkerLine(terminalLine, completionMarker, blockedMarker)) {
+    return void 0;
   }
+  return lines.slice(0, -1).find((line) => isTerminalMarkerLine(line, completionMarker, blockedMarker));
+}
+function extractBlockedReason(line, blockedMarker) {
+  if (!line.startsWith(blockedMarker)) return void 0;
+  const afterMarker = line.slice(blockedMarker.length);
+  const match = afterMarker.match(/^:\s*(.+?)(?:\s*-->|$)/);
+  return match?.[1]?.trim();
+}
+function parseTrackerState(content, markers = {}) {
+  const completionMarker = markers.completionMarker ?? DEFAULT_COMPLETION_MARKER;
+  const blockedMarker = markers.blockedMarker ?? DEFAULT_BLOCKED_MARKER;
+  const lines = getNonEmptyLines(content);
+  const terminalLine = lines.at(-1);
+  const completed = terminalLine === completionMarker;
+  const blocked = terminalLine !== void 0 && isBlockedLine(terminalLine, blockedMarker);
+  const blockedReason = blocked && terminalLine ? extractBlockedReason(terminalLine, blockedMarker) : void 0;
   return {
-    getState,
-    incrementIteration,
-    deactivate,
-    trackerPath
+    completed,
+    blocked,
+    blockedReason,
+    misplacedTerminalMarker: getMisplacedTerminalMarker(
+      lines,
+      completionMarker,
+      blockedMarker
+    ),
+    skeletonNotReplaced: content.includes(TRACKER_SKELETON_MARKER)
   };
 }
 function buildContinuePrompt(loop) {
@@ -1271,15 +1265,17 @@ After completing meaningful work, update the tracker:
 
 When all steps are complete:
 1. Update the tracker with all steps checked off
-2. Add \`${DEFAULT_COMPLETION_MARKER}\` at the end of the tracker file
-3. Provide a summary of what was accomplished
+2. Put any final summary or outcome notes above the terminal marker
+3. Add \`${DEFAULT_COMPLETION_MARKER}\` as the final non-empty line of the tracker file
+4. Do not write any tracker content after the terminal marker
 
 ### Blocked
 
 If you are blocked and cannot make further progress:
 1. Document what is blocking you in the Notes section
-2. Add \`${DEFAULT_BLOCKED_CLOSED_MARKER}\` or \`${DEFAULT_BLOCKED_REASON_MARKER}\` at the end of the tracker file
-3. Explain what needs to happen to unblock the task whenever possible
+2. Explain what needs to happen to unblock the task whenever possible above the terminal marker
+3. Add \`${DEFAULT_BLOCKED_CLOSED_MARKER}\` or \`${DEFAULT_BLOCKED_REASON_MARKER}\` as the final non-empty line of the tracker file
+4. Do not write any tracker content after the terminal marker
 `;
 function ensureSystemPromptFile() {
   const dir = path5.join(
@@ -1693,7 +1689,7 @@ import fs10 from "fs";
 import path8 from "path";
 
 // src/core/workflows/stateMachine.md
-var stateMachine_default = "# Stateless Turn Protocol\n\nYou run in a stateless loop. Each Turn is a fresh process with no memory of prior Turns. **The tracker file is your only continuity** \u2014 read it, work, write it. Assume interruption: the runner may kill a long Turn, your context may collapse under tool output, you may hit token limits mid-task. Anything not in the tracker is gone.\n\n## First action, every Turn\n\n1. Read the tracker at the configured path (default: `.athena/<session_id>/tracker.md`). The runner provides the session ID \u2014 do not invent one.\n2. If the tracker contains `<!-- TRACKER_SKELETON -->` \u2192 this is Turn 1, run [**Orient**](#orient-turn-1).\n3. Otherwise \u2192 this is a continuation, run [**Execute**](#execute-turn-2) from where the tracker says, not from the start of the flow.\n\nReading first prevents two failure modes that waste whole Turns: redoing work already done, or contradicting decisions a prior Turn made.\n\n## Tracker contract\n\nThe tracker must always answer four questions:\n\n1. What are we trying to accomplish?\n2. What has been done?\n3. What's left?\n4. What should the next Turn do first?\n\nA future Turn has no other context. If something isn't here, it doesn't exist. Section headings may vary by workflow, but these four answers must be explicit and easy to find.\n\n### Terminal markers\n\nDefault markers (workflows may override \u2014 use the markers configured for the active workflow):\n\n- `<!-- WORKFLOW_COMPLETE -->` \u2014 all work done and verified\n- `<!-- WORKFLOW_BLOCKED -->` or `<!-- WORKFLOW_BLOCKED: reason -->` \u2014 cannot proceed without external intervention\n\nRules:\n\n- Only the last non-empty line of the tracker is authoritative. Marker-like text in notes, examples, or quoted instructions earlier in the file is ignored.\n- The runner trusts markers unconditionally. A premature marker ends the loop with no automatic recovery \u2014 write one only when its criteria are fully met.\n- Include a concrete reason after `WORKFLOW_BLOCKED:` whenever possible; the bare form is still valid.\n\n## Phases\n\n### Orient (Turn 1)\n\n1. **Replace the skeleton immediately**, before any domain work. Even a three-line tracker (goal + \"orienting\") protects you if the Turn dies during setup.\n2. Identify and load the applicable workflow skills before doing domain work. If a workflow, plugin, or local skill table names a relevant skill, read it fully and follow it. Do not assume you already know the workflow's conventions, tool sequence, quality gates, or implementation details.\n3. Use a dedicated git worktree for repository-changing work. If you are not already inside a task-specific worktree, create or enter one before editing files, record its branch/path in the tracker, and continue there. Skip this only when the workflow explicitly forbids it or the task is read-only.\n4. Run the workflow's orientation steps exactly as written. These vary by domain \u2014 a test-writing workflow explores the product in a browser; a migration workflow audits the schema. The workflow defines what orientation means. Do not skip, reorder, reinterpret, or replace workflow steps with a generic approach unless the workflow explicitly allows it or the tracker records a concrete blocker that makes the written step impossible.\n5. Refine the tracker into a granular plan. Each task a concrete, verifiable unit of work, including verification steps (running checks, reviewing output) \u2014 not just implementation. Vague tasks (\"write tests\") cannot be meaningfully resumed by a future Turn that has no idea what they mean here.\n6. Record concrete observations \u2014 what you actually saw, not what you assumed. Wrong assumptions burn entire future Turns on rework.\n7. **Single-Turn requests still go through this phase.** If the entire request is satisfied in one Turn, write a minimal tracker (what was asked, what was done, the outcome) and append `<!-- WORKFLOW_COMPLETE -->`. Leaving the skeleton in place causes the runner to classify the Turn as a failure.\n\n### Execute (Turn 2+)\n\n- Work from where the tracker says, in the workflow's prescribed sequence. Not every Turn covers every step.\n- Be strict with workflow steps. Before starting each unit, identify the next required workflow step from the workflow document and tracker, follow it as written, and record completion or blockers against that step. Do not substitute your own process, collapse separate gates into one, or advance past an unchecked step.\n- Be strict with skills. Before each new activity, check the workflow, plugin metadata, local skill table, and tracker for relevant skills. Load the appropriate skill first, read it completely, and follow its instructions. If no skill applies, record that explicitly in the tracker before proceeding. Skills carry the implementation detail (scaffolding steps, locator rules, anti-patterns, code templates) that this protocol intentionally doesn't repeat.\n- Keep repository work inside the recorded git worktree. If a continuation Turn starts outside the recorded worktree, enter it before editing. If no worktree is recorded and edits are still required, create or enter one before proceeding.\n- Delegate heavy exploration or generation to subagents via the Task tool. Pass file paths, conventions, and concrete output expectations; tell them which skill to load. Respect the workflow's **delegation constraints** \u2014 some operations must run in the main agent because their output is proof, or because the main agent needs to interpret results in context.\n- Run quality gates in order. Do not skip \u2014 they exist because skipping cascades into rework. On a failing verdict, address the issues and re-run before proceeding. Respect the workflow's **retry limits**: repeated failure usually signals a deeper issue another retry won't fix.\n\n### End\n\n1. Tracker reflects all progress, discoveries, and blockers.\n2. Tracker says clearly what the next Turn should do first.\n3. If all work is verified: append the completion marker.\n4. If an unrecoverable blocker prevents progress: append the blocked marker, with a reason if you have one.\n\n## When to write the tracker\n\nWrite on **concrete triggers**, not on a vague sense of \"meaningful progress.\" The right cadence sits between every-tool-call (noisy log, wastes tokens) and end-of-Turn (everything lost if you die mid-task).\n\n- **Discrete unit done** \u2014 file written, fix applied, test run, gate passed. Reflect the new reality before starting the next unit.\n- **Insight learned** \u2014 API quirk, config field that turned out to matter, dead end ruled out, decision between two approaches. Insights are tracker-worthy even when no code changed; rediscovering them costs the next Turn a full re-exploration. The tracker is a knowledge ledger, not just a task log.\n- **About to do something risky or long-running** \u2014 subagent dispatch, long build, flaky external call, large refactor. Write _first_, then act. If the operation kills your Turn, only what's on disk survives.\n- **Plan changed** \u2014 task resequenced, new task surfaced, planned task no longer needed. Stale plans poison continuation Turns.\n- **You haven't written in a while** \u2014 if you can't remember the last update, you've gone too long. A short defensive update (\"doing X, last completed Y, next is Z\") beats nothing.\n\nEach update covers: what changed (work or knowledge), what's now next, and any caveat the next Turn needs. Don't transcribe tool calls \u2014 the tracker is a contract with your future self, not a replay log.\n\nThe cost of one extra tracker update is a few tokens. The cost of dying without one is a whole wasted Turn. Bias toward writing.\n\n## Task UI projection\n\nThe tracker is the durable source of truth. Your harness's task tools are a Turn-scoped UI projection of the same plan, shown to the user in their CLI widget. They do not survive process exit.\n\n{{TASK_TOOL_INSTRUCTIONS}}\n\n- **Turn 1, after orientation:** project the tracker's task plan into the task tools.\n- **Turn 2+, after reading the tracker:** recreate the projection from the tracker; do not assume task IDs from prior Turns still exist.\n- **During work:** update both \u2014 the task tools for immediate UI feedback, the tracker for persistence \u2014 in the same working phase.\n\n## Turn bounding\n\nEach fresh Turn starts with a clean context window and a compact tracker \u2014 effectively self-compaction. As you work, context fills with tool outputs and intermediate state. The longer you run, the more attention is spread across tokens that are no longer relevant, degrading precision on the work that matters now.\n\nWork a bounded chunk per Turn. Ending early and letting the next Turn pick up from a clean tracker is almost always better than pushing through with a heavy context. Natural checkpoints:\n\n- After a quality gate\n- After crossing multiple phases (explored \u2192 planned \u2192 wrote specs) \u2014 stop before pushing into the next\n- When your context is visibly heavy with tool output from earlier work\n\n## Quick reference\n\n- [ ] Read the tracker before doing anything else\n- [ ] Replace the skeleton immediately, even for single-Turn requests\n- [ ] Update on concrete triggers \u2014 unit done, insight learned, risky op pending, plan changed\n- [ ] Project the tracker plan into task tools at Turn start; keep both in sync as work lands\n- [ ] Follow the workflow steps as written; do not skip, reorder, or substitute your own process\n- [ ] Load the appropriate skill before each activity; do not rely on assumed knowledge\n- [ ] Use and record a dedicated git worktree for repository-changing work\n- [ ] Run quality gates in order; respect delegation constraints and retry limits\n- [ ] Write the completion marker only when all work is verified\n- [ ] Checkpoint and end before context goes stale\n";
+var stateMachine_default = "# Stateless Turn Protocol\n\nYou run in a stateless loop. Each Turn is a fresh process with no memory of prior Turns. **The tracker file is your only continuity** \u2014 read it, work, write it. Assume interruption: the runner may kill a long Turn, your context may collapse under tool output, you may hit token limits mid-task. Anything not in the tracker is gone.\n\n## First action, every Turn\n\n1. Read the tracker at the configured path (default: `.athena/<session_id>/tracker.md`). The runner provides the session ID \u2014 do not invent one.\n2. If the tracker contains `<!-- TRACKER_SKELETON -->` \u2192 this is Turn 1, run [**Orient**](#orient-turn-1).\n3. Otherwise \u2192 this is a continuation, run [**Execute**](#execute-turn-2) from where the tracker says, not from the start of the flow.\n\nReading first prevents two failure modes that waste whole Turns: redoing work already done, or contradicting decisions a prior Turn made.\n\n## Tracker contract\n\nThe tracker must always answer four questions:\n\n1. What are we trying to accomplish?\n2. What has been done?\n3. What's left?\n4. What should the next Turn do first?\n\nA future Turn has no other context. If something isn't here, it doesn't exist. Section headings may vary by workflow, but these four answers must be explicit and easy to find.\n\n### Terminal markers\n\nDefault markers (workflows may override \u2014 use the markers configured for the active workflow):\n\n- `<!-- WORKFLOW_COMPLETE -->` \u2014 all work done and verified\n- `<!-- WORKFLOW_BLOCKED -->` or `<!-- WORKFLOW_BLOCKED: reason -->` \u2014 cannot proceed without external intervention\n\nRules:\n\n- Only the last non-empty line of the tracker is authoritative. Marker-like text in notes, examples, or quoted instructions earlier in the file is ignored.\n- When you write a terminal marker, it must be the final non-empty line of the tracker. Put every summary, status note, and next-step sentence before the marker. Never append prose after it.\n- The runner trusts markers unconditionally. A premature marker ends the loop with no automatic recovery \u2014 write one only when its criteria are fully met.\n- Include a concrete reason after `WORKFLOW_BLOCKED:` whenever possible; the bare form is still valid.\n\n## Phases\n\n### Orient (Turn 1)\n\n1. **Replace the skeleton immediately**, before any domain work. Even a three-line tracker (goal + \"orienting\") protects you if the Turn dies during setup.\n2. Identify and load the applicable workflow skills before doing domain work. If a workflow, plugin, or local skill table names a relevant skill, read it fully and follow it. Do not assume you already know the workflow's conventions, tool sequence, quality gates, or implementation details.\n3. Use a dedicated git worktree for repository-changing work. If you are not already inside a task-specific worktree, create or enter one before editing files, record its branch/path in the tracker, and continue there. Skip this only when the workflow explicitly forbids it or the task is read-only.\n4. Run the workflow's orientation steps exactly as written. These vary by domain \u2014 a test-writing workflow explores the product in a browser; a migration workflow audits the schema. The workflow defines what orientation means. Do not skip, reorder, reinterpret, or replace workflow steps with a generic approach unless the workflow explicitly allows it or the tracker records a concrete blocker that makes the written step impossible.\n5. Refine the tracker into a granular plan. Each task a concrete, verifiable unit of work, including verification steps (running checks, reviewing output) \u2014 not just implementation. Vague tasks (\"write tests\") cannot be meaningfully resumed by a future Turn that has no idea what they mean here.\n6. Record concrete observations \u2014 what you actually saw, not what you assumed. Wrong assumptions burn entire future Turns on rework.\n7. **Single-Turn requests still go through this phase.** If the entire request is satisfied in one Turn, write a minimal tracker (what was asked, what was done, the outcome) and append `<!-- WORKFLOW_COMPLETE -->`. Leaving the skeleton in place causes the runner to classify the Turn as a failure.\n\n### Execute (Turn 2+)\n\n- Work from where the tracker says, in the workflow's prescribed sequence. Not every Turn covers every step.\n- Be strict with workflow steps. Before starting each unit, identify the next required workflow step from the workflow document and tracker, follow it as written, and record completion or blockers against that step. Do not substitute your own process, collapse separate gates into one, or advance past an unchecked step.\n- Be strict with skills. Before each new activity, check the workflow, plugin metadata, local skill table, and tracker for relevant skills. Load the appropriate skill first, read it completely, and follow its instructions. If no skill applies, record that explicitly in the tracker before proceeding. Skills carry the implementation detail (scaffolding steps, locator rules, anti-patterns, code templates) that this protocol intentionally doesn't repeat.\n- Keep repository work inside the recorded git worktree. If a continuation Turn starts outside the recorded worktree, enter it before editing. If no worktree is recorded and edits are still required, create or enter one before proceeding.\n- Delegate heavy exploration or generation to subagents via the Task tool. Pass file paths, conventions, and concrete output expectations; tell them which skill to load. Respect the workflow's **delegation constraints** \u2014 some operations must run in the main agent because their output is proof, or because the main agent needs to interpret results in context.\n- Run quality gates in order. Do not skip \u2014 they exist because skipping cascades into rework. On a failing verdict, address the issues and re-run before proceeding. Respect the workflow's **retry limits**: repeated failure usually signals a deeper issue another retry won't fix.\n\n### End\n\n1. Tracker reflects all progress, discoveries, and blockers.\n2. Tracker says clearly what the next Turn should do first.\n3. If all work is verified: append the completion marker as the final non-empty line.\n4. If an unrecoverable blocker prevents progress: append the blocked marker as the final non-empty line, with a reason if you have one.\n\n## When to write the tracker\n\nWrite on **concrete triggers**, not on a vague sense of \"meaningful progress.\" The right cadence sits between every-tool-call (noisy log, wastes tokens) and end-of-Turn (everything lost if you die mid-task).\n\n- **Discrete unit done** \u2014 file written, fix applied, test run, gate passed. Reflect the new reality before starting the next unit.\n- **Insight learned** \u2014 API quirk, config field that turned out to matter, dead end ruled out, decision between two approaches. Insights are tracker-worthy even when no code changed; rediscovering them costs the next Turn a full re-exploration. The tracker is a knowledge ledger, not just a task log.\n- **About to do something risky or long-running** \u2014 subagent dispatch, long build, flaky external call, large refactor. Write _first_, then act. If the operation kills your Turn, only what's on disk survives.\n- **Plan changed** \u2014 task resequenced, new task surfaced, planned task no longer needed. Stale plans poison continuation Turns.\n- **You haven't written in a while** \u2014 if you can't remember the last update, you've gone too long. A short defensive update (\"doing X, last completed Y, next is Z\") beats nothing.\n\nEach update covers: what changed (work or knowledge), what's now next, and any caveat the next Turn needs. Don't transcribe tool calls \u2014 the tracker is a contract with your future self, not a replay log.\n\nThe cost of one extra tracker update is a few tokens. The cost of dying without one is a whole wasted Turn. Bias toward writing.\n\n## Task UI projection\n\nThe tracker is the durable source of truth. Your harness's task tools are a Turn-scoped UI projection of the same plan, shown to the user in their CLI widget. They do not survive process exit.\n\n{{TASK_TOOL_INSTRUCTIONS}}\n\n- **Turn 1, after orientation:** project the tracker's task plan into the task tools.\n- **Turn 2+, after reading the tracker:** recreate the projection from the tracker; do not assume task IDs from prior Turns still exist.\n- **During work:** update both \u2014 the task tools for immediate UI feedback, the tracker for persistence \u2014 in the same working phase.\n\n## Turn bounding\n\nEach fresh Turn starts with a clean context window and a compact tracker \u2014 effectively self-compaction. As you work, context fills with tool outputs and intermediate state. The longer you run, the more attention is spread across tokens that are no longer relevant, degrading precision on the work that matters now.\n\nWork a bounded chunk per Turn. Ending early and letting the next Turn pick up from a clean tracker is almost always better than pushing through with a heavy context. Natural checkpoints:\n\n- After a quality gate\n- After crossing multiple phases (explored \u2192 planned \u2192 wrote specs) \u2014 stop before pushing into the next\n- When your context is visibly heavy with tool output from earlier work\n\n## Quick reference\n\n- [ ] Read the tracker before doing anything else\n- [ ] Replace the skeleton immediately, even for single-Turn requests\n- [ ] Update on concrete triggers \u2014 unit done, insight learned, risky op pending, plan changed\n- [ ] Project the tracker plan into task tools at Turn start; keep both in sync as work lands\n- [ ] Follow the workflow steps as written; do not skip, reorder, or substitute your own process\n- [ ] Load the appropriate skill before each activity; do not rely on assumed knowledge\n- [ ] Use and record a dedicated git worktree for repository-changing work\n- [ ] Run quality gates in order; respect delegation constraints and retry limits\n- [ ] Write the completion marker only when all work is verified, and make it the final non-empty line\n- [ ] Checkpoint and end before context goes stale\n";
 
 // src/core/workflows/stateMachine.ts
 function buildTaskToolInstructions(harness) {
@@ -1788,7 +1784,6 @@ function resolveTrackerPath(input) {
 function createWorkflowRunState(input) {
   const { projectDir, sessionId, workflow, harness } = input;
   const trackerResolved = resolveTrackerPath({ projectDir, sessionId, workflow });
-  const loopManager = workflow?.loop?.enabled === true && trackerResolved ? createLoopManager(trackerResolved.absolutePath, workflow.loop) : null;
   const { workflowOverride, warnings } = readWorkflowOverride(
     projectDir,
     workflow,
@@ -1798,15 +1793,16 @@ function createWorkflowRunState(input) {
   );
   return {
     workflow,
-    loopManager,
     trackerPathForPrompt: trackerResolved?.promptPath,
     workflowOverride,
     warnings
   };
 }
 function prepareWorkflowTurn(state, input) {
-  const { workflow, loopManager } = state;
-  const prompt = workflow && loopManager && loopManager.getState().iteration > 0 ? buildContinuePrompt({
+  const { workflow } = state;
+  const iteration = input.iteration ?? 1;
+  const isContinuation = workflow?.loop?.enabled === true && iteration > 1;
+  const prompt = isContinuation ? buildContinuePrompt({
     ...workflow.loop,
     trackerPath: state.trackerPathForPrompt ?? workflow.loop?.trackerPath
   }) : workflow ? applyPromptTemplate(workflow.promptTemplate, input.prompt) : input.prompt;
@@ -1819,60 +1815,57 @@ function prepareWorkflowTurn(state, input) {
     warnings: state.warnings
   };
 }
-function shouldContinueWorkflowRun(state) {
-  const { workflow, loopManager } = state;
-  if (!workflow?.loop?.enabled || !loopManager) {
-    return null;
-  }
-  const loopState = loopManager.getState();
-  if (!fs10.existsSync(loopManager.trackerPath)) {
-    cleanupWorkflowRun(state);
+
+// src/core/workflows/useWorkflowSessionController.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+
+// src/core/workflows/workflowRunner.ts
+import crypto from "crypto";
+import fs12 from "fs";
+import path9 from "path";
+
+// src/core/workflows/terminalOutcome.ts
+import fs11 from "fs";
+var MISSING_TRACKER_MESSAGE = "the tracker file went missing during the run \u2014 the workflow can no longer verify progress";
+var SKELETON_NOT_REPLACED_MESSAGE = "tracker skeleton was never replaced \u2014 Claude did not bootstrap the tracker";
+var MISPLACED_TERMINAL_MARKER_MESSAGE = "terminal workflow marker is not the final non-empty line of the tracker; move all summary text above the marker";
+function resolveTurnOutcome(input) {
+  const { trackerPath, loop, iteration } = input;
+  if (!fs11.existsSync(trackerPath)) {
     return {
-      reason: "missing_tracker",
-      maxIterations: loopState.maxIterations
+      kind: "stop",
+      status: "failed",
+      stopReason: MISSING_TRACKER_MESSAGE
     };
   }
-  if (loopState.skeletonNotReplaced) {
-    cleanupWorkflowRun(state);
+  const tracker = parseTrackerState(readTracker(trackerPath), loop);
+  if (tracker.skeletonNotReplaced) {
     return {
-      reason: "skeleton_not_replaced",
-      maxIterations: loopState.maxIterations
+      kind: "stop",
+      status: "failed",
+      stopReason: SKELETON_NOT_REPLACED_MESSAGE
     };
   }
-  let reason;
-  if (loopState.completed) {
-    reason = "completed";
-  } else if (loopState.blocked) {
-    reason = "blocked";
-  } else if (loopState.iteration + 1 >= loopState.maxIterations) {
-    reason = "max_iterations";
-  }
-  if (reason) {
-    cleanupWorkflowRun(state);
+  if (tracker.misplacedTerminalMarker) {
     return {
-      reason,
-      blockedReason: loopState.blockedReason,
-      maxIterations: loopState.maxIterations
+      kind: "stop",
+      status: "failed",
+      stopReason: MISPLACED_TERMINAL_MARKER_MESSAGE
     };
   }
-  loopManager.incrementIteration();
-  return null;
-}
-function cleanupWorkflowRun(state) {
-  if (!state.loopManager) {
-    return;
+  if (tracker.completed) {
+    return { kind: "stop", status: "completed" };
   }
-  state.loopManager.deactivate();
-  state.loopManager = null;
+  if (tracker.blocked) {
+    return { kind: "stop", status: "blocked", stopReason: tracker.blockedReason };
+  }
+  if (iteration >= loop.maxIterations) {
+    return { kind: "stop", status: "exhausted" };
+  }
+  return { kind: "continue" };
 }
 
-// src/core/workflows/useWorkflowSessionController.ts
-import { useCallback, useEffect, useRef, useState } from "react";
-
 // src/core/workflows/workflowRunner.ts
-import crypto from "crypto";
-import fs11 from "fs";
-import path9 from "path";
 var NULL_TOKENS = {
   input: null,
   output: null,
@@ -1929,9 +1922,9 @@ function mergeTokens(base, next) {
   };
 }
 function defaultCreateTracker(trackerPath, content) {
-  fs11.mkdirSync(path9.dirname(trackerPath), { recursive: true });
+  fs12.mkdirSync(path9.dirname(trackerPath), { recursive: true });
   try {
-    fs11.writeFileSync(trackerPath, content, { encoding: "utf-8", flag: "wx" });
+    fs12.writeFileSync(trackerPath, content, { encoding: "utf-8", flag: "wx" });
   } catch (e) {
     if (e.code !== "EEXIST") throw e;
   }
@@ -1989,80 +1982,72 @@ function createWorkflowRunner(input) {
     let nextContinuation = input.initialContinuation ?? {
       mode: "fresh"
     };
-    try {
-      while (!cancelled) {
-        iterations++;
-        const prepared = prepareWorkflowTurn(workflowState, {
-          prompt: input.prompt,
-          configOverride: void 0
-        });
-        const turnResult = await input.startTurn({
-          prompt: prepared.prompt,
-          continuation: nextContinuation,
-          configOverride: prepared.configOverride
-        });
-        if (cancelled) {
-          status = "cancelled";
-          persist();
-          break;
-        }
-        cumulativeTokens = mergeTokens(cumulativeTokens, turnResult.tokens);
-        if (turnResult.error || turnResult.exitCode !== null && turnResult.exitCode !== 0) {
-          status = "failed";
-          const parts = [];
-          if (turnResult.error?.message) {
-            parts.push(turnResult.error.message);
-          } else if (turnResult.exitCode !== null) {
-            parts.push(`Process exited with code ${turnResult.exitCode}`);
-          }
-          if (turnResult.lastStderr) {
-            parts.push(turnResult.lastStderr);
-          }
-          stopReason = parts.join(": ") || "Turn failed";
-          persist();
-          break;
-        }
-        const transport = turnResult.diagnostics?.transport;
-        if (transport && transport.streamToolUses > 0 && transport.preToolUseEvents === 0) {
-          status = "failed";
-          stopReason = `Hook transport broken: observed ${transport.streamToolUses} tool use(s) in Claude stream but received no PreToolUse events.`;
-          persist();
-          break;
-        }
-        if (!input.workflow?.loop?.enabled) {
-          status = "completed";
-          persist();
-          break;
+    const loop = input.workflow?.loop;
+    while (!cancelled) {
+      iterations++;
+      const prepared = prepareWorkflowTurn(workflowState, {
+        prompt: input.prompt,
+        iteration: iterations,
+        configOverride: void 0
+      });
+      const turnResult = await input.startTurn({
+        prompt: prepared.prompt,
+        continuation: nextContinuation,
+        configOverride: prepared.configOverride
+      });
+      if (cancelled) {
+        status = "cancelled";
+        persist();
+        break;
+      }
+      cumulativeTokens = mergeTokens(cumulativeTokens, turnResult.tokens);
+      if (turnResult.error || turnResult.exitCode !== null && turnResult.exitCode !== 0) {
+        status = "failed";
+        const parts = [];
+        if (turnResult.error?.message) {
+          parts.push(turnResult.error.message);
+        } else if (turnResult.exitCode !== null) {
+          parts.push(`Process exited with code ${turnResult.exitCode}`);
         }
-        const loopStop = shouldContinueWorkflowRun(workflowState);
-        if (loopStop) {
-          if (loopStop.reason === "completed") {
-            status = "completed";
-          } else if (loopStop.reason === "blocked") {
-            status = "blocked";
-            stopReason = loopStop.blockedReason;
-          } else if (loopStop.reason === "max_iterations") {
-            status = "exhausted";
-          } else if (loopStop.reason === "skeleton_not_replaced") {
-            status = "failed";
-            stopReason = "tracker skeleton was never replaced \u2014 Claude did not bootstrap the tracker";
-          } else {
-            status = "failed";
-            stopReason = `Loop stopped: ${loopStop.reason}`;
-          }
-          persist();
-          break;
+        if (turnResult.lastStderr) {
+          parts.push(turnResult.lastStderr);
         }
+        stopReason = parts.join(": ") || "Turn failed";
         persist();
-        input.onIterationComplete?.(snapshot());
-        nextContinuation = { mode: "fresh" };
+        break;
       }
-      if (cancelled && status === "running") {
-        status = "cancelled";
+      const transport = turnResult.diagnostics?.transport;
+      if (transport && transport.streamToolUses > 0 && transport.preToolUseEvents === 0) {
+        status = "failed";
+        stopReason = `Hook transport broken: observed ${transport.streamToolUses} tool use(s) in Claude stream but received no PreToolUse events.`;
         persist();
+        break;
       }
-    } finally {
-      cleanupWorkflowRun(workflowState);
+      if (!loop?.enabled) {
+        status = "completed";
+        persist();
+        break;
+      }
+      if (trackerAbsPath) {
+        const outcome = resolveTurnOutcome({
+          trackerPath: trackerAbsPath,
+          loop,
+          iteration: iterations
+        });
+        if (outcome.kind === "stop") {
+          status = outcome.status;
+          stopReason = outcome.stopReason;
+          persist();
+          break;
+        }
+      }
+      persist();
+      input.onIterationComplete?.(snapshot());
+      nextContinuation = { mode: "fresh" };
+    }
+    if (cancelled && status === "running") {
+      status = "cancelled";
+      persist();
     }
     return {
       runId,
@@ -2189,17 +2174,17 @@ function useWorkflowSessionController(base, input) {
 }
 
 // src/infra/plugins/mcpOptions.ts
-import fs12 from "fs";
+import fs13 from "fs";
 import path10 from "path";
 function collectMcpServersWithOptions(pluginDirs) {
   const result = [];
   const seen = /* @__PURE__ */ new Set();
   for (const dir of pluginDirs) {
     const mcpPath = path10.join(dir, ".mcp.json");
-    if (!fs12.existsSync(mcpPath)) {
+    if (!fs13.existsSync(mcpPath)) {
       continue;
     }
-    const config = JSON.parse(fs12.readFileSync(mcpPath, "utf-8"));
+    const config = JSON.parse(fs13.readFileSync(mcpPath, "utf-8"));
     for (const [serverName, serverConfig] of Object.entries(
       config.mcpServers ?? {}
     )) {
@@ -2244,4 +2229,4 @@ export {
   compileWorkflowPlan,
   collectMcpServersWithOptions
 };
-//# sourceMappingURL=chunk-DSWRVUOO.js.map
+//# sourceMappingURL=chunk-7UUPLAP4.js.map