@drisp/cli 0.5.23 → 0.5.24

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

@@ -8,7 +8,7 @@ import {
   installWorkflowPlugins,
   resolveWorkflow,
   writeGlobalConfig
-} from "./chunk-JHSADKDJ.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-CCCUR6KA.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.23";
+    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-JHSADKDJ.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,84 +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. 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 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 getNonEmptyLines(content) {
-    return content.trimEnd().split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
-  }
-  function isBlockedLine(line) {
-    return line === `${blockedMarker} -->` || line.startsWith(`${blockedMarker}:`);
-  }
-  function isTerminalMarkerLine(line) {
-    return line === completionMarker || isBlockedLine(line);
-  }
-  function getTerminalLine(content) {
-    const lines = getNonEmptyLines(content);
-    return lines.at(-1);
-  }
-  function getMisplacedTerminalMarker(content) {
-    const lines = getNonEmptyLines(content);
-    if (lines.length < 2) return void 0;
-    const terminalLine = lines.at(-1);
-    if (terminalLine && isTerminalMarkerLine(terminalLine)) return void 0;
-    return lines.slice(0, -1).find(isTerminalMarkerLine);
-  }
-  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 && isBlockedLine(terminalLine);
-    const blockedReason = blocked && terminalLine ? extractBlockedReason(terminalLine) : void 0;
-    const misplacedTerminalMarker = getMisplacedTerminalMarker(content);
-    const reachedLimit = iteration >= config.maxIterations;
-    const skeletonNotReplaced = content.includes(TRACKER_SKELETON_MARKER);
-    return {
-      active,
-      iteration,
-      maxIterations: config.maxIterations,
-      completionMarker,
-      blockedMarker,
-      completed,
-      blocked,
-      blockedReason,
-      misplacedTerminalMarker,
-      reachedLimit,
-      skeletonNotReplaced
-    };
-  }
-  function incrementIteration() {
-    iteration++;
+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) {
@@ -1808,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,
@@ -1818,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;
@@ -1839,67 +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
     };
   }
-  if (loopState.misplacedTerminalMarker) {
-    cleanupWorkflowRun(state);
+  if (tracker.misplacedTerminalMarker) {
     return {
-      reason: "misplaced_terminal_marker",
-      maxIterations: loopState.maxIterations
+      kind: "stop",
+      status: "failed",
+      stopReason: MISPLACED_TERMINAL_MARKER_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 (tracker.completed) {
+    return { kind: "stop", status: "completed" };
   }
-  if (reason) {
-    cleanupWorkflowRun(state);
-    return {
-      reason,
-      blockedReason: loopState.blockedReason,
-      maxIterations: loopState.maxIterations
-    };
+  if (tracker.blocked) {
+    return { kind: "stop", status: "blocked", stopReason: tracker.blockedReason };
   }
-  loopManager.incrementIteration();
-  return null;
-}
-function cleanupWorkflowRun(state) {
-  if (!state.loopManager) {
-    return;
+  if (iteration >= loop.maxIterations) {
+    return { kind: "stop", status: "exhausted" };
   }
-  state.loopManager.deactivate();
-  state.loopManager = null;
+  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,
@@ -1956,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;
   }
@@ -2016,83 +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 if (loopStop.reason === "misplaced_terminal_marker") {
-            status = "failed";
-            stopReason = "terminal workflow marker is not the final non-empty line of the tracker; move all summary text above the marker";
-          } 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,
@@ -2219,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 ?? {}
     )) {
@@ -2274,4 +2229,4 @@ export {
   compileWorkflowPlan,
   collectMcpServersWithOptions
 };
-//# sourceMappingURL=chunk-JHSADKDJ.js.map
+//# sourceMappingURL=chunk-7UUPLAP4.js.map