@joshski/dust 0.1.79 → 0.1.81

package/dist/dust.js

@@ -3,7 +3,7 @@ import { createRequire } from "node:module";
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 // lib/cli/run.ts
-import { existsSync, statSync as statSync3 } from "node:fs";
+import { existsSync as existsSync2, statSync as statSync3, writeSync } from "node:fs";
 import {
   chmod as chmod3,
   mkdir as mkdir3,
@@ -13,6 +13,18 @@ import {
   writeFile as writeFile3
 } from "node:fs/promises";
 
+// lib/command-events.ts
+function createEventEmitter(writeEvent) {
+  let sequence = 0;
+  return (event) => {
+    writeEvent({
+      sequence: sequence++,
+      timestamp: new Date().toISOString(),
+      event
+    });
+  };
+}
+
 // lib/git/file-sorter.ts
 function createGitDirectoryFileSorter(gitRunner) {
   return async (dir, files) => {
@@ -306,7 +318,7 @@ async function loadSettings(cwd, fileSystem) {
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.79";
+var DUST_VERSION = "0.1.81";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";
@@ -1664,7 +1676,7 @@ async function audit(dependencies) {
 }
 
 // lib/cli/commands/bucket.ts
-import { spawn as nodeSpawn4 } from "node:child_process";
+import { spawn as nodeSpawn5 } from "node:child_process";
 import { accessSync, statSync } from "node:fs";
 import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
@@ -1710,9 +1722,9 @@ async function clearToken(fileSystem, homeDir) {
     throw error;
   }
 }
-async function defaultExchangeCode(code) {
+async function defaultExchangeCode(code, fetchFn = fetch) {
   const host = getDustbucketHost();
-  const response = await fetch(`${host}/auth/cli/exchange`, {
+  const response = await fetchFn(`${host}/auth/cli/exchange`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify({ code })
@@ -2021,6 +2033,31 @@ var defaultDependencies = {
   spawn: nodeSpawn2,
   createInterface: nodeCreateInterface
 };
+function buildDockerRunArguments(docker, claudeArguments, env) {
+  const dockerArguments = [
+    "run",
+    "--rm",
+    "-i",
+    "-v",
+    `${docker.repoPath}:/workspace`,
+    "-w",
+    "/workspace",
+    "-v",
+    `${docker.homeDir}/.claude:/root/.claude:ro`,
+    "-v",
+    `${docker.homeDir}/.ssh:/root/.ssh:ro`
+  ];
+  if (docker.hasGitconfig) {
+    dockerArguments.push("-v", `${docker.homeDir}/.gitconfig:/root/.gitconfig:ro`);
+  }
+  for (const [key, value] of Object.entries(env)) {
+    dockerArguments.push("-e", `${key}=${value}`);
+  }
+  dockerArguments.push(docker.imageTag);
+  dockerArguments.push("claude");
+  dockerArguments.push(...claudeArguments);
+  return dockerArguments;
+}
 async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDependencies) {
   const {
     cwd,
@@ -2031,7 +2068,8 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
     sessionId,
     dangerouslySkipPermissions,
     env,
-    signal
+    signal,
+    docker
   } = options;
   const claudeArguments = [
     "-p",
@@ -2059,10 +2097,15 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
   if (dangerouslySkipPermissions) {
     claudeArguments.push("--dangerously-skip-permissions");
   }
-  const proc = dependencies.spawn("claude", claudeArguments, {
+  const mergedEnv = { ...process.env, ...env };
+  const proc = docker ? dependencies.spawn("docker", buildDockerRunArguments(docker, claudeArguments, env ?? {}), {
     cwd,
     stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, ...env }
+    env: mergedEnv
+  }) : dependencies.spawn("claude", claudeArguments, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: mergedEnv
   });
   if (!proc.stdout) {
     throw new Error("Failed to get stdout from claude process");
@@ -2438,30 +2481,45 @@ function getRepoPath(repoName, reposDir) {
   const safeName = repoName.replace(/[^a-zA-Z0-9-_/]/g, "-");
   return join7(reposDir, safeName);
 }
-async function cloneRepository(repository, targetPath, spawn, context) {
+function cloneWithUrl(url, targetPath, spawn) {
   return new Promise((resolve) => {
-    const proc = spawn("git", ["clone", repository.gitUrl, targetPath], {
+    const proc = spawn("git", ["clone", url, targetPath], {
       stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+      env: {
+        ...process.env,
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_SSH_COMMAND: "ssh -o StrictHostKeyChecking=accept-new"
+      }
     });
     let stderr = "";
     proc.stderr?.on("data", (data) => {
       stderr += data.toString();
     });
     proc.on("close", (code) => {
-      if (code === 0) {
-        resolve(true);
-      } else {
-        context.stderr(`Failed to clone ${repository.name}: ${stderr.trim()}`);
-        resolve(false);
-      }
+      resolve({ success: code === 0, stderr: stderr.trim() });
     });
     proc.on("error", (error) => {
-      context.stderr(`Failed to clone ${repository.name}: ${error.message}`);
-      resolve(false);
+      resolve({ success: false, stderr: error.message });
     });
   });
 }
+async function cloneRepository(repository, targetPath, spawn, context) {
+  const httpsResult = await cloneWithUrl(repository.gitUrl, targetPath, spawn);
+  if (httpsResult.success) {
+    return true;
+  }
+  if (repository.gitSshUrl) {
+    context.stderr(`HTTPS clone failed for ${repository.name}, trying SSH: ${httpsResult.stderr}`);
+    const sshResult = await cloneWithUrl(repository.gitSshUrl, targetPath, spawn);
+    if (sshResult.success) {
+      return true;
+    }
+    context.stderr(`Failed to clone ${repository.name} via SSH: ${sshResult.stderr}`);
+    return false;
+  }
+  context.stderr(`Failed to clone ${repository.name}: ${httpsResult.stderr}`);
+  return false;
+}
 async function removeRepository(path, spawn, context) {
   return new Promise((resolve) => {
     const proc = spawn("rm", ["-rf", path], {
@@ -2522,7 +2580,66 @@ function formatAgentEvent(event) {
 
 // lib/cli/commands/loop.ts
 import { spawn as nodeSpawn3 } from "node:child_process";
+import { existsSync } from "node:fs";
 import os from "node:os";
+import path2 from "node:path";
+
+// lib/docker/docker-agent.ts
+import path from "node:path";
+var log = createLogger("dust:docker:agent");
+async function isDockerAvailable(dependencies) {
+  return new Promise((resolve) => {
+    const proc = dependencies.spawn("docker", ["--version"], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0);
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+  });
+}
+function generateImageTag(repoPath) {
+  const repoName = path.basename(repoPath);
+  const sanitized = repoName.toLowerCase().replace(/[^a-z0-9._-]/g, "-");
+  return `dust-agent-${sanitized}`;
+}
+async function buildDockerImage(config, dependencies) {
+  const dockerfilePath = path.join(config.repoPath, ".dust", "Dockerfile");
+  log(`building Docker image ${config.imageTag} from ${dockerfilePath}`);
+  return new Promise((resolve) => {
+    const proc = dependencies.spawn("docker", ["build", "-t", config.imageTag, "-f", dockerfilePath, config.repoPath], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        log(`Docker image ${config.imageTag} built successfully`);
+        resolve({ success: true });
+      } else {
+        log(`Docker build failed: ${stderr}`);
+        resolve({
+          success: false,
+          error: `Docker build failed with exit code ${code}: ${stderr.trim()}`
+        });
+      }
+    });
+    proc.on("error", (error) => {
+      resolve({
+        success: false,
+        error: `Docker build failed: ${error.message}`
+      });
+    });
+  });
+}
+function hasDockerfile(repoPath, dependencies) {
+  const dockerfilePath = path.join(repoPath, ".dust", "Dockerfile");
+  return dependencies.existsSync(dockerfilePath);
+}
 
 // lib/artifacts/workflow-tasks.ts
 var IDEA_TRANSITION_PREFIXES = [
@@ -2530,10 +2647,79 @@ var IDEA_TRANSITION_PREFIXES = [
   "Decompose Idea: ",
   "Shelve Idea: "
 ];
+var CAPTURE_IDEA_PREFIX = "Add Idea: ";
 var EXPEDITE_IDEA_PREFIX = "Expedite Idea: ";
 function titleToFilename(title) {
   return `${title.toLowerCase().replace(/\./g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
+var WORKFLOW_SECTION_HEADINGS = [
+  { type: "refine", heading: "Refines Idea" },
+  { type: "decompose-idea", heading: "Decomposes Idea" },
+  { type: "shelve", heading: "Shelves Idea" }
+];
+function extractIdeaSlugFromSection(content, sectionHeading) {
+  const lines = content.split(`
+`);
+  let inSection = false;
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      inSection = line.trimEnd() === `## ${sectionHeading}`;
+      continue;
+    }
+    if (!inSection)
+      continue;
+    if (line.startsWith("# "))
+      break;
+    const linkMatch = line.match(MARKDOWN_LINK_PATTERN);
+    if (linkMatch) {
+      const target = linkMatch[2];
+      const slugMatch = target.match(/([^/]+)\.md$/);
+      if (slugMatch) {
+        return slugMatch[1];
+      }
+    }
+  }
+  return null;
+}
+async function findAllWorkflowTasks(fileSystem, dustPath) {
+  const tasksPath = `${dustPath}/tasks`;
+  const captureIdeaTasks = [];
+  const workflowTasksByIdeaSlug = new Map;
+  if (!fileSystem.exists(tasksPath)) {
+    return { captureIdeaTasks, workflowTasksByIdeaSlug };
+  }
+  const files = await fileSystem.readdir(tasksPath);
+  for (const file of files.filter((f) => f.endsWith(".md")).sort()) {
+    const content = await fileSystem.readFile(`${tasksPath}/${file}`);
+    const titleMatch = content.match(/^#\s+(.+)$/m);
+    if (!titleMatch)
+      continue;
+    const title = titleMatch[1].trim();
+    const taskSlug = file.replace(/\.md$/, "");
+    if (title.startsWith(CAPTURE_IDEA_PREFIX)) {
+      captureIdeaTasks.push({
+        taskSlug,
+        ideaTitle: title.slice(CAPTURE_IDEA_PREFIX.length)
+      });
+    } else if (title.startsWith(EXPEDITE_IDEA_PREFIX)) {
+      captureIdeaTasks.push({
+        taskSlug,
+        ideaTitle: title.slice(EXPEDITE_IDEA_PREFIX.length)
+      });
+    }
+    for (const { type, heading } of WORKFLOW_SECTION_HEADINGS) {
+      const linkedSlug = extractIdeaSlugFromSection(content, heading);
+      if (linkedSlug) {
+        workflowTasksByIdeaSlug.set(linkedSlug, {
+          type,
+          ideaSlug: linkedSlug,
+          taskSlug
+        });
+      }
+    }
+  }
+  return { captureIdeaTasks, workflowTasksByIdeaSlug };
+}
 
 // lib/cli/commands/focus.ts
 function buildImplementationInstructions(bin, hooksInstalled, taskTitle, taskPath, installCommand) {
@@ -2669,9 +2855,25 @@ async function next(dependencies) {
     return { exitCode: 1 };
   }
   if (result.tasks.length === 0) {
+    context.emitEvent?.({
+      type: "tasks-listed",
+      tasks: []
+    });
     return { exitCode: 0 };
   }
   printTaskList(context, result.tasks);
+  context.emitEvent?.({
+    type: "tasks-listed",
+    tasks: result.tasks.map((task) => {
+      const parts = task.path.split("/");
+      const filename = parts[parts.length - 1];
+      return {
+        path: task.path,
+        title: task.title ?? filename.replace(".md", ""),
+        blockedBy: []
+      };
+    })
+  });
   return { exitCode: 0 };
 }
 
@@ -2708,6 +2910,14 @@ function formatLoopEvent(event) {
       return `Completed iteration ${event.iteration}/${event.maxIterations}`;
     case "loop.ended":
       return `Reached max iterations (${event.maxIterations}). Exiting.`;
+    case "loop.docker_detected":
+      return `Docker mode: found .dust/Dockerfile (image: ${event.imageTag})`;
+    case "loop.docker_building":
+      return `Building Docker image ${event.imageTag}...`;
+    case "loop.docker_built":
+      return `Docker image ${event.imageTag} ready`;
+    case "loop.docker_error":
+      return `Docker error: ${event.error}`;
   }
 }
 function createPostEvent(fetchFn) {
@@ -2747,7 +2957,7 @@ function createWireEventSender(eventsUrl, sessionId, postEvent, onError, getAgen
     postEvent(eventsUrl, payload).catch(onError);
   };
 }
-var log = createLogger("dust:cli:commands:loop");
+var log2 = createLogger("dust:cli:commands:loop");
 var SLEEP_INTERVAL_MS = 30000;
 var SLEEP_STEP_MS = 1000;
 var DEFAULT_MAX_ITERATIONS = 10;
@@ -2797,15 +3007,16 @@ async function runOneIteration(dependencies, loopDependencies, onLoopEvent, onAg
     onRawEvent,
     hooksInstalled = false,
     signal,
-    logger = log,
-    repositoryId
+    logger = log2,
+    repositoryId,
+    docker
   } = options;
   const baseEnv = buildUnattendedEnv({ repositoryId });
-  log("syncing with remote");
+  log2("syncing with remote");
   onLoopEvent({ type: "loop.syncing" });
   const pullResult = await gitPull(context.cwd, spawn);
   if (!pullResult.success) {
-    log(`git pull failed: ${pullResult.message}`);
+    log2(`git pull failed: ${pullResult.message}`);
     onLoopEvent({
       type: "loop.sync_skipped",
       reason: pullResult.message
@@ -2836,7 +3047,8 @@ Make sure the repository is in a clean state and synced with remote before finis
           cwd: context.cwd,
           dangerouslySkipPermissions: true,
           env: baseEnv,
-          signal
+          signal,
+          docker
         },
         onRawEvent
       });
@@ -2855,12 +3067,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");
+    log2("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}`);
+  log2(`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;
@@ -2888,11 +3100,12 @@ ${instructions}`;
         cwd: context.cwd,
         dangerouslySkipPermissions: true,
         env: baseEnv,
-        signal
+        signal,
+        docker
       },
       onRawEvent
     });
-    log(`${agentName} completed task: ${task.title ?? task.path}`);
+    log2(`${agentName} completed task: ${task.title ?? task.path}`);
     onAgentEvent?.({ type: "agent-session-ended", success: true });
     return "ran_claude";
   } catch (error) {
@@ -2947,7 +3160,36 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
     sendWireEvent(event);
   };
   const hooksInstalled = await manageGitHooks(dependencies);
-  log(`starting loop, maxIterations=${maxIterations}, sessionId=${sessionId}`);
+  let dockerConfig;
+  const dockerDeps = {
+    spawn: loopDependencies.dockerDeps?.spawn ?? loopDependencies.spawn,
+    homedir: loopDependencies.dockerDeps?.homedir ?? os.homedir,
+    existsSync: loopDependencies.dockerDeps?.existsSync ?? existsSync
+  };
+  if (hasDockerfile(context.cwd, dockerDeps)) {
+    const imageTag = generateImageTag(context.cwd);
+    onLoopEvent({ type: "loop.docker_detected", imageTag });
+    if (!await isDockerAvailable(dockerDeps)) {
+      context.stderr("Docker not available. Install Docker or remove .dust/Dockerfile to run without Docker.");
+      return { exitCode: 1 };
+    }
+    onLoopEvent({ type: "loop.docker_building", imageTag });
+    const buildResult = await buildDockerImage({ repoPath: context.cwd, imageTag }, dockerDeps);
+    if (!buildResult.success) {
+      onLoopEvent({ type: "loop.docker_error", error: buildResult.error });
+      context.stderr(buildResult.error);
+      return { exitCode: 1 };
+    }
+    onLoopEvent({ type: "loop.docker_built", imageTag });
+    const homeDir = os.homedir();
+    dockerConfig = {
+      imageTag,
+      repoPath: context.cwd,
+      homeDir,
+      hasGitconfig: existsSync(path2.join(homeDir, ".gitconfig"))
+    };
+  }
+  log2(`starting loop, maxIterations=${maxIterations}, sessionId=${sessionId}`);
   onLoopEvent({ type: "loop.warning" });
   onLoopEvent({
     type: "loop.started",
@@ -2957,7 +3199,10 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
   context.stdout("   Press Ctrl+C to stop");
   context.stdout("");
   let completedIterations = 0;
-  const iterationOptions = { hooksInstalled };
+  const iterationOptions = {
+    hooksInstalled,
+    docker: dockerConfig
+  };
   if (eventsUrl) {
     iterationOptions.onRawEvent = createHeartbeatThrottler(onAgentEvent);
   }
@@ -2965,12 +3210,12 @@ 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");
+      log2("sleeping, no tasks");
       const writeInline = context.stdoutInline ?? context.stdout;
       await sleepWithProgress(loopDependencies.sleep, SLEEP_INTERVAL_MS, writeInline, context.stdout);
     } else {
       completedIterations++;
-      log(`iteration ${completedIterations}/${maxIterations} complete, result=${result}`);
+      log2(`iteration ${completedIterations}/${maxIterations} complete, result=${result}`);
       onLoopEvent({
         type: "loop.iteration_complete",
         iteration: completedIterations,
@@ -2978,13 +3223,135 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
       });
     }
   }
-  log(`loop ended after ${completedIterations} iterations`);
+  log2(`loop ended after ${completedIterations} iterations`);
   onLoopEvent({ type: "loop.ended", maxIterations });
   return { exitCode: 0 };
 }
 
+// lib/codex/spawn-codex.ts
+import { spawn as nodeSpawn4 } from "node:child_process";
+import { createInterface as nodeCreateInterface2 } from "node:readline";
+var debug2 = createLogger("dust.codex.spawn-codex");
+var defaultDependencies2 = {
+  spawn: nodeSpawn4,
+  createInterface: nodeCreateInterface2
+};
+async function* spawnCodex(prompt, options = {}, dependencies = defaultDependencies2) {
+  const { cwd, env, signal } = options;
+  const codexArguments = ["exec", prompt, "--json", "--yolo"];
+  if (cwd) {
+    codexArguments.push("--cd", cwd);
+  }
+  const proc = dependencies.spawn("codex", codexArguments, {
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...env }
+  });
+  if (!proc.stdout) {
+    throw new Error("Failed to get stdout from codex process");
+  }
+  let stderrOutput = "";
+  proc.stderr?.on("data", (data) => {
+    stderrOutput += data.toString();
+  });
+  const closePromise = new Promise((resolve, reject) => {
+    proc.on("close", (code) => {
+      if (code === 0 || code === null)
+        resolve();
+      else {
+        const errMsg = stderrOutput.trim() ? `codex exited with code ${code}: ${stderrOutput.trim()}` : `codex exited with code ${code}`;
+        reject(new Error(errMsg));
+      }
+    });
+    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 {
+        debug2("Skipping malformed JSON line: %s", line.slice(0, 200));
+      }
+    }
+    await closePromise;
+  } finally {
+    signal?.removeEventListener("abort", abortHandler);
+    rl.close?.();
+  }
+}
+
+// lib/codex/event-parser.ts
+function* parseCodexRawEvent(raw) {
+  if (raw.type !== "item.completed")
+    return;
+  const item = raw.item;
+  if (!item)
+    return;
+  if (item.type === "agent_message" && typeof item.text === "string") {
+    yield { type: "text_delta", text: `${item.text}
+` };
+  } else if (item.type === "command_execution" && typeof item.command === "string") {
+    yield {
+      type: "tool_use",
+      id: typeof item.id === "string" ? item.id : "",
+      name: "command_execution",
+      input: { command: item.command }
+    };
+    if (typeof item.aggregated_output === "string") {
+      yield {
+        type: "tool_result",
+        toolUseId: typeof item.id === "string" ? item.id : "",
+        content: item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})`
+      };
+    }
+  }
+}
+
+// lib/codex/streamer.ts
+async function streamCodexEvents(events, sink, onRawEvent) {
+  let hadTextOutput = false;
+  for await (const raw of events) {
+    onRawEvent?.(raw);
+    for (const event of parseCodexRawEvent(raw)) {
+      processEvent(event, sink, { hadTextOutput });
+      if (event.type === "text_delta") {
+        hadTextOutput = true;
+      } else if (event.type === "tool_use") {
+        hadTextOutput = false;
+      }
+    }
+  }
+}
+
+// lib/codex/run.ts
+var defaultRunnerDependencies2 = {
+  spawnCodex,
+  createStdoutSink,
+  streamCodexEvents
+};
+async function run2(prompt, options = {}, dependencies = defaultRunnerDependencies2) {
+  const isRunOptions = (opt) => ("spawnOptions" in opt) || ("onRawEvent" in opt);
+  const spawnOptions = isRunOptions(options) ? options.spawnOptions ?? {} : options;
+  const onRawEvent = isRunOptions(options) ? options.onRawEvent : undefined;
+  const events = dependencies.spawnCodex(prompt, spawnOptions);
+  const sink = dependencies.createStdoutSink();
+  await dependencies.streamCodexEvents(events, sink, onRawEvent);
+}
+
 // lib/bucket/repository-loop.ts
-var log2 = createLogger("dust:bucket:repository-loop");
+var log3 = createLogger("dust:bucket:repository-loop");
 var FALLBACK_TIMEOUT_MS = 300000;
 function createLogCallbacks(logBuffer) {
   return {
@@ -3030,59 +3397,40 @@ function createWakeUpHandler(repoState, resolve) {
 }
 function createNoOpGlobScanner() {
   return {
-    scan: async function* () {}
+    scan: async function* noOpScan() {}
   };
 }
-async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
-  const { spawn, run: run2, fileSystem, sleep } = repoDeps;
-  const repoName = repoState.repository.name;
-  const settings = await loadSettings(repoState.path, fileSystem);
-  const logCallbacks = createLogCallbacks(repoState.logBuffer);
-  const commandDeps = {
-    arguments: [],
-    context: {
-      cwd: repoState.path,
-      stdout: (msg) => logCallbacks.stdout(msg),
-      stderr: (msg) => logCallbacks.stderr(msg)
-    },
-    fileSystem,
-    globScanner: createNoOpGlobScanner(),
-    settings
-  };
-  let partialLine = "";
-  const bufferSinkDeps = {
-    ...defaultRunnerDependencies,
-    createStdoutSink: () => ({
-      write: (text) => {
-        partialLine += text;
-        const lines = partialLine.split(`
+function createBufferStdoutSink(loopState, logBuffer) {
+  return {
+    write(text) {
+      loopState.partialLine += text;
+      const lines = loopState.partialLine.split(`
 `);
-        for (let i = 0;i < lines.length - 1; i++) {
-          appendLogLine(repoState.logBuffer, createLogLine(lines[i], "stdout"));
-        }
-        partialLine = lines[lines.length - 1];
-      },
-      line: (text) => {
-        partialLine = flushAndLogMultiLine(partialLine, text, repoState.logBuffer);
+      for (let i = 0;i < lines.length - 1; i++) {
+        appendLogLine(logBuffer, createLogLine(lines[i], "stdout"));
       }
-    })
-  };
-  const bufferRun = (prompt, options) => run2(prompt, options, bufferSinkDeps);
-  const loopDeps = {
-    spawn,
-    run: bufferRun,
-    sleep,
-    postEvent: async () => {}
+      loopState.partialLine = lines[lines.length - 1];
+    },
+    line(text) {
+      loopState.partialLine = flushAndLogMultiLine(loopState.partialLine, text, logBuffer);
+    }
   };
-  let agentSessionId;
-  let sequence = 0;
-  const onLoopEvent = (event) => {
+}
+function createBufferRun(run3, bufferSinkDeps) {
+  return (prompt, options) => run3(prompt, options, bufferSinkDeps);
+}
+async function noOpPostEvent() {}
+function createLoopEventHandler(logBuffer) {
+  return function onLoopEvent(event) {
     const formatted = formatLoopEvent(event);
     if (formatted !== null) {
-      appendLogLine(repoState.logBuffer, createLogLine(formatted, "stdout"));
+      appendLogLine(logBuffer, createLogLine(formatted, "stdout"));
     }
   };
-  const onAgentEvent = (event) => {
+}
+function createAgentEventHandler(parameters) {
+  const { repoState, sendEvent, sessionId, repoName, loopState } = parameters;
+  return function onAgentEvent(event) {
     if (event.type === "agent-session-started") {
       repoState.agentStatus = "busy";
     } else if (event.type === "agent-session-ended") {
@@ -3093,26 +3441,88 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
       appendLogLine(repoState.logBuffer, createLogLine(formatted, "stdout"));
     }
     if (sendEvent && sessionId) {
-      sequence++;
+      loopState.sequence++;
       sendEvent(buildEventMessage({
-        sequence,
+        sequence: loopState.sequence,
         sessionId,
         repository: repoName,
         repoId: repoState.repository.id,
         event,
-        agentSessionId
+        agentSessionId: loopState.agentSessionId
       }));
     }
   };
+}
+function createCancelHandler(abortController) {
+  return abortController.abort.bind(abortController);
+}
+function setupFallbackTimeout(repoState, sleep, resolve, wakeUpForThisWait) {
+  sleep(FALLBACK_TIMEOUT_MS).then(function onFallbackTimeout() {
+    if (repoState.wakeUp === wakeUpForThisWait) {
+      repoState.wakeUp = undefined;
+      resolve();
+    }
+  });
+}
+async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
+  const { spawn, run: run3, fileSystem, sleep } = repoDeps;
+  const repoName = repoState.repository.name;
+  const settings = await loadSettings(repoState.path, fileSystem);
+  const logCallbacks = createLogCallbacks(repoState.logBuffer);
+  const commandDeps = {
+    arguments: [],
+    context: {
+      cwd: repoState.path,
+      stdout: logCallbacks.stdout,
+      stderr: logCallbacks.stderr
+    },
+    fileSystem,
+    globScanner: createNoOpGlobScanner(),
+    settings
+  };
+  const loopState = {
+    partialLine: "",
+    sequence: 0,
+    agentSessionId: undefined
+  };
+  const isCodex = repoState.repository.agentProvider === "codex";
+  const agentType = isCodex ? "codex" : "claude";
+  const createStdoutSink2 = () => createBufferStdoutSink(loopState, repoState.logBuffer);
+  let bufferRun;
+  if (isCodex) {
+    const codexBufferSinkDeps = {
+      ...defaultRunnerDependencies2,
+      createStdoutSink: createStdoutSink2
+    };
+    bufferRun = (prompt, options) => run2(prompt, options, codexBufferSinkDeps);
+  } else {
+    const bufferSinkDeps = {
+      ...defaultRunnerDependencies,
+      createStdoutSink: createStdoutSink2
+    };
+    bufferRun = createBufferRun(run3, bufferSinkDeps);
+  }
+  const loopDeps = {
+    spawn,
+    run: bufferRun,
+    sleep,
+    postEvent: noOpPostEvent,
+    agentType
+  };
+  const onLoopEvent = createLoopEventHandler(repoState.logBuffer);
+  const onAgentEvent = createAgentEventHandler({
+    repoState,
+    sendEvent,
+    sessionId,
+    repoName,
+    loopState
+  });
   const hooksInstalled = await manageGitHooks(commandDeps);
-  const logLine = (msg) => appendLogLine(repoState.logBuffer, createLogLine(msg, "stdout"));
-  log2(`loop started for ${repoName} at ${repoState.path}`);
+  log3(`loop started for ${repoName} at ${repoState.path}`);
   while (!repoState.stopRequested) {
-    agentSessionId = crypto.randomUUID();
+    loopState.agentSessionId = crypto.randomUUID();
     const abortController = new AbortController;
-    const cancelCurrentIteration = () => {
-      abortController.abort();
-    };
+    const cancelCurrentIteration = createCancelHandler(abortController);
     repoState.cancelCurrentIteration = cancelCurrentIteration;
     let result;
     try {
@@ -3124,7 +3534,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
       });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
-      log2(`iteration error for ${repoName}: ${msg}`);
+      log3(`iteration error for ${repoName}: ${msg}`);
       appendLogLine(repoState.logBuffer, createLogLine(`Loop error: ${msg}`, "stderr"));
       await sleep(1e4);
       continue;
@@ -3136,39 +3546,34 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
     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...");
+        log3(`${repoName}: task signal received during iteration, rechecking`);
+        appendLogLine(repoState.logBuffer, createLogLine("Task signal received during iteration, rechecking...", "stdout"));
         continue;
       }
-      log2(`${repoName}: no tasks available, waiting`);
-      logLine("Waiting for tasks...");
-      await new Promise((resolve) => {
+      log3(`${repoName}: no tasks available, waiting`);
+      appendLogLine(repoState.logBuffer, createLogLine("Waiting for tasks...", "stdout"));
+      await new Promise(function waitForTasks(resolve) {
         const wakeUpForThisWait = createWakeUpHandler(repoState, resolve);
         repoState.wakeUp = wakeUpForThisWait;
-        sleep(FALLBACK_TIMEOUT_MS).then(() => {
-          if (repoState.wakeUp === wakeUpForThisWait) {
-            repoState.wakeUp = undefined;
-            resolve();
-          }
-        });
+        setupFallbackTimeout(repoState, sleep, resolve, wakeUpForThisWait);
       });
     }
   }
-  log2(`loop stopped for ${repoName}`);
+  log3(`loop stopped for ${repoName}`);
   appendLogLine(repoState.logBuffer, createLogLine(`Stopped loop for ${repoName}`, "stdout"));
 }
 
 // lib/bucket/repository.ts
-var log3 = createLogger("dust:bucket:repository");
+var log4 = createLogger("dust:bucket:repository");
 function startRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
-  log3(`starting loop for ${repoState.repository.name}`);
+  log4(`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}`);
+    log4(`loop crashed for ${repoState.repository.name}: ${message}`);
     appendLogLine(repoState.logBuffer, createLogLine(`Repository loop crashed: ${message}`, "stderr"));
   }).finally(() => {
-    log3(`loop finished for ${repoState.repository.name}`);
+    log4(`loop finished for ${repoState.repository.name}`);
     repoState.loopPromise = null;
     repoState.agentStatus = "idle";
     repoState.wakeUp = undefined;
@@ -3191,10 +3596,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`);
+    log4(`repository ${repository.name} already exists, skipping add`);
     return;
   }
-  log3(`adding repository ${repository.name}`);
+  log4(`adding repository ${repository.name}`);
   const repoPath = getRepoPath(repository.name, repoDeps.getReposDir());
   await repoDeps.fileSystem.mkdir(dirname2(repoPath), { recursive: true });
   if (repoDeps.fileSystem.exists(repoPath)) {
@@ -3234,7 +3639,7 @@ async function removeRepositoryFromManager(repoName, manager, repoDeps, context)
   if (!repoState) {
     return;
   }
-  log3(`removing repository ${repoName}`);
+  log4(`removing repository ${repoName}`);
   repoState.stopRequested = true;
   repoState.cancelCurrentIteration?.();
   repoState.wakeUp?.();
@@ -3292,13 +3697,20 @@ function parseServerMessage(data) {
       if (typeof repo.id !== "number" || typeof repo.url !== "string" || typeof repo.hasTask !== "boolean") {
         return null;
       }
-      repositories.push({
+      const item = {
         id: repo.id,
         name: repo.name,
         gitUrl: repo.gitUrl,
         url: repo.url,
         hasTask: repo.hasTask
-      });
+      };
+      if (typeof repo.gitSshUrl === "string") {
+        item.gitSshUrl = repo.gitSshUrl;
+      }
+      if (typeof repo.agentProvider === "string") {
+        item.agentProvider = repo.agentProvider;
+      }
+      repositories.push(item);
     }
     return { type: "repository-list", repositories };
   }
@@ -3739,7 +4151,7 @@ function handleKeyInput(state, key, options) {
 }
 
 // lib/cli/commands/bucket.ts
-var log4 = createLogger("dust:cli:commands:bucket");
+var log5 = 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;
@@ -3799,27 +4211,27 @@ function defaultWriteStdout(data) {
 }
 function createAuthFileSystem(dependencies) {
   return {
-    exists: (path) => {
+    exists: (path3) => {
       try {
-        dependencies.accessSync(path);
+        dependencies.accessSync(path3);
         return true;
       } catch {
         return false;
       }
     },
-    isDirectory: (path) => {
+    isDirectory: (path3) => {
       try {
-        return dependencies.statSync(path).isDirectory();
+        return dependencies.statSync(path3).isDirectory();
       } catch {
         return false;
       }
     },
-    getFileCreationTime: (path) => dependencies.statSync(path).birthtimeMs,
-    readFile: (path) => dependencies.readFile(path, "utf8"),
-    writeFile: (path, content) => dependencies.writeFile(path, content, "utf8"),
-    mkdir: (path, options) => dependencies.mkdir(path, options).then(() => {}),
-    readdir: (path) => dependencies.readdir(path),
-    chmod: (path, mode) => dependencies.chmod(path, mode),
+    getFileCreationTime: (path3) => dependencies.statSync(path3).birthtimeMs,
+    readFile: (path3) => dependencies.readFile(path3, "utf8"),
+    writeFile: (path3, content) => dependencies.writeFile(path3, content, "utf8"),
+    mkdir: (path3, options) => dependencies.mkdir(path3, options).then(() => {}),
+    readdir: (path3) => dependencies.readdir(path3),
+    chmod: (path3, mode) => dependencies.chmod(path3, mode),
     rename: (oldPath, newPath) => dependencies.rename(oldPath, newPath)
   };
 }
@@ -3835,7 +4247,7 @@ function createDefaultBucketDependencies() {
     rename: (oldPath, newPath) => import("node:fs/promises").then((mod) => mod.rename(oldPath, newPath))
   });
   return {
-    spawn: nodeSpawn4,
+    spawn: nodeSpawn5,
     createWebSocket: defaultCreateWebSocket,
     setupKeypress: defaultSetupKeypress,
     setupSignals: defaultSetupSignals,
@@ -3887,20 +4299,20 @@ function toRepositoryDependencies(bucketDeps, fileSystem) {
 }
 function ensureRepositoryLoopRunning(repoState, state, repoDeps, context, useTUI) {
   if (repoState.loopPromise || repoState.wakeUp || repoState.stopRequested) {
-    log4(`loop already running/waiting for ${repoState.repository.name}`);
+    log5(`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}`);
+  log5(`task-available signal for ${repoState.repository.name}`);
   ensureRepositoryLoopRunning(repoState, state, repoDeps, context, useTUI);
   if (repoState.wakeUp) {
-    log4(`waking loop for ${repoState.repository.name}`);
+    log5(`waking loop for ${repoState.repository.name}`);
     repoState.wakeUp();
   } else {
-    log4(`marking task pending for ${repoState.repository.name} (loop busy)`);
+    log5(`marking task pending for ${repoState.repository.name} (loop busy)`);
     repoState.taskAvailablePending = true;
   }
 }
@@ -4034,7 +4446,7 @@ function connectWebSocket(token, state, bucketDependencies, context, fileSystem,
       logMessage(state, context, useTUI, `Invalid WebSocket message format: ${event.data}`, "stderr");
       return;
     }
-    log4(`ws message: ${message.type}`);
+    log5(`ws message: ${message.type}`);
     if (message.type === "repository-list") {
       const repos = message.repositories;
       logMessage(state, context, useTUI, `Received repository list (${repos.length} repositories):`);
@@ -4084,7 +4496,7 @@ async function shutdown(state, bucketDeps, context) {
   if (state.shuttingDown)
     return;
   state.shuttingDown = true;
-  log4("shutdown initiated");
+  log5("shutdown initiated");
   context.stdout("Shutting down...");
   if (state.reconnectTimer) {
     clearTimeout(state.reconnectTimer);
@@ -4287,16 +4699,16 @@ function createDefaultUploadDependencies() {
       getHomeDir: () => homedir2(),
       fileSystem: authFileSystem
     },
-    readFileBytes: async (path) => {
-      const buffer = await Bun.file(path).arrayBuffer();
+    readFileBytes: async (path3) => {
+      const buffer = await Bun.file(path3).arrayBuffer();
       return new Uint8Array(buffer);
     },
-    getFileSize: async (path) => {
-      const file = Bun.file(path);
+    getFileSize: async (path3) => {
+      const file = Bun.file(path3);
       return file.size;
     },
-    fileExists: async (path) => {
-      const file = Bun.file(path);
+    fileExists: async (path3) => {
+      const file = Bun.file(path3);
       return file.exists();
     },
     uploadFile: async (url, token, fileBytes, contentType, fileName) => {
@@ -5090,12 +5502,12 @@ function validateNoCycles(allPrincipleRelationships) {
   }
   for (const rel of allPrincipleRelationships) {
     const visited = new Set;
-    const path = [];
+    const path3 = [];
     let current = rel.filePath;
     while (current) {
       if (visited.has(current)) {
-        const cycleStart = path.indexOf(current);
-        const cyclePath = path.slice(cycleStart).concat(current);
+        const cycleStart = path3.indexOf(current);
+        const cyclePath = path3.slice(cycleStart).concat(current);
         violations.push({
           file: rel.filePath,
           message: `Cycle detected in principle hierarchy: ${cyclePath.join(" -> ")}`
@@ -5103,7 +5515,7 @@ function validateNoCycles(allPrincipleRelationships) {
         break;
       }
       visited.add(current);
-      path.push(current);
+      path3.push(current);
       const currentRel = relationshipMap.get(current);
       if (currentRel && currentRel.parentPrinciples.length > 0) {
         current = currentRel.parentPrinciples[0];
@@ -5305,7 +5717,7 @@ async function lintMarkdown(dependencies) {
 }
 
 // lib/cli/commands/check.ts
-var log5 = createLogger("dust:cli:commands:check");
+var log6 = createLogger("dust:cli:commands:check");
 var DEFAULT_CHECK_TIMEOUT_MS = 13000;
 var MAX_OUTPUT_LINES = 500;
 var KEEP_LINES = 250;
@@ -5325,14 +5737,27 @@ function truncateOutput(output) {
   ].join(`
 `);
 }
-async function runSingleCheck(check, cwd, runner) {
+async function runSingleCheck(check, cwd, runner, emitEvent) {
   const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
-  log5(`running check ${check.name}: ${check.command}`);
+  log6(`running check ${check.name}: ${check.command}`);
+  emitEvent?.({ type: "check-started", name: check.name });
   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)`);
+  log6(`check ${check.name} ${status} (${durationMs}ms)`);
+  if (result.exitCode === 0) {
+    emitEvent?.({ type: "check-passed", name: check.name, durationMs });
+  } else {
+    const failedEvent = {
+      type: "check-failed",
+      name: check.name,
+      durationMs
+    };
+    if (result.output)
+      failedEvent.output = result.output;
+    emitEvent?.(failedEvent);
+  }
   return {
     name: check.name,
     command: check.command,
@@ -5344,25 +5769,26 @@ async function runSingleCheck(check, cwd, runner) {
     timeoutSeconds: timeoutMs / 1000
   };
 }
-async function runConfiguredChecks(checks, cwd, runner) {
-  const promises = checks.map((check) => runSingleCheck(check, cwd, runner));
+async function runConfiguredChecks(checks, cwd, runner, emitEvent) {
+  const promises = checks.map((check) => runSingleCheck(check, cwd, runner, emitEvent));
   return Promise.all(promises);
 }
-async function runConfiguredChecksSerially(checks, cwd, runner) {
+async function runConfiguredChecksSerially(checks, cwd, runner, emitEvent) {
   const results = [];
   for (const check of checks) {
-    results.push(await runSingleCheck(check, cwd, runner));
+    results.push(await runSingleCheck(check, cwd, runner, emitEvent));
   }
   return results;
 }
-async function runValidationCheck(dependencies) {
+async function runValidationCheck(dependencies, emitEvent) {
   const outputLines = [];
   const bufferedContext = {
     cwd: dependencies.context.cwd,
     stdout: (msg) => outputLines.push(msg),
     stderr: (msg) => outputLines.push(msg)
   };
-  log5("running built-in check: dust lint");
+  log6("running built-in check: dust lint");
+  emitEvent?.({ type: "check-started", name: "lint" });
   const startTime = Date.now();
   const result = await lintMarkdown({
     ...dependencies,
@@ -5371,13 +5797,26 @@ async function runValidationCheck(dependencies) {
   });
   const durationMs = Date.now() - startTime;
   const lintStatus = result.exitCode === 0 ? "passed" : "failed";
-  log5(`built-in check dust lint ${lintStatus} (${durationMs}ms)`);
+  log6(`built-in check dust lint ${lintStatus} (${durationMs}ms)`);
+  const output = outputLines.join(`
+`);
+  if (result.exitCode === 0) {
+    emitEvent?.({ type: "check-passed", name: "lint", durationMs });
+  } else {
+    const failedEvent = {
+      type: "check-failed",
+      name: "lint",
+      durationMs
+    };
+    if (output)
+      failedEvent.output = output;
+    emitEvent?.(failedEvent);
+  }
   return {
     name: "lint",
     command: "dust lint",
     exitCode: result.exitCode,
-    output: outputLines.join(`
-`),
+    output,
     isBuiltIn: true,
     durationMs,
     timedOut: false
@@ -5446,18 +5885,18 @@ async function check(dependencies, shellRunner = defaultShellRunner) {
   if (serial) {
     const results2 = [];
     if (hasDustDir) {
-      results2.push(await runValidationCheck(dependencies));
+      results2.push(await runValidationCheck(dependencies, context.emitEvent));
     }
-    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner);
+    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner, context.emitEvent);
     results2.push(...configuredResults);
     const exitCode2 = displayResults(results2, context);
     return { exitCode: exitCode2 };
   }
   const checkPromises = [];
   if (hasDustDir) {
-    checkPromises.push(runValidationCheck(dependencies));
+    checkPromises.push(runValidationCheck(dependencies, context.emitEvent));
   }
-  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner));
+  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner, context.emitEvent));
   const promiseResults = await Promise.all(checkPromises);
   const results = [];
   for (const result of promiseResults) {
@@ -5638,6 +6077,16 @@ async function init(dependencies) {
 
 // lib/cli/commands/list.ts
 import { basename as basename2 } from "node:path";
+function workflowTypeToStatus(type) {
+  switch (type) {
+    case "refine":
+      return "refining";
+    case "decompose-idea":
+      return "decomposing";
+    case "shelve":
+      return "shelving";
+  }
+}
 var VALID_TYPES = ["tasks", "ideas", "principles", "facts"];
 var SECTION_HEADERS = {
   tasks: "\uD83D\uDCCB Tasks",
@@ -5712,6 +6161,7 @@ async function list(dependencies) {
     return { exitCode: 1 };
   }
   const specificTypeRequested = commandArguments.length > 0;
+  const workflowTasks = typesToList.includes("ideas") && fileSystem.exists(dustPath) ? await findAllWorkflowTasks(fileSystem, dustPath) : null;
   for (const type of typesToList) {
     const dirPath = `${dustPath}/${type}`;
     const dirExists = fileSystem.exists(dirPath);
@@ -5726,6 +6176,13 @@ async function list(dependencies) {
         context.stdout(`No ${type} found.`);
         context.stdout("");
       }
+      if (type === "facts") {
+        context.emitEvent?.({ type: "facts-listed", facts: [] });
+      } else if (type === "ideas") {
+        context.emitEvent?.({ type: "ideas-listed", ideas: [] });
+      } else if (type === "principles") {
+        context.emitEvent?.({ type: "principles-listed", principles: [] });
+      }
       continue;
     }
     context.stdout(SECTION_HEADERS[type]);
@@ -5740,16 +6197,26 @@ async function list(dependencies) {
         context.stdout("");
       }
     }
+    const collectedItems = [];
     for (const file of mdFiles) {
       const filePath = `${dirPath}/${file}`;
       const content = await fileSystem.readFile(filePath);
       const title = extractTitle(content);
       const openingSentence = extractOpeningSentence(content);
       const relativePath = `.dust/${type}/${file}`;
+      const slug = file.replace(".md", "");
+      const displayTitle = title || slug;
+      if (type === "ideas") {
+        const workflowTask = workflowTasks?.workflowTasksByIdeaSlug.get(slug);
+        const status = workflowTask ? workflowTypeToStatus(workflowTask.type) : "draft";
+        collectedItems.push({ path: relativePath, title: displayTitle, status });
+      } else if (type === "facts" || type === "principles") {
+        collectedItems.push({ path: relativePath, title: displayTitle });
+      }
       if (title) {
         context.stdout(`${colors.bold}# ${title}${colors.reset}`);
       } else {
-        context.stdout(`${colors.bold}# ${file.replace(".md", "")}${colors.reset}`);
+        context.stdout(`${colors.bold}# ${slug}${colors.reset}`);
       }
       if (openingSentence) {
         context.stdout(`${colors.dim}${openingSentence}${colors.reset}`);
@@ -5757,130 +6224,28 @@ async function list(dependencies) {
       context.stdout(`${colors.cyan}→ ${relativePath}${colors.reset}`);
       context.stdout("");
     }
-  }
-  return { exitCode: 0 };
-}
-
-// lib/codex/spawn-codex.ts
-import { spawn as nodeSpawn5 } from "node:child_process";
-import { createInterface as nodeCreateInterface2 } from "node:readline";
-var debug2 = createLogger("dust.codex.spawn-codex");
-var defaultDependencies2 = {
-  spawn: nodeSpawn5,
-  createInterface: nodeCreateInterface2
-};
-async function* spawnCodex(prompt, options = {}, dependencies = defaultDependencies2) {
-  const { cwd, env, signal } = options;
-  const codexArguments = ["exec", prompt, "--json", "--yolo"];
-  if (cwd) {
-    codexArguments.push("--cd", cwd);
-  }
-  const proc = dependencies.spawn("codex", codexArguments, {
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, ...env }
-  });
-  if (!proc.stdout) {
-    throw new Error("Failed to get stdout from codex process");
-  }
-  let stderrOutput = "";
-  proc.stderr?.on("data", (data) => {
-    stderrOutput += data.toString();
-  });
-  const closePromise = new Promise((resolve3, reject) => {
-    proc.on("close", (code) => {
-      if (code === 0 || code === null)
-        resolve3();
-      else {
-        const errMsg = stderrOutput.trim() ? `codex exited with code ${code}: ${stderrOutput.trim()}` : `codex exited with code ${code}`;
-        reject(new Error(errMsg));
-      }
-    });
-    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 {
-        debug2("Skipping malformed JSON line: %s", line.slice(0, 200));
-      }
-    }
-    await closePromise;
-  } finally {
-    signal?.removeEventListener("abort", abortHandler);
-    rl.close?.();
-  }
-}
-
-// lib/codex/event-parser.ts
-function* parseCodexRawEvent(raw) {
-  if (raw.type !== "item.completed")
-    return;
-  const item = raw.item;
-  if (!item)
-    return;
-  if (item.type === "agent_message" && typeof item.text === "string") {
-    yield { type: "text_delta", text: `${item.text}
-` };
-  } else if (item.type === "command_execution" && typeof item.command === "string") {
-    yield {
-      type: "tool_use",
-      id: typeof item.id === "string" ? item.id : "",
-      name: "command_execution",
-      input: { command: item.command }
-    };
-    if (typeof item.aggregated_output === "string") {
-      yield {
-        type: "tool_result",
-        toolUseId: typeof item.id === "string" ? item.id : "",
-        content: item.aggregated_output || `(exit code: ${item.exit_code ?? "unknown"})`
-      };
-    }
-  }
-}
-
-// lib/codex/streamer.ts
-async function streamCodexEvents(events, sink, onRawEvent) {
-  let hadTextOutput = false;
-  for await (const raw of events) {
-    onRawEvent?.(raw);
-    for (const event of parseCodexRawEvent(raw)) {
-      processEvent(event, sink, { hadTextOutput });
-      if (event.type === "text_delta") {
-        hadTextOutput = true;
-      } else if (event.type === "tool_use") {
-        hadTextOutput = false;
-      }
+    if (type === "facts") {
+      context.emitEvent?.({
+        type: "facts-listed",
+        facts: collectedItems.map((i) => ({ path: i.path, title: i.title }))
+      });
+    } else if (type === "ideas") {
+      context.emitEvent?.({
+        type: "ideas-listed",
+        ideas: collectedItems.map((i) => ({
+          path: i.path,
+          title: i.title,
+          status: i.status ?? "draft"
+        }))
+      });
+    } else if (type === "principles") {
+      context.emitEvent?.({
+        type: "principles-listed",
+        principles: collectedItems.map((i) => ({ path: i.path, title: i.title }))
+      });
     }
   }
-}
-
-// lib/codex/run.ts
-var defaultRunnerDependencies2 = {
-  spawnCodex,
-  createStdoutSink,
-  streamCodexEvents
-};
-async function run2(prompt, options = {}, dependencies = defaultRunnerDependencies2) {
-  const isRunOptions = (opt) => ("spawnOptions" in opt) || ("onRawEvent" in opt);
-  const spawnOptions = isRunOptions(options) ? options.spawnOptions ?? {} : options;
-  const onRawEvent = isRunOptions(options) ? options.onRawEvent : undefined;
-  const events = dependencies.spawnCodex(prompt, spawnOptions);
-  const sink = dependencies.createStdoutSink();
-  await dependencies.streamCodexEvents(events, sink, onRawEvent);
+  return { exitCode: 0 };
 }
 
 // lib/cli/commands/loop-codex.ts
@@ -6137,8 +6502,8 @@ function parseGitDiffNameStatus(output) {
     const parts = line.split("\t");
     if (parts.length >= 2) {
       const statusChar = parts[0].charAt(0);
-      const path = parts.length > 2 ? parts[2] : parts[1];
-      changes.push({ status: statusChar, path });
+      const path3 = parts.length > 2 ? parts[2] : parts[1];
+      changes.push({ status: statusChar, path: path3 });
     }
   }
   return changes;
@@ -6199,12 +6564,12 @@ async function getUncommittedFiles(cwd, gitRunner) {
 `).filter((line) => line.length > 0);
   for (const line of lines) {
     if (line.length > 3) {
-      const path = line.substring(3);
-      const arrowIndex = path.indexOf(" -> ");
+      const path3 = line.substring(3);
+      const arrowIndex = path3.indexOf(" -> ");
       if (arrowIndex !== -1) {
-        files.push(path.substring(arrowIndex + 4));
+        files.push(path3.substring(arrowIndex + 4));
       } else {
-        files.push(path);
+        files.push(path3);
       }
     }
   }
@@ -6355,24 +6720,24 @@ async function main(options) {
 function createFileSystem(primitives) {
   return {
     exists: primitives.existsSync,
-    isDirectory: (path) => {
+    isDirectory: (path3) => {
       try {
-        return primitives.statSync(path).isDirectory();
+        return primitives.statSync(path3).isDirectory();
       } catch {
         return false;
       }
     },
-    readFile: (path) => primitives.readFile(path, "utf-8"),
-    writeFile: (path, content, options) => primitives.writeFile(path, content, {
+    readFile: (path3) => primitives.readFile(path3, "utf-8"),
+    writeFile: (path3, content, options) => primitives.writeFile(path3, content, {
       encoding: "utf-8",
       flag: options?.flag
     }),
-    mkdir: async (path, options) => {
-      await primitives.mkdir(path, options);
+    mkdir: async (path3, options) => {
+      await primitives.mkdir(path3, options);
     },
-    getFileCreationTime: (path) => primitives.statSync(path).birthtimeMs,
-    readdir: (path) => primitives.readdir(path),
-    chmod: (path, mode) => primitives.chmod(path, mode),
+    getFileCreationTime: (path3) => primitives.statSync(path3).birthtimeMs,
+    readdir: (path3) => primitives.readdir(path3),
+    chmod: (path3, mode) => primitives.chmod(path3, mode),
     rename: (oldPath, newPath) => primitives.rename(oldPath, newPath)
   };
 }
@@ -6396,7 +6761,8 @@ async function wireEntry(fsPrimitives, processPrimitives, consolePrimitives) {
       cwd: processPrimitives.cwd(),
       stdout: consolePrimitives.log,
       stdoutInline: consolePrimitives.write,
-      stderr: consolePrimitives.error
+      stderr: consolePrimitives.error,
+      emitEvent: consolePrimitives.emitEvent
     },
     fileSystem,
     glob,
@@ -6406,7 +6772,12 @@ async function wireEntry(fsPrimitives, processPrimitives, consolePrimitives) {
 }
 
 // lib/cli/run.ts
-await wireEntry({ existsSync, statSync: statSync3, readFile: readFile3, writeFile: writeFile3, mkdir: mkdir3, readdir: readdir3, chmod: chmod3, rename }, {
+var eventsFd = process.env.DUST_EVENTS_FD ? Number.parseInt(process.env.DUST_EVENTS_FD, 10) : undefined;
+var emitEvent = eventsFd !== undefined && !Number.isNaN(eventsFd) ? createEventEmitter((message) => {
+  writeSync(eventsFd, `${JSON.stringify(message)}
+`);
+}) : undefined;
+await wireEntry({ existsSync: existsSync2, statSync: statSync3, readFile: readFile3, writeFile: writeFile3, mkdir: mkdir3, readdir: readdir3, chmod: chmod3, rename }, {
   argv: process.argv,
   cwd: () => process.cwd(),
   exit: (code) => {
@@ -6417,5 +6788,6 @@ await wireEntry({ existsSync, statSync: statSync3, readFile: readFile3, writeFil
   write: (message) => {
     process.stdout.write(message);
   },
-  error: console.error
+  error: console.error,
+  emitEvent
 });