@joshski/dust 0.1.49 → 0.1.51

package/dist/dust.js

@@ -1008,7 +1008,7 @@ import { accessSync, statSync } from "node:fs";
 import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { createServer as httpCreateServer } from "node:http";
 import { homedir } from "node:os";
-import { join as join8 } from "node:path";
+import { join as join9 } from "node:path";
 
 // lib/bucket/auth.ts
 import { join as join4 } from "node:path";
@@ -1177,7 +1177,7 @@ function getLogLines(buffer) {
 }
 
 // lib/bucket/repository.ts
-import { dirname as dirname2, join as join7 } from "node:path";
+import { dirname as dirname2, join as join8 } from "node:path";
 
 // lib/claude/spawn-claude-code.ts
 import { spawn as nodeSpawn } from "node:child_process";
@@ -1195,7 +1195,8 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
     systemPrompt,
     sessionId,
     dangerouslySkipPermissions,
-    env
+    env,
+    signal
   } = options;
   const claudeArguments = [
     "-p",
@@ -1231,19 +1232,11 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
   if (!proc.stdout) {
     throw new Error("Failed to get stdout from claude process");
   }
-  const rl = dependencies.createInterface({ input: proc.stdout });
-  for await (const line of rl) {
-    if (!line.trim())
-      continue;
-    try {
-      yield JSON.parse(line);
-    } catch {}
-  }
   let stderrOutput = "";
   proc.stderr?.on("data", (data) => {
     stderrOutput += data.toString();
   });
-  await new Promise((resolve, reject) => {
+  const closePromise = new Promise((resolve, reject) => {
     proc.on("close", (code) => {
       if (code === 0 || code === null)
         resolve();
@@ -1254,6 +1247,30 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
     });
     proc.on("error", reject);
   });
+  const abortHandler = () => {
+    if (!proc.killed) {
+      proc.kill();
+    }
+  };
+  if (signal?.aborted) {
+    abortHandler();
+  } else if (signal) {
+    signal.addEventListener("abort", abortHandler, { once: true });
+  }
+  const rl = dependencies.createInterface({ input: proc.stdout });
+  try {
+    for await (const line of rl) {
+      if (!line.trim())
+        continue;
+      try {
+        yield JSON.parse(line);
+      } catch {}
+    }
+    await closePromise;
+  } finally {
+    signal?.removeEventListener("abort", abortHandler);
+    rl.close?.();
+  }
 }
 
 // lib/claude/event-parser.ts
@@ -1578,11 +1595,84 @@ async function run(prompt, options = {}, dependencies = defaultRunnerDependencie
   await dependencies.streamEvents(events, sink, onRawEvent);
 }
 
-// lib/bucket/repository-git.ts
+// lib/logging/match.ts
+function parsePatterns(debug) {
+  if (!debug)
+    return [];
+  const expressions = debug.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return expressions.map((expr) => {
+    const escaped = expr.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = escaped.replace(/\*/g, ".*");
+    return new RegExp(`^${pattern}$`);
+  });
+}
+function matchesAny(name, patterns) {
+  return patterns.some((re) => re.test(name));
+}
+function formatLine(name, messages) {
+  const text = messages.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+  return `${new Date().toISOString()} [${name}] ${text}
+`;
+}
+
+// lib/logging/sink.ts
+import { appendFileSync, mkdirSync } from "node:fs";
 import { join as join5 } from "node:path";
+var logPath;
+var ready = false;
+var scope = process.env.DEBUG_LOG_SCOPE || "debug";
+function ensureLogFile() {
+  if (ready)
+    return logPath;
+  ready = true;
+  const dir = join5(process.cwd(), "log", "dust");
+  logPath = join5(dir, `${scope}.log`);
+  try {
+    mkdirSync(dir, { recursive: true });
+  } catch {
+    logPath = undefined;
+  }
+  return logPath;
+}
+function setLogScope(name) {
+  scope = name;
+  process.env.DEBUG_LOG_SCOPE = name;
+  logPath = undefined;
+  ready = false;
+}
+var writeToFile = (line) => {
+  const path = ensureLogFile();
+  if (!path)
+    return;
+  try {
+    appendFileSync(path, line);
+  } catch {}
+};
+
+// lib/logging/index.ts
+var patterns = null;
+var initialized = false;
+function init() {
+  if (initialized)
+    return;
+  initialized = true;
+  const parsed = parsePatterns(process.env.DEBUG);
+  patterns = parsed.length > 0 ? parsed : null;
+}
+function createLogger(name, write = writeToFile) {
+  return (...messages) => {
+    init();
+    if (!patterns || !matchesAny(name, patterns))
+      return;
+    write(formatLine(name, messages));
+  };
+}
+
+// lib/bucket/repository-git.ts
+import { join as join6 } from "node:path";
 function getRepoPath(repoName, reposDir) {
   const safeName = repoName.replace(/[^a-zA-Z0-9-_/]/g, "-");
-  return join5(reposDir, safeName);
+  return join6(reposDir, safeName);
 }
 async function cloneRepository(repository, targetPath, spawn, context) {
   return new Promise((resolve) => {
@@ -1652,7 +1742,7 @@ function formatAgentEvent(event) {
 import { spawn as nodeSpawn2 } from "node:child_process";
 import { readFileSync } from "node:fs";
 import os from "node:os";
-import { dirname, join as join6 } from "node:path";
+import { dirname, join as join7 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // lib/workflow-tasks.ts
@@ -1800,8 +1890,8 @@ async function next(dependencies) {
 var __dirname2 = dirname(fileURLToPath(import.meta.url));
 function getDustVersion() {
   const candidates = [
-    join6(__dirname2, "../../../package.json"),
-    join6(__dirname2, "../package.json")
+    join7(__dirname2, "../../../package.json"),
+    join7(__dirname2, "../package.json")
   ];
   for (const candidate of candidates) {
     try {
@@ -1881,6 +1971,7 @@ function createWireEventSender(eventsUrl, sessionId, postEvent, onError, getAgen
     postEvent(eventsUrl, payload).catch(onError);
   };
 }
+var log = createLogger("dust.cli.commands.loop");
 var SLEEP_INTERVAL_MS = 30000;
 var DEFAULT_MAX_ITERATIONS = 10;
 async function gitPull(cwd, spawn) {
@@ -1914,10 +2005,12 @@ async function runOneIteration(dependencies, loopDependencies, onLoopEvent, onAg
   const { context } = dependencies;
   const { spawn, run: run2 } = loopDependencies;
   const agentName = loopDependencies.agentType === "codex" ? "Codex" : "Claude";
-  const { onRawEvent, hooksInstalled = false } = options;
+  const { onRawEvent, hooksInstalled = false, signal } = options;
+  log("syncing with remote");
   onLoopEvent({ type: "loop.syncing" });
   const pullResult = await gitPull(context.cwd, spawn);
   if (!pullResult.success) {
+    log(`git pull failed: ${pullResult.message}`);
     onLoopEvent({
       type: "loop.sync_skipped",
       reason: pullResult.message
@@ -1947,7 +2040,8 @@ Make sure the repository is in a clean state and synced with remote before finis
         spawnOptions: {
           cwd: context.cwd,
           dangerouslySkipPermissions: true,
-          env: { DUST_UNATTENDED: "1", DUST_SKIP_AGENT: "1" }
+          env: { DUST_UNATTENDED: "1", DUST_SKIP_AGENT: "1" },
+          signal
         },
         onRawEvent
       });
@@ -1966,10 +2060,12 @@ Make sure the repository is in a clean state and synced with remote before finis
   onLoopEvent({ type: "loop.checking_tasks" });
   const tasks = await findAvailableTasks(dependencies);
   if (tasks.length === 0) {
+    log("no tasks available");
     onLoopEvent({ type: "loop.no_tasks" });
     return "no_tasks";
   }
   const task = tasks[0];
+  log(`found ${tasks.length} task(s), picking: ${task.title ?? task.path}`);
   onLoopEvent({ type: "loop.tasks_found" });
   const taskContent = await dependencies.fileSystem.readFile(`${dependencies.context.cwd}/${task.path}`);
   const { dustCommand, installCommand = "npm install" } = dependencies.settings;
@@ -2000,14 +2096,17 @@ ${instructions}`;
       spawnOptions: {
         cwd: context.cwd,
         dangerouslySkipPermissions: true,
-        env: { DUST_UNATTENDED: "1", DUST_SKIP_AGENT: "1" }
+        env: { DUST_UNATTENDED: "1", DUST_SKIP_AGENT: "1" },
+        signal
       },
       onRawEvent
     });
+    log(`${agentName} completed task: ${task.title ?? task.path}`);
     onAgentEvent?.({ type: "agent-session-ended", success: true });
     return "ran_claude";
   } catch (error) {
     const errorMessage = error instanceof Error ? error.message : String(error);
+    log(`${agentName} error on task ${task.title ?? task.path}: ${errorMessage}`);
     context.stderr(`${agentName} exited with error: ${errorMessage}`);
     onAgentEvent?.({
       type: "agent-session-ended",
@@ -2052,6 +2151,7 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
     sendWireEvent(event);
   };
   const hooksInstalled = await manageGitHooks(dependencies);
+  log(`starting loop, maxIterations=${maxIterations}, sessionId=${sessionId}`);
   onLoopEvent({ type: "loop.warning" });
   onLoopEvent({
     type: "loop.started",
@@ -2071,9 +2171,11 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
     agentSessionId = crypto.randomUUID();
     const result = await runOneIteration(dependencies, loopDependencies, onLoopEvent, onAgentEvent, iterationOptions);
     if (result === "no_tasks") {
+      log("sleeping, no tasks");
       await loopDependencies.sleep(SLEEP_INTERVAL_MS);
     } else {
       completedIterations++;
+      log(`iteration ${completedIterations}/${maxIterations} complete, result=${result}`);
       onLoopEvent({
         type: "loop.iteration_complete",
         iteration: completedIterations,
@@ -2081,11 +2183,13 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
       });
     }
   }
+  log(`loop ended after ${completedIterations} iterations`);
   onLoopEvent({ type: "loop.ended", maxIterations });
   return { exitCode: 0 };
 }
 
 // lib/bucket/repository-loop.ts
+var log2 = createLogger("dust.bucket.repository-loop");
 var FALLBACK_TIMEOUT_MS = 300000;
 function createNoOpGlobScanner() {
   return {
@@ -2173,26 +2277,55 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
     }
   };
   const hooksInstalled = await manageGitHooks(commandDeps);
+  const logLine = (msg) => appendLogLine(repoState.logBuffer, createLogLine(msg, "stdout"));
+  log2(`loop started for ${repoName} at ${repoState.path}`);
   while (!repoState.stopRequested) {
     agentSessionId = crypto.randomUUID();
-    const result = await runOneIteration(commandDeps, loopDeps, onLoopEvent, onAgentEvent, {
-      hooksInstalled,
-      onRawEvent: (rawEvent) => {
-        onAgentEvent(rawEventToAgentEvent(rawEvent));
+    const abortController = new AbortController;
+    const cancelCurrentIteration = () => {
+      abortController.abort();
+    };
+    repoState.cancelCurrentIteration = cancelCurrentIteration;
+    let result;
+    try {
+      result = await runOneIteration(commandDeps, loopDeps, onLoopEvent, onAgentEvent, {
+        hooksInstalled,
+        signal: abortController.signal,
+        onRawEvent: (rawEvent) => {
+          onAgentEvent(rawEventToAgentEvent(rawEvent));
+        }
+      });
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      log2(`iteration error for ${repoName}: ${msg}`);
+      appendLogLine(repoState.logBuffer, createLogLine(`Loop error: ${msg}`, "stderr"));
+      await sleep(1e4);
+      continue;
+    } finally {
+      if (repoState.cancelCurrentIteration === cancelCurrentIteration) {
+        repoState.cancelCurrentIteration = undefined;
       }
-    });
+    }
     if (result === "no_tasks") {
       if (repoState.taskAvailablePending) {
         repoState.taskAvailablePending = false;
+        log2(`${repoName}: task signal received during iteration, rechecking`);
+        logLine("Task signal received during iteration, rechecking...");
         continue;
       }
+      log2(`${repoName}: no tasks available, waiting`);
+      logLine("Waiting for tasks...");
       await new Promise((resolve) => {
-        repoState.wakeUp = () => {
+        const wakeUpForThisWait = () => {
+          if (repoState.wakeUp !== wakeUpForThisWait) {
+            return;
+          }
           repoState.wakeUp = undefined;
           resolve();
         };
+        repoState.wakeUp = wakeUpForThisWait;
         sleep(FALLBACK_TIMEOUT_MS).then(() => {
-          if (repoState.wakeUp) {
+          if (repoState.wakeUp === wakeUpForThisWait) {
             repoState.wakeUp = undefined;
             resolve();
           }
@@ -2200,9 +2333,27 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
       });
     }
   }
+  log2(`loop stopped for ${repoName}`);
   appendLogLine(repoState.logBuffer, createLogLine(`Stopped loop for ${repoName}`, "stdout"));
 }
+
 // lib/bucket/repository.ts
+var log3 = createLogger("dust.bucket.repository");
+function startRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
+  log3(`starting loop for ${repoState.repository.name}`);
+  repoState.stopRequested = false;
+  repoState.loopPromise = runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    log3(`loop crashed for ${repoState.repository.name}: ${message}`);
+    appendLogLine(repoState.logBuffer, createLogLine(`Repository loop crashed: ${message}`, "stderr"));
+  }).finally(() => {
+    log3(`loop finished for ${repoState.repository.name}`);
+    repoState.loopPromise = null;
+    repoState.agentStatus = "idle";
+    repoState.wakeUp = undefined;
+    repoState.cancelCurrentIteration = undefined;
+  });
+}
 function parseRepository(data) {
   if (typeof data === "string") {
     return { name: data, gitUrl: data };
@@ -2224,8 +2375,10 @@ function parseRepository(data) {
 }
 async function addRepository(repository, manager, repoDeps, context) {
   if (manager.repositories.has(repository.name)) {
+    log3(`repository ${repository.name} already exists, skipping add`);
     return;
   }
+  log3(`adding repository ${repository.name}`);
   const repoPath = getRepoPath(repository.name, repoDeps.getReposDir());
   await repoDeps.fileSystem.mkdir(dirname2(repoPath), { recursive: true });
   if (repoDeps.fileSystem.exists(repoPath)) {
@@ -2258,14 +2411,16 @@ async function addRepository(repository, manager, repoDeps, context) {
   };
   manager.emit(addedEvent);
   context.stdout(formatBucketEvent(addedEvent));
-  repoState.loopPromise = runRepositoryLoop(repoState, repoDeps, manager.sendEvent, manager.sessionId);
+  startRepositoryLoop(repoState, repoDeps, manager.sendEvent, manager.sessionId);
 }
 async function removeRepositoryFromManager(repoName, manager, repoDeps, context) {
   const repoState = manager.repositories.get(repoName);
   if (!repoState) {
     return;
   }
+  log3(`removing repository ${repoName}`);
   repoState.stopRequested = true;
+  repoState.cancelCurrentIteration?.();
   repoState.wakeUp?.();
   if (repoState.loopPromise) {
     await Promise.race([repoState.loopPromise, repoDeps.sleep(5000)]);
@@ -2576,14 +2731,24 @@ function formatLogLine(line, prefixAlign, maxWidth) {
     prefix = `${line.color}${paddedName}${ANSI.RESET} ${ANSI.DIM}|${ANSI.RESET} `;
     prefixWidth = prefixAlign + 3;
   }
+  let timePrefix = "";
+  let timePrefixWidth = 0;
+  if (line.repository === "system") {
+    const d = new Date(line.timestamp);
+    const hh = String(d.getHours()).padStart(2, "0");
+    const mm = String(d.getMinutes()).padStart(2, "0");
+    const ss = String(d.getSeconds()).padStart(2, "0");
+    timePrefix = `${ANSI.DIM}${hh}:${mm}:${ss}${ANSI.RESET} `;
+    timePrefixWidth = 9;
+  }
   const textColor = line.stream === "stderr" ? ANSI.FG_RED : "";
   const textReset = line.stream === "stderr" ? ANSI.RESET : "";
   const sanitizedText = line.text.replace(/[\r\n]+/g, "");
   const text = `${textColor}${sanitizedText}${textReset}`;
-  const availableWidth = maxWidth - prefixWidth;
+  const availableWidth = maxWidth - prefixWidth - timePrefixWidth;
   if (availableWidth <= 0)
-    return prefix;
-  return prefix + truncateLine(text, availableWidth);
+    return prefix + timePrefix;
+  return prefix + timePrefix + truncateLine(text, availableWidth);
 }
 function renderFrame(state) {
   const lines = [];
@@ -2708,6 +2873,7 @@ function handleKeyInput(state, key, options) {
 }
 
 // lib/cli/commands/bucket.ts
+var log4 = createLogger("dust.cli.commands.bucket");
 var DEFAULT_DUSTBUCKET_WS_URL = "wss://dustbucket.com/agent/connect";
 var INITIAL_RECONNECT_DELAY_MS = 1000;
 var MAX_RECONNECT_DELAY_MS = 30000;
@@ -2829,7 +2995,7 @@ function createDefaultBucketDependencies() {
     writeStdout: defaultWriteStdout,
     isTTY: process.stdout.isTTY ?? false,
     sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-    getReposDir: () => process.env.DUST_REPOS_DIR || join8(homedir(), ".dust", "repos"),
+    getReposDir: () => process.env.DUST_REPOS_DIR || join9(homedir(), ".dust", "repos"),
     auth: {
       createServer: defaultCreateServer,
       openBrowser: defaultOpenBrowser,
@@ -2870,6 +3036,25 @@ function toRepositoryDependencies(bucketDeps, fileSystem) {
     getReposDir: bucketDeps.getReposDir
   };
 }
+function ensureRepositoryLoopRunning(repoState, state, repoDeps, context, useTUI) {
+  if (repoState.loopPromise || repoState.wakeUp || repoState.stopRequested) {
+    log4(`loop already running/waiting for ${repoState.repository.name}`);
+    return;
+  }
+  logMessage(state, context, useTUI, `Repository loop not running for ${repoState.repository.name}; restarting`);
+  startRepositoryLoop(repoState, repoDeps, state.sendEvent, state.sessionId);
+}
+function signalTaskAvailable(repoState, state, repoDeps, context, useTUI) {
+  log4(`task-available signal for ${repoState.repository.name}`);
+  ensureRepositoryLoopRunning(repoState, state, repoDeps, context, useTUI);
+  if (repoState.wakeUp) {
+    log4(`waking loop for ${repoState.repository.name}`);
+    repoState.wakeUp();
+  } else {
+    log4(`marking task pending for ${repoState.repository.name} (loop busy)`);
+    repoState.taskAvailablePending = true;
+  }
+}
 function syncUIWithRepoList(state, repos) {
   const incomingNames = new Set;
   for (const data of repos) {
@@ -2993,9 +3178,14 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
   ws.onmessage = (event) => {
     try {
       const message = JSON.parse(event.data);
+      log4(`ws message: ${message.type}`);
       if (message.type === "repository-list") {
         const repos = message.repositories ?? [];
-        logMessage(state, context, useTUI, `Received repository list (${repos.length} repositories)`);
+        const repoNames = repos.map((r) => {
+          const name = r?.name ?? "?";
+          return r?.hasTask ? `${name} (has task)` : name;
+        }).join(", ");
+        logMessage(state, context, useTUI, `Received repository list: ${repoNames || "(empty)"}`);
         syncUIWithRepoList(state, repos);
         const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
         const repoContext = createTUIContext(state, context, useTUI);
@@ -3005,11 +3195,7 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
             if (typeof repoData === "object" && repoData !== null && "name" in repoData && "hasTask" in repoData && repoData.hasTask) {
               const repoState = state.repositories.get(repoData.name);
               if (repoState) {
-                if (repoState.wakeUp) {
-                  repoState.wakeUp();
-                } else {
-                  repoState.taskAvailablePending = true;
-                }
+                signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
               }
             }
           }
@@ -3019,13 +3205,13 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
       } else if (message.type === "task-available") {
         const repoName = message.repository;
         if (typeof repoName === "string") {
+          const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
+          logMessage(state, context, useTUI, `Received task-available for ${repoName}`);
           const repoState = state.repositories.get(repoName);
           if (repoState) {
-            if (repoState.wakeUp) {
-              repoState.wakeUp();
-            } else {
-              repoState.taskAvailablePending = true;
-            }
+            signalTaskAvailable(repoState, state, repoDeps, context, useTUI);
+          } else {
+            logMessage(state, context, useTUI, `No repository state found for ${repoName}`, "stderr");
           }
         }
       }
@@ -3038,6 +3224,7 @@ async function shutdown(state, bucketDeps, context) {
   if (state.shuttingDown)
     return;
   state.shuttingDown = true;
+  log4("shutdown initiated");
   context.stdout("Shutting down...");
   if (state.reconnectTimer) {
     clearTimeout(state.reconnectTimer);
@@ -3049,6 +3236,7 @@ async function shutdown(state, bucketDeps, context) {
   }
   for (const repoState of state.repositories.values()) {
     repoState.stopRequested = true;
+    repoState.cancelCurrentIteration?.();
     repoState.wakeUp?.();
   }
   const loopPromises = Array.from(state.repositories.values()).map((rs) => rs.loopPromise).filter((p) => p !== null);
@@ -3229,39 +3417,25 @@ function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, time
 }
 
 // lib/cli/commands/lint-markdown.ts
-import { dirname as dirname3, join as join9, resolve } from "node:path";
+import { join as join10 } from "node:path";
+
+// lib/lint/validators/content-validator.ts
 var REQUIRED_HEADINGS = ["## Goals", "## Blocked By", "## Definition of Done"];
-var REQUIRED_GOAL_HEADINGS = ["## Parent Goal", "## Sub-Goals"];
-var SLUG_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*\.md$/;
-var EXPECTED_DIRECTORIES = ["goals", "ideas", "tasks", "facts", "config"];
 var MAX_OPENING_SENTENCE_LENGTH = 150;
-function validateFilename(filePath) {
-  const parts = filePath.split("/");
-  const filename = parts[parts.length - 1];
-  if (!SLUG_PATTERN.test(filename)) {
-    return {
-      file: filePath,
-      message: `Filename "${filename}" does not match slug-style naming`
-    };
-  }
-  return null;
-}
-function validateTitleFilenameMatch(filePath, content) {
-  const title = extractTitle(content);
-  if (!title) {
-    return null;
-  }
-  const parts = filePath.split("/");
-  const actualFilename = parts[parts.length - 1];
-  const expectedFilename = titleToFilename(title);
-  if (actualFilename !== expectedFilename) {
-    return {
-      file: filePath,
-      message: `Filename "${actualFilename}" does not match title "${title}" (expected "${expectedFilename}")`
-    };
-  }
-  return null;
-}
+var NON_IMPERATIVE_STARTERS = new Set([
+  "the",
+  "a",
+  "an",
+  "this",
+  "that",
+  "these",
+  "those",
+  "we",
+  "it",
+  "they",
+  "you",
+  "i"
+]);
 function validateOpeningSentence(filePath, content) {
   const openingSentence = extractOpeningSentence(content);
   if (!openingSentence) {
@@ -3285,20 +3459,6 @@ function validateOpeningSentenceLength(filePath, content) {
   }
   return null;
 }
-var NON_IMPERATIVE_STARTERS = new Set([
-  "the",
-  "a",
-  "an",
-  "this",
-  "that",
-  "these",
-  "those",
-  "we",
-  "it",
-  "they",
-  "you",
-  "i"
-]);
 function validateImperativeOpeningSentence(filePath, content) {
   const openingSentence = extractOpeningSentence(content);
   if (!openingSentence) {
@@ -3327,194 +3487,109 @@ function validateTaskHeadings(filePath, content) {
   }
   return violations;
 }
-function validateLinks(filePath, content, fileSystem) {
+
+// lib/lint/validators/directory-validator.ts
+var EXPECTED_DIRECTORIES = ["goals", "ideas", "tasks", "facts", "config"];
+async function validateContentDirectoryFiles(dirPath, fileSystem) {
   const violations = [];
-  const lines = content.split(`
-`);
-  const fileDir = dirname3(filePath);
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
-    let match = linkPattern.exec(line);
-    while (match) {
-      const linkTarget = match[2];
-      if (!linkTarget.startsWith("http://") && !linkTarget.startsWith("https://") && !linkTarget.startsWith("#")) {
-        const targetPath = linkTarget.split("#")[0];
-        const resolvedPath = resolve(fileDir, targetPath);
-        if (!fileSystem.exists(resolvedPath)) {
-          violations.push({
-            file: filePath,
-            message: `Broken link: "${linkTarget}"`,
-            line: i + 1
-          });
-        }
-      }
-      match = linkPattern.exec(line);
+  let entries;
+  try {
+    entries = await fileSystem.readdir(dirPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
     }
+    throw error;
   }
-  return violations;
-}
-function validateIdeaOpenQuestions(filePath, content) {
-  const violations = [];
-  const lines = content.split(`
-`);
-  let inOpenQuestions = false;
-  let currentQuestionLine = null;
-  let inCodeBlock = false;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("```")) {
-      inCodeBlock = !inCodeBlock;
-      continue;
-    }
-    if (inCodeBlock)
-      continue;
-    if (line.startsWith("## ")) {
-      if (inOpenQuestions && currentQuestionLine !== null) {
-        violations.push({
-          file: filePath,
-          message: "Question has no options listed beneath it",
-          line: currentQuestionLine
-        });
-      }
-      const headingText = line.slice(3).trimEnd();
-      if (headingText.toLowerCase() === "open questions" && headingText !== "Open Questions") {
-        violations.push({
-          file: filePath,
-          message: `Heading "${line.trimEnd()}" should be "## Open Questions"`,
-          line: i + 1
-        });
-      }
-      inOpenQuestions = line === "## Open Questions";
-      currentQuestionLine = null;
-      continue;
-    }
-    if (!inOpenQuestions)
-      continue;
-    if (/^[-*] /.test(line.trimStart())) {
+  for (const entry of entries) {
+    const entryPath = `${dirPath}/${entry}`;
+    if (entry.startsWith(".")) {
       violations.push({
-        file: filePath,
-        message: "Open Questions must use ### headings for questions and #### headings for options, not bullet points. Run `dust new idea` to see the expected format.",
-        line: i + 1
+        file: entryPath,
+        message: `Hidden file "${entry}" found in content directory`
       });
       continue;
     }
-    if (line.startsWith("### ")) {
-      if (currentQuestionLine !== null) {
-        violations.push({
-          file: filePath,
-          message: "Question has no options listed beneath it",
-          line: currentQuestionLine
-        });
-      }
-      if (!line.trimEnd().endsWith("?")) {
-        violations.push({
-          file: filePath,
-          message: 'Questions must end with "?" (e.g., "### Should we take our own payments?")',
-          line: i + 1
-        });
-        currentQuestionLine = null;
-      } else {
-        currentQuestionLine = i + 1;
-      }
+    if (fileSystem.isDirectory(entryPath)) {
+      violations.push({
+        file: entryPath,
+        message: `Subdirectory "${entry}" found in content directory (content directories should be flat)`
+      });
       continue;
     }
-    if (line.startsWith("#### ")) {
-      currentQuestionLine = null;
+    if (!entry.endsWith(".md")) {
+      violations.push({
+        file: entryPath,
+        message: `Non-markdown file "${entry}" found in content directory`
+      });
     }
   }
-  if (inOpenQuestions && currentQuestionLine !== null) {
-    violations.push({
-      file: filePath,
-      message: "Question has no options listed beneath it",
-      line: currentQuestionLine
-    });
-  }
   return violations;
 }
-var SEMANTIC_RULES = [
-  {
-    section: "## Goals",
-    requiredPath: "/.dust/goals/",
-    description: "goal"
-  },
-  {
-    section: "## Blocked By",
-    requiredPath: "/.dust/tasks/",
-    description: "task"
-  }
-];
-function validateSemanticLinks(filePath, content) {
+async function validateDirectoryStructure(dustPath, fileSystem, extraDirectories = []) {
   const violations = [];
-  const lines = content.split(`
-`);
-  const fileDir = dirname3(filePath);
-  let currentSection = null;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("## ")) {
-      currentSection = line;
-      continue;
+  let entries;
+  try {
+    entries = await fileSystem.readdir(dustPath);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return [];
     }
-    const rule = SEMANTIC_RULES.find((r) => r.section === currentSection);
-    if (!rule)
+    throw error;
+  }
+  const allowedDirectories = new Set([
+    ...EXPECTED_DIRECTORIES,
+    ...extraDirectories
+  ]);
+  for (const entry of entries) {
+    const entryPath = `${dustPath}/${entry}`;
+    if (!fileSystem.isDirectory(entryPath)) {
       continue;
-    const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
-    let match = linkPattern.exec(line);
-    while (match) {
-      const linkTarget = match[2];
-      if (linkTarget.startsWith("#")) {
-        violations.push({
-          file: filePath,
-          message: `Link in "${rule.section}" must point to a ${rule.description} file, not an anchor: "${linkTarget}"`,
-          line: i + 1
-        });
-        match = linkPattern.exec(line);
-        continue;
-      }
-      if (linkTarget.startsWith("http://") || linkTarget.startsWith("https://")) {
-        violations.push({
-          file: filePath,
-          message: `Link in "${rule.section}" must point to a ${rule.description} file, not an external URL: "${linkTarget}"`,
-          line: i + 1
-        });
-        match = linkPattern.exec(line);
-        continue;
-      }
-      const targetPath = linkTarget.split("#")[0];
-      const resolvedPath = resolve(fileDir, targetPath);
-      if (!resolvedPath.includes(rule.requiredPath)) {
-        violations.push({
-          file: filePath,
-          message: `Link in "${rule.section}" must point to a ${rule.description} file: "${linkTarget}"`,
-          line: i + 1
-        });
-      }
-      match = linkPattern.exec(line);
+    }
+    if (!allowedDirectories.has(entry)) {
+      const allowedList = [...allowedDirectories].sort().join(", ");
+      violations.push({
+        file: entryPath,
+        message: `Unexpected directory "${entry}" in .dust/. Allowed directories: ${allowedList}. To allow this directory, add it to "extraDirectories" in .dust/config/settings.json`
+      });
     }
   }
   return violations;
 }
-function validateIdeaTransitionTitle(filePath, content, ideasPath, fileSystem) {
+
+// lib/lint/validators/filename-validator.ts
+var SLUG_PATTERN = /^[a-z0-9]+(-[a-z0-9]+)*\.md$/;
+function validateFilename(filePath) {
+  const parts = filePath.split("/");
+  const filename = parts[parts.length - 1];
+  if (!SLUG_PATTERN.test(filename)) {
+    return {
+      file: filePath,
+      message: `Filename "${filename}" does not match slug-style naming`
+    };
+  }
+  return null;
+}
+function validateTitleFilenameMatch(filePath, content) {
   const title = extractTitle(content);
   if (!title) {
     return null;
   }
-  for (const prefix of IDEA_TRANSITION_PREFIXES) {
-    if (title.startsWith(prefix)) {
-      const ideaTitle = title.slice(prefix.length);
-      const ideaFilename = titleToFilename(ideaTitle);
-      if (!fileSystem.exists(`${ideasPath}/${ideaFilename}`)) {
-        return {
-          file: filePath,
-          message: `Idea transition task references non-existent idea: "${ideaTitle}" (expected file "${ideaFilename}" in ideas/)`
-        };
-      }
-      return null;
-    }
+  const parts = filePath.split("/");
+  const actualFilename = parts[parts.length - 1];
+  const expectedFilename = titleToFilename(title);
+  if (actualFilename !== expectedFilename) {
+    return {
+      file: filePath,
+      message: `Filename "${actualFilename}" does not match title "${title}" (expected "${expectedFilename}")`
+    };
   }
   return null;
 }
+
+// lib/lint/validators/goal-hierarchy.ts
+import { dirname as dirname3, resolve } from "node:path";
+var REQUIRED_GOAL_HEADINGS = ["## Parent Goal", "## Sub-Goals"];
 function validateGoalHierarchySections(filePath, content) {
   const violations = [];
   for (const heading of REQUIRED_GOAL_HEADINGS) {
@@ -3527,57 +3602,6 @@ function validateGoalHierarchySections(filePath, content) {
   }
   return violations;
 }
-function validateGoalHierarchyLinks(filePath, content) {
-  const violations = [];
-  const lines = content.split(`
-`);
-  const fileDir = dirname3(filePath);
-  let currentSection = null;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("## ")) {
-      currentSection = line;
-      continue;
-    }
-    if (currentSection !== "## Parent Goal" && currentSection !== "## Sub-Goals") {
-      continue;
-    }
-    const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
-    let match = linkPattern.exec(line);
-    while (match) {
-      const linkTarget = match[2];
-      if (linkTarget.startsWith("#")) {
-        violations.push({
-          file: filePath,
-          message: `Link in "${currentSection}" must point to a goal file, not an anchor: "${linkTarget}"`,
-          line: i + 1
-        });
-        match = linkPattern.exec(line);
-        continue;
-      }
-      if (linkTarget.startsWith("http://") || linkTarget.startsWith("https://")) {
-        violations.push({
-          file: filePath,
-          message: `Link in "${currentSection}" must point to a goal file, not an external URL: "${linkTarget}"`,
-          line: i + 1
-        });
-        match = linkPattern.exec(line);
-        continue;
-      }
-      const targetPath = linkTarget.split("#")[0];
-      const resolvedPath = resolve(fileDir, targetPath);
-      if (!resolvedPath.includes("/.dust/goals/")) {
-        violations.push({
-          file: filePath,
-          message: `Link in "${currentSection}" must point to a goal file: "${linkTarget}"`,
-          line: i + 1
-        });
-      }
-      match = linkPattern.exec(line);
-    }
-  }
-  return violations;
-}
 function extractGoalRelationships(filePath, content) {
   const lines = content.split(`
 `);
@@ -3673,86 +3697,266 @@ function validateNoCycles(allGoalRelationships) {
   }
   return violations;
 }
-async function safeScanDir(glob, dirPath) {
-  const files = [];
-  try {
-    for await (const file of glob.scan(dirPath)) {
-      files.push(file);
+
+// lib/lint/validators/idea-validator.ts
+function validateIdeaOpenQuestions(filePath, content) {
+  const violations = [];
+  const lines = content.split(`
+`);
+  let inOpenQuestions = false;
+  let currentQuestionLine = null;
+  let inCodeBlock = false;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      inCodeBlock = !inCodeBlock;
+      continue;
     }
-    return { files, exists: true };
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return { files: [], exists: false };
+    if (inCodeBlock)
+      continue;
+    if (line.startsWith("## ")) {
+      if (inOpenQuestions && currentQuestionLine !== null) {
+        violations.push({
+          file: filePath,
+          message: "Question has no options listed beneath it",
+          line: currentQuestionLine
+        });
+      }
+      const headingText = line.slice(3).trimEnd();
+      if (headingText.toLowerCase() === "open questions" && headingText !== "Open Questions") {
+        violations.push({
+          file: filePath,
+          message: `Heading "${line.trimEnd()}" should be "## Open Questions"`,
+          line: i + 1
+        });
+      }
+      inOpenQuestions = line === "## Open Questions";
+      currentQuestionLine = null;
+      continue;
     }
-    throw error;
+    if (!inOpenQuestions)
+      continue;
+    if (/^[-*] /.test(line.trimStart())) {
+      violations.push({
+        file: filePath,
+        message: "Open Questions must use ### headings for questions and #### headings for options, not bullet points. Run `dust new idea` to see the expected format.",
+        line: i + 1
+      });
+      continue;
+    }
+    if (line.startsWith("### ")) {
+      if (currentQuestionLine !== null) {
+        violations.push({
+          file: filePath,
+          message: "Question has no options listed beneath it",
+          line: currentQuestionLine
+        });
+      }
+      if (!line.trimEnd().endsWith("?")) {
+        violations.push({
+          file: filePath,
+          message: 'Questions must end with "?" (e.g., "### Should we take our own payments?")',
+          line: i + 1
+        });
+        currentQuestionLine = null;
+      } else {
+        currentQuestionLine = i + 1;
+      }
+      continue;
+    }
+    if (line.startsWith("#### ")) {
+      currentQuestionLine = null;
+    }
+  }
+  if (inOpenQuestions && currentQuestionLine !== null) {
+    violations.push({
+      file: filePath,
+      message: "Question has no options listed beneath it",
+      line: currentQuestionLine
+    });
   }
+  return violations;
 }
-async function validateContentDirectoryFiles(dirPath, fileSystem) {
+function validateIdeaTransitionTitle(filePath, content, ideasPath, fileSystem) {
+  const title = extractTitle(content);
+  if (!title) {
+    return null;
+  }
+  for (const prefix of IDEA_TRANSITION_PREFIXES) {
+    if (title.startsWith(prefix)) {
+      const ideaTitle = title.slice(prefix.length);
+      const ideaFilename = titleToFilename(ideaTitle);
+      if (!fileSystem.exists(`${ideasPath}/${ideaFilename}`)) {
+        return {
+          file: filePath,
+          message: `Idea transition task references non-existent idea: "${ideaTitle}" (expected file "${ideaFilename}" in ideas/)`
+        };
+      }
+      return null;
+    }
+  }
+  return null;
+}
+
+// lib/lint/validators/link-validator.ts
+import { dirname as dirname4, resolve as resolve2 } from "node:path";
+var SEMANTIC_RULES = [
+  {
+    section: "## Goals",
+    requiredPath: "/.dust/goals/",
+    description: "goal"
+  },
+  {
+    section: "## Blocked By",
+    requiredPath: "/.dust/tasks/",
+    description: "task"
+  }
+];
+function validateLinks(filePath, content, fileSystem) {
   const violations = [];
-  let entries;
-  try {
-    entries = await fileSystem.readdir(dirPath);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
+  const lines = content.split(`
+`);
+  const fileDir = dirname4(filePath);
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
+    let match = linkPattern.exec(line);
+    while (match) {
+      const linkTarget = match[2];
+      if (!linkTarget.startsWith("http://") && !linkTarget.startsWith("https://") && !linkTarget.startsWith("#")) {
+        const targetPath = linkTarget.split("#")[0];
+        const resolvedPath = resolve2(fileDir, targetPath);
+        if (!fileSystem.exists(resolvedPath)) {
+          violations.push({
+            file: filePath,
+            message: `Broken link: "${linkTarget}"`,
+            line: i + 1
+          });
+        }
+      }
+      match = linkPattern.exec(line);
     }
-    throw error;
   }
-  for (const entry of entries) {
-    const entryPath = `${dirPath}/${entry}`;
-    if (entry.startsWith(".")) {
-      violations.push({
-        file: entryPath,
-        message: `Hidden file "${entry}" found in content directory`
-      });
+  return violations;
+}
+function validateSemanticLinks(filePath, content) {
+  const violations = [];
+  const lines = content.split(`
+`);
+  const fileDir = dirname4(filePath);
+  let currentSection = null;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      currentSection = line;
       continue;
     }
-    if (fileSystem.isDirectory(entryPath)) {
-      violations.push({
-        file: entryPath,
-        message: `Subdirectory "${entry}" found in content directory (content directories should be flat)`
-      });
+    const rule = SEMANTIC_RULES.find((r) => r.section === currentSection);
+    if (!rule)
       continue;
-    }
-    if (!entry.endsWith(".md")) {
-      violations.push({
-        file: entryPath,
-        message: `Non-markdown file "${entry}" found in content directory`
-      });
+    const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
+    let match = linkPattern.exec(line);
+    while (match) {
+      const linkTarget = match[2];
+      if (linkTarget.startsWith("#")) {
+        violations.push({
+          file: filePath,
+          message: `Link in "${rule.section}" must point to a ${rule.description} file, not an anchor: "${linkTarget}"`,
+          line: i + 1
+        });
+        match = linkPattern.exec(line);
+        continue;
+      }
+      if (linkTarget.startsWith("http://") || linkTarget.startsWith("https://")) {
+        violations.push({
+          file: filePath,
+          message: `Link in "${rule.section}" must point to a ${rule.description} file, not an external URL: "${linkTarget}"`,
+          line: i + 1
+        });
+        match = linkPattern.exec(line);
+        continue;
+      }
+      const targetPath = linkTarget.split("#")[0];
+      const resolvedPath = resolve2(fileDir, targetPath);
+      if (!resolvedPath.includes(rule.requiredPath)) {
+        violations.push({
+          file: filePath,
+          message: `Link in "${rule.section}" must point to a ${rule.description} file: "${linkTarget}"`,
+          line: i + 1
+        });
+      }
+      match = linkPattern.exec(line);
     }
   }
   return violations;
 }
-async function validateDirectoryStructure(dustPath, fileSystem, extraDirectories = []) {
+function validateGoalHierarchyLinks(filePath, content) {
   const violations = [];
-  let entries;
-  try {
-    entries = await fileSystem.readdir(dustPath);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      return [];
+  const lines = content.split(`
+`);
+  const fileDir = dirname4(filePath);
+  let currentSection = null;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("## ")) {
+      currentSection = line;
+      continue;
     }
-    throw error;
-  }
-  const allowedDirectories = new Set([
-    ...EXPECTED_DIRECTORIES,
-    ...extraDirectories
-  ]);
-  for (const entry of entries) {
-    const entryPath = `${dustPath}/${entry}`;
-    if (!fileSystem.isDirectory(entryPath)) {
+    if (currentSection !== "## Parent Goal" && currentSection !== "## Sub-Goals") {
       continue;
     }
-    if (!allowedDirectories.has(entry)) {
-      const allowedList = [...allowedDirectories].sort().join(", ");
-      violations.push({
-        file: entryPath,
-        message: `Unexpected directory "${entry}" in .dust/. Allowed directories: ${allowedList}. To allow this directory, add it to "extraDirectories" in .dust/config/settings.json`
-      });
+    const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
+    let match = linkPattern.exec(line);
+    while (match) {
+      const linkTarget = match[2];
+      if (linkTarget.startsWith("#")) {
+        violations.push({
+          file: filePath,
+          message: `Link in "${currentSection}" must point to a goal file, not an anchor: "${linkTarget}"`,
+          line: i + 1
+        });
+        match = linkPattern.exec(line);
+        continue;
+      }
+      if (linkTarget.startsWith("http://") || linkTarget.startsWith("https://")) {
+        violations.push({
+          file: filePath,
+          message: `Link in "${currentSection}" must point to a goal file, not an external URL: "${linkTarget}"`,
+          line: i + 1
+        });
+        match = linkPattern.exec(line);
+        continue;
+      }
+      const targetPath = linkTarget.split("#")[0];
+      const resolvedPath = resolve2(fileDir, targetPath);
+      if (!resolvedPath.includes("/.dust/goals/")) {
+        violations.push({
+          file: filePath,
+          message: `Link in "${currentSection}" must point to a goal file: "${linkTarget}"`,
+          line: i + 1
+        });
+      }
+      match = linkPattern.exec(line);
     }
   }
   return violations;
 }
+
+// lib/cli/commands/lint-markdown.ts
+async function safeScanDir(glob, dirPath) {
+  const files = [];
+  try {
+    for await (const file of glob.scan(dirPath)) {
+      files.push(file);
+    }
+    return { files, exists: true };
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { files: [], exists: false };
+    }
+    throw error;
+  }
+}
 async function lintMarkdown(dependencies) {
   const { context, fileSystem, globScanner: glob } = dependencies;
   const dustPath = `${context.cwd}/.dust`;
@@ -3766,7 +3970,7 @@ async function lintMarkdown(dependencies) {
   const violations = [];
   context.stdout("Validating directory structure...");
   violations.push(...await validateDirectoryStructure(dustPath, fileSystem, dependencies.settings.extraDirectories));
-  const settingsPath = join9(dustPath, "config", "settings.json");
+  const settingsPath = join10(dustPath, "config", "settings.json");
   if (fileSystem.exists(settingsPath)) {
     context.stdout("Validating settings.json...");
     try {
@@ -3927,12 +4131,16 @@ async function lintMarkdown(dependencies) {
 }
 
 // lib/cli/commands/check.ts
+var log5 = createLogger("dust.cli.commands.check");
 var DEFAULT_CHECK_TIMEOUT_MS = 13000;
 async function runSingleCheck(check, cwd, runner) {
   const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
+  log5(`running check ${check.name}: ${check.command}`);
   const startTime = Date.now();
   const result = await runner.run(check.command, cwd, timeoutMs);
   const durationMs = Date.now() - startTime;
+  const status = result.timedOut ? "timed out" : result.exitCode === 0 ? "passed" : "failed";
+  log5(`check ${check.name} ${status} (${durationMs}ms)`);
   return {
     name: check.name,
     command: check.command,
@@ -3962,6 +4170,7 @@ async function runValidationCheck(dependencies) {
     stdout: (msg) => outputLines.push(msg),
     stderr: (msg) => outputLines.push(msg)
   };
+  log5("running built-in check: dust lint");
   const startTime = Date.now();
   const result = await lintMarkdown({
     ...dependencies,
@@ -3969,6 +4178,8 @@ async function runValidationCheck(dependencies) {
     arguments: []
   });
   const durationMs = Date.now() - startTime;
+  const lintStatus = result.exitCode === 0 ? "passed" : "failed";
+  log5(`built-in check dust lint ${lintStatus} (${durationMs}ms)`);
   return {
     name: "lint",
     command: "dust lint",
@@ -4024,6 +4235,7 @@ async function check(dependencies, shellRunner = defaultShellRunner) {
     settings
   } = dependencies;
   const serial = commandArguments.includes("--serial");
+  setLogScope("check");
   if (!settings.checks || settings.checks.length === 0) {
     context.stderr("Error: No checks configured in .dust/config/settings.json");
     context.stderr("");
@@ -4155,7 +4367,7 @@ function agentsMdContent(dustCommand) {
     Always immediately run \`${dustCommand} agent\` when you start working in this repository.
   `;
 }
-async function init(dependencies) {
+async function init2(dependencies) {
   const { context, fileSystem } = dependencies;
   const colors = getColors();
   const dustPath = `${context.cwd}/.dust`;
@@ -4363,7 +4575,7 @@ var defaultDependencies2 = {
   createInterface: nodeCreateInterface2
 };
 async function* spawnCodex(prompt, options = {}, dependencies = defaultDependencies2) {
-  const { cwd, env } = options;
+  const { cwd, env, signal } = options;
   const codexArguments = ["exec", prompt, "--json", "--yolo"];
   if (cwd) {
     codexArguments.push("--cd", cwd);
@@ -4375,22 +4587,14 @@ async function* spawnCodex(prompt, options = {}, dependencies = defaultDependenc
   if (!proc.stdout) {
     throw new Error("Failed to get stdout from codex process");
   }
-  const rl = dependencies.createInterface({ input: proc.stdout });
-  for await (const line of rl) {
-    if (!line.trim())
-      continue;
-    try {
-      yield JSON.parse(line);
-    } catch {}
-  }
   let stderrOutput = "";
   proc.stderr?.on("data", (data) => {
     stderrOutput += data.toString();
   });
-  await new Promise((resolve2, reject) => {
+  const closePromise = new Promise((resolve3, reject) => {
     proc.on("close", (code) => {
       if (code === 0 || code === null)
-        resolve2();
+        resolve3();
       else {
         const errMsg = stderrOutput.trim() ? `codex exited with code ${code}: ${stderrOutput.trim()}` : `codex exited with code ${code}`;
         reject(new Error(errMsg));
@@ -4398,6 +4602,30 @@ async function* spawnCodex(prompt, options = {}, dependencies = defaultDependenc
     });
     proc.on("error", reject);
   });
+  const abortHandler = () => {
+    if (!proc.killed) {
+      proc.kill();
+    }
+  };
+  if (signal?.aborted) {
+    abortHandler();
+  } else if (signal) {
+    signal.addEventListener("abort", abortHandler, { once: true });
+  }
+  const rl = dependencies.createInterface({ input: proc.stdout });
+  try {
+    for await (const line of rl) {
+      if (!line.trim())
+        continue;
+      try {
+        yield JSON.parse(line);
+      } catch {}
+    }
+    await closePromise;
+  } finally {
+    signal?.removeEventListener("abort", abortHandler);
+    rl.close?.();
+  }
 }
 
 // lib/codex/event-parser.ts
@@ -4785,7 +5013,7 @@ async function facts(dependencies) {
 
 // lib/cli/main.ts
 var commandRegistry = {
-  init,
+  init: init2,
   lint: lintMarkdown,
   list,
   tasks,