@joshski/dust 0.1.33 → 0.1.35

package/dist/dust.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 // lib/cli/run.ts
 import { existsSync } from "node:fs";
-import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { chmod as chmod2, mkdir as mkdir2, readdir as readdir2, readFile as readFile2, writeFile as writeFile2 } from "node:fs/promises";
 
 // lib/config/settings.ts
 import { join } from "node:path";
 var DEFAULT_SETTINGS = {
-  dustCommand: "npx dust"
+  dustCommand: "npx dust",
+  installCommand: "npm install"
 };
 function detectDustCommand(cwd, fileSystem) {
   if (fileSystem.exists(join(cwd, "bun.lockb"))) {
@@ -23,6 +24,21 @@ function detectDustCommand(cwd, fileSystem) {
   }
   return "npx dust";
 }
+function detectInstallCommand(cwd, fileSystem) {
+  if (fileSystem.exists(join(cwd, "bun.lockb"))) {
+    return "bun install";
+  }
+  if (fileSystem.exists(join(cwd, "pnpm-lock.yaml"))) {
+    return "pnpm install";
+  }
+  if (fileSystem.exists(join(cwd, "package-lock.json"))) {
+    return "npm install";
+  }
+  if (process.env.BUN_INSTALL) {
+    return "bun install";
+  }
+  return "npm install";
+}
 function detectTestCommand(cwd, fileSystem) {
   if (fileSystem.exists(join(cwd, "bun.lockb")) || fileSystem.exists(join(cwd, "bun.lock"))) {
     return "bun test";
@@ -54,7 +70,8 @@ async function loadSettings(cwd, fileSystem) {
   const settingsPath = join(cwd, ".dust", "config", "settings.json");
   if (!fileSystem.exists(settingsPath)) {
     const result = {
-      dustCommand: detectDustCommand(cwd, fileSystem)
+      dustCommand: detectDustCommand(cwd, fileSystem),
+      installCommand: detectInstallCommand(cwd, fileSystem)
     };
     if (process.env.DUST_EVENTS_URL) {
       result.eventsUrl = process.env.DUST_EVENTS_URL;
@@ -74,13 +91,17 @@ async function loadSettings(cwd, fileSystem) {
     if (!parsed.dustCommand) {
       result.dustCommand = detectDustCommand(cwd, fileSystem);
     }
+    if (!parsed.installCommand) {
+      result.installCommand = detectInstallCommand(cwd, fileSystem);
+    }
     if (process.env.DUST_EVENTS_URL) {
       result.eventsUrl = process.env.DUST_EVENTS_URL;
     }
     return result;
   } catch {
     const result = {
-      dustCommand: detectDustCommand(cwd, fileSystem)
+      dustCommand: detectDustCommand(cwd, fileSystem),
+      installCommand: detectInstallCommand(cwd, fileSystem)
     };
     if (process.env.DUST_EVENTS_URL) {
       result.eventsUrl = process.env.DUST_EVENTS_URL;
@@ -123,7 +144,7 @@ import { join as join4 } from "node:path";
 // lib/agents/detection.ts
 function detectAgent(env = process.env) {
   if (env.CLAUDECODE) {
-    if (env.CLAUDE_CODE_ENTRYPOINT === "remote") {
+    if (env.CLAUDE_CODE_REMOTE) {
       return { type: "claude-code-web", name: "Claude Code Web" };
     }
     return { type: "claude-code", name: "Claude Code" };
@@ -323,62 +344,10 @@ async function agent(dependencies) {
   return { exitCode: 0 };
 }
 
-// lib/cli/process-runner.ts
-import { spawn } from "node:child_process";
-function createShellRunner(spawnFn) {
-  return {
-    run: (command, cwd, timeoutMs) => runBufferedProcess(spawnFn, command, [], cwd, true, timeoutMs)
-  };
-}
-var defaultShellRunner = createShellRunner(spawn);
-function createGitRunner(spawnFn) {
-  return {
-    run: (gitArguments, cwd) => runBufferedProcess(spawnFn, "git", gitArguments, cwd, false)
-  };
-}
-var defaultGitRunner = createGitRunner(spawn);
-function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, timeoutMs) {
-  return new Promise((resolve) => {
-    const proc = spawnFn(command, commandArguments, { cwd, shell });
-    const chunks = [];
-    let resolved = false;
-    let timer;
-    if (timeoutMs !== undefined) {
-      timer = setTimeout(() => {
-        resolved = true;
-        proc.kill();
-        resolve({
-          exitCode: 1,
-          output: chunks.join(""),
-          timedOut: true
-        });
-      }, timeoutMs);
-    }
-    proc.stdout?.on("data", (data) => {
-      chunks.push(data.toString());
-    });
-    proc.stderr?.on("data", (data) => {
-      chunks.push(data.toString());
-    });
-    proc.on("close", (code) => {
-      if (resolved)
-        return;
-      if (timer !== undefined)
-        clearTimeout(timer);
-      resolve({ exitCode: code ?? 1, output: chunks.join("") });
-    });
-    proc.on("error", (error) => {
-      if (resolved)
-        return;
-      if (timer !== undefined)
-        clearTimeout(timer);
-      resolve({ exitCode: 1, output: error.message });
-    });
-  });
-}
-
-// lib/cli/commands/lint-markdown.ts
-import { dirname as dirname2, resolve } from "node:path";
+// lib/cli/commands/audit.ts
+import { readdirSync, readFileSync as readFileSync2 } from "node:fs";
+import { basename, dirname as dirname2, join as join5 } from "node:path";
+import { fileURLToPath as fileURLToPath2 } from "node:url";
 
 // lib/markdown/markdown-utilities.ts
 function extractTitle(content) {
@@ -432,1759 +401,3109 @@ function extractOpeningSentence(content) {
   return sentenceMatch[1];
 }
 
-// lib/workflow-tasks.ts
-var IDEA_TRANSITION_PREFIXES = [
-  "Refine Idea: ",
-  "Decompose Idea: ",
-  "Shelve Idea: "
-];
-function titleToFilename(title) {
-  return `${title.toLowerCase().replace(/\./g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}.md`;
+// lib/cli/colors.ts
+var ANSI_COLORS = {
+  reset: "\x1B[0m",
+  bold: "\x1B[1m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m"
+};
+var NO_COLORS = {
+  reset: "",
+  bold: "",
+  dim: "",
+  cyan: "",
+  green: "",
+  yellow: ""
+};
+function shouldDisableColors() {
+  if (process.env.NO_COLOR !== undefined) {
+    return true;
+  }
+  if (process.env.TERM === "dumb") {
+    return true;
+  }
+  if (!process.stdout.isTTY) {
+    return true;
+  }
+  return false;
+}
+function getColors() {
+  return shouldDisableColors() ? NO_COLORS : ANSI_COLORS;
 }
 
-// lib/cli/commands/lint-markdown.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 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`
-    };
+// lib/cli/commands/audit.ts
+var __dirname3 = dirname2(fileURLToPath2(import.meta.url));
+var stockAuditsDir = join5(__dirname3, "../../templates/audits");
+function loadStockAudits() {
+  const files = readdirSync(stockAuditsDir).filter((f) => f.endsWith(".md")).sort();
+  return files.map((file) => {
+    const template = readFileSync2(join5(stockAuditsDir, file), "utf-8");
+    const name = basename(file, ".md");
+    const description = extractOpeningSentence(template);
+    return { name, description, template };
+  });
+}
+function transformAuditContent(content) {
+  const titleMatch = content.match(/^#\s+(.+)$/m);
+  if (!titleMatch) {
+    return content;
   }
-  return null;
+  const originalTitle = titleMatch[1];
+  return content.replace(/^#\s+.+$/m, `# Audit: ${originalTitle}`);
 }
-function validateTitleFilenameMatch(filePath, content) {
-  const title = extractTitle(content);
-  if (!title) {
-    return null;
+async function addAudit(auditName, dependencies) {
+  const { context, fileSystem, settings } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  const userAuditsPath = `${dustPath}/config/audits`;
+  const tasksPath = `${dustPath}/tasks`;
+  const taskFilePath = `${tasksPath}/audit-${auditName}.md`;
+  const relativeTaskPath = `.dust/tasks/audit-${auditName}.md`;
+  if (fileSystem.exists(taskFilePath)) {
+    context.stderr(`Error: Audit task already exists at ${relativeTaskPath}`);
+    return { exitCode: 1 };
   }
-  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}")`
-    };
+  const userAuditPath = `${userAuditsPath}/${auditName}.md`;
+  if (fileSystem.exists(userAuditPath)) {
+    const content = await fileSystem.readFile(userAuditPath);
+    const transformedContent = transformAuditContent(content);
+    await fileSystem.mkdir(tasksPath, { recursive: true });
+    await fileSystem.writeFile(taskFilePath, transformedContent);
+    context.stdout(`→ ${relativeTaskPath}`);
+    return { exitCode: 0 };
   }
-  return null;
-}
-function validateOpeningSentence(filePath, content) {
-  const openingSentence = extractOpeningSentence(content);
-  if (!openingSentence) {
-    return {
-      file: filePath,
-      message: "Missing or malformed opening sentence after H1 heading"
-    };
+  const stockAudit = loadStockAudits().find((a) => a.name === auditName);
+  if (stockAudit) {
+    const transformedContent = transformAuditContent(stockAudit.template);
+    await fileSystem.mkdir(tasksPath, { recursive: true });
+    await fileSystem.writeFile(taskFilePath, transformedContent);
+    context.stdout(`→ ${relativeTaskPath}`);
+    return { exitCode: 0 };
   }
-  return null;
+  context.stderr(`Error: Audit '${auditName}' not found`);
+  context.stderr(`Run '${settings.dustCommand} audit' to see available audits`);
+  return { exitCode: 1 };
 }
-function validateOpeningSentenceLength(filePath, content) {
-  const openingSentence = extractOpeningSentence(content);
-  if (!openingSentence) {
-    return null;
+async function listAudits(dependencies) {
+  const { context, fileSystem } = dependencies;
+  const colors = getColors();
+  const dustPath = `${context.cwd}/.dust`;
+  const userAuditsPath = `${dustPath}/config/audits`;
+  const audits = new Map;
+  for (const stockAudit of loadStockAudits()) {
+    audits.set(stockAudit.name, {
+      name: stockAudit.name,
+      description: stockAudit.description,
+      source: "stock"
+    });
   }
-  if (openingSentence.length > MAX_OPENING_SENTENCE_LENGTH) {
-    return {
-      file: filePath,
-      message: `Opening sentence is ${openingSentence.length} characters (max ${MAX_OPENING_SENTENCE_LENGTH}). Split into multiple sentences; only the first sentence is checked.`
-    };
+  if (fileSystem.exists(userAuditsPath)) {
+    const files = await fileSystem.readdir(userAuditsPath);
+    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+    for (const file of mdFiles) {
+      const name = basename(file, ".md");
+      const filePath = `${userAuditsPath}/${file}`;
+      const content = await fileSystem.readFile(filePath);
+      const title = extractTitle(content);
+      const openingSentence = extractOpeningSentence(content);
+      const relativePath = `.dust/config/audits/${file}`;
+      audits.set(name, {
+        name: title || name,
+        description: openingSentence || "",
+        source: relativePath
+      });
+    }
   }
-  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) {
-    return null;
+  context.stdout("\uD83D\uDD0D Audits");
+  context.stdout("");
+  context.stdout("Audits are canned tasks that help maintain project health.");
+  context.stdout("");
+  for (const auditInfo of audits.values()) {
+    context.stdout(`${colors.bold}# ${auditInfo.name}${colors.reset}`);
+    if (auditInfo.description) {
+      context.stdout(`${colors.dim}${auditInfo.description}${colors.reset}`);
+    }
+    context.stdout(`${colors.cyan}→ ${auditInfo.source}${colors.reset}`);
+    context.stdout("");
   }
-  const firstWord = openingSentence.split(/\s/)[0].replace(/[^a-zA-Z]/g, "");
-  const lower = firstWord.toLowerCase();
-  if (NON_IMPERATIVE_STARTERS.has(lower) || lower.endsWith("ing")) {
-    const preview = openingSentence.length > 40 ? `${openingSentence.slice(0, 40)}...` : openingSentence;
-    return {
-      file: filePath,
-      message: `Opening sentence should use imperative form (e.g., "Add X" not "This adds X"). Found: "${preview}"`
-    };
+  return { exitCode: 0 };
+}
+async function audit(dependencies) {
+  const auditName = dependencies.arguments[0];
+  if (auditName) {
+    return addAudit(auditName, dependencies);
   }
-  return null;
+  return listAudits(dependencies);
 }
-function validateTaskHeadings(filePath, content) {
-  const violations = [];
-  for (const heading of REQUIRED_HEADINGS) {
-    if (!content.includes(heading)) {
-      violations.push({
-        file: filePath,
-        message: `Missing required heading: "${heading}"`
-      });
-    }
+
+// lib/cli/commands/bucket.ts
+import { spawn as nodeSpawn3 } from "node:child_process";
+import { accessSync } from "node:fs";
+import { chmod, mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { createServer as httpCreateServer } from "node:http";
+import { homedir, tmpdir } from "node:os";
+
+// lib/bucket/auth.ts
+import { join as join6 } from "node:path";
+var CREDENTIALS_DIR = ".dust";
+var CREDENTIALS_FILE = "credentials.json";
+var AUTH_TIMEOUT_MS = 120000;
+var DEFAULT_DUSTBUCKET_HOST = "https://dustbucket.com";
+function getDustbucketHost() {
+  return process.env.DUST_BUCKET_HOST || DEFAULT_DUSTBUCKET_HOST;
+}
+function credentialsPath(homeDir) {
+  return join6(homeDir, CREDENTIALS_DIR, CREDENTIALS_FILE);
+}
+async function loadStoredToken(fileSystem, homeDir) {
+  const path = credentialsPath(homeDir);
+  try {
+    const content = await fileSystem.readFile(path);
+    const data = JSON.parse(content);
+    return typeof data.token === "string" ? data.token : null;
+  } catch {
+    return null;
   }
-  return violations;
 }
-function validateLinks(filePath, content, fileSystem) {
-  const violations = [];
-  const lines = content.split(`
-`);
-  const fileDir = dirname2(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
-          });
+async function storeToken(fileSystem, homeDir, token) {
+  const dirPath = join6(homeDir, CREDENTIALS_DIR);
+  await fileSystem.mkdir(dirPath, { recursive: true });
+  await fileSystem.writeFile(credentialsPath(homeDir), JSON.stringify({ token }));
+}
+async function clearToken(fileSystem, homeDir) {
+  const path = credentialsPath(homeDir);
+  try {
+    await fileSystem.writeFile(path, "{}");
+  } catch {}
+}
+async function authenticate(authDeps) {
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    let serverHandle = null;
+    const cleanup = () => {
+      if (timer) {
+        clearTimeout(timer);
+        timer = null;
+      }
+      if (serverHandle) {
+        serverHandle.stop();
+        serverHandle = null;
+      }
+    };
+    const handler = (request) => {
+      const url = new URL(request.url);
+      if (url.pathname === "/callback") {
+        const token = url.searchParams.get("token");
+        if (token) {
+          cleanup();
+          resolve(token);
+          return new Response("<html><body><p>Authentication successful! You can close this tab.</p></body></html>", { headers: { "Content-Type": "text/html" } });
         }
+        return new Response("Missing token", { status: 400 });
       }
-      match = linkPattern.exec(line);
+      return new Response("Not found", { status: 404 });
+    };
+    try {
+      const server = authDeps.createServer(handler);
+      serverHandle = server;
+      const dustbucketUrl = getDustbucketHost();
+      const authUrl = `${dustbucketUrl}/auth/cli?port=${server.port}`;
+      authDeps.openBrowser(authUrl);
+      timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("Authentication timed out"));
+      }, authDeps.authTimeoutMs ?? AUTH_TIMEOUT_MS);
+    } catch (error) {
+      cleanup();
+      reject(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())) {
-      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;
+
+// lib/bucket/events.ts
+var WS_OPEN = 1;
+function formatBucketEvent(event) {
+  switch (event.type) {
+    case "bucket.connected":
+      return "Connected to dustbucket";
+    case "bucket.disconnected":
+      return `Disconnected (code: ${event.code}, reason: ${event.reason || "none"})`;
+    case "bucket.repository_added":
+      return `Added repository: ${event.repository}`;
+    case "bucket.repository_removed":
+      return `Removed repository: ${event.repository}`;
+    case "bucket.error":
+      return event.repository ? `Error for ${event.repository}: ${event.error}` : `Error: ${event.error}`;
+  }
+}
+function createEventMessageSender(getWebSocket) {
+  return (msg) => {
+    const ws = getWebSocket();
+    if (ws && ws.readyState === WS_OPEN) {
+      try {
+        ws.send(JSON.stringify(msg));
+      } catch {}
     }
+  };
+}
+
+// lib/bucket/log-buffer.ts
+var MAX_LINES = 5000;
+var TRIM_TO_LINES = 3000;
+function createLogBuffer(maxLines = MAX_LINES, trimToLines = TRIM_TO_LINES) {
+  return {
+    lines: [],
+    maxLines,
+    trimToLines
+  };
+}
+function appendLogLine(buffer, line) {
+  buffer.lines.push(line);
+  if (buffer.lines.length > buffer.maxLines) {
+    buffer.lines = buffer.lines.slice(-buffer.trimToLines);
   }
-  if (inOpenQuestions && currentQuestionLine !== null) {
-    violations.push({
-      file: filePath,
-      message: "Question has no options listed beneath it",
-      line: currentQuestionLine
-    });
+}
+function createLogLine(text, stream, timestamp = Date.now()) {
+  return { text, stream, timestamp };
+}
+function getLogLines(buffer) {
+  return buffer.lines;
+}
+
+// lib/bucket/repository.ts
+import { join as join7 } from "node:path";
+
+// lib/agent-events.ts
+function mapToAgentEvent(event) {
+  switch (event.type) {
+    case "claude.started":
+      return { type: "agent-session-started" };
+    case "claude.ended":
+      return {
+        type: "agent-session-ended",
+        success: event.success,
+        error: event.error
+      };
+    case "claude.raw_event":
+      if (typeof event.rawEvent.type === "string" && event.rawEvent.type === "stream_event") {
+        return { type: "agent-session-activity" };
+      }
+      return { type: "claude-event", rawEvent: event.rawEvent };
+    default:
+      return null;
   }
-  return violations;
 }
-var SEMANTIC_RULES = [
-  {
-    section: "## Goals",
-    requiredPath: "/.dust/goals/",
-    description: "goal"
-  },
-  {
-    section: "## Blocked By",
-    requiredPath: "/.dust/tasks/",
-    description: "task"
+
+// lib/claude/spawn-claude-code.ts
+import { spawn as nodeSpawn } from "node:child_process";
+import { createInterface as nodeCreateInterface } from "node:readline";
+var defaultDependencies = {
+  spawn: nodeSpawn,
+  createInterface: nodeCreateInterface
+};
+async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDependencies) {
+  const {
+    cwd,
+    allowedTools,
+    maxTurns,
+    model,
+    systemPrompt,
+    sessionId,
+    dangerouslySkipPermissions,
+    env
+  } = options;
+  const claudeArguments = [
+    "-p",
+    prompt,
+    "--output-format",
+    "stream-json",
+    "--verbose",
+    "--include-partial-messages"
+  ];
+  if (allowedTools?.length) {
+    claudeArguments.push("--allowedTools", ...allowedTools);
   }
-];
-function validateSemanticLinks(filePath, content) {
-  const violations = [];
-  const lines = content.split(`
-`);
-  const fileDir = dirname2(filePath);
-  let currentSection = null;
-  for (let i = 0;i < lines.length; i++) {
-    const line = lines[i];
-    if (line.startsWith("## ")) {
-      currentSection = line;
-      continue;
-    }
-    const rule = SEMANTIC_RULES.find((r) => r.section === currentSection);
-    if (!rule)
+  if (maxTurns) {
+    claudeArguments.push("--max-turns", String(maxTurns));
+  }
+  if (model) {
+    claudeArguments.push("--model", model);
+  }
+  if (systemPrompt) {
+    claudeArguments.push("--system-prompt", systemPrompt);
+  }
+  if (sessionId) {
+    claudeArguments.push("--session-id", sessionId);
+  }
+  if (dangerouslySkipPermissions) {
+    claudeArguments.push("--dangerously-skip-permissions");
+  }
+  const proc = dependencies.spawn("claude", claudeArguments, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    env: { ...process.env, ...env }
+  });
+  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;
-    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;
+    try {
+      yield JSON.parse(line);
+    } catch {}
+  }
+  let stderrOutput = "";
+  proc.stderr?.on("data", (data) => {
+    stderrOutput += data.toString();
+  });
+  await new Promise((resolve, reject) => {
+    proc.on("close", (code) => {
+      if (code === 0 || code === null)
+        resolve();
+      else {
+        const errMsg = stderrOutput.trim() ? `claude exited with code ${code}: ${stderrOutput.trim()}` : `claude exited with code ${code}`;
+        reject(new Error(errMsg));
       }
-      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;
+    });
+    proc.on("error", reject);
+  });
+}
+
+// lib/claude/event-parser.ts
+function* parseRawEvent(raw) {
+  if (raw.type === "stream_event") {
+    const event = raw.event;
+    if (event?.delta?.type === "text_delta" && event.delta.text) {
+      yield { type: "text_delta", text: event.delta.text };
+    }
+  } else if (raw.type === "assistant") {
+    const msg = raw;
+    const content = msg.message?.content ?? [];
+    yield { type: "assistant_message", content };
+    for (const block of content) {
+      if (block.type === "tool_use" && block.id && block.name && block.input) {
+        yield {
+          type: "tool_use",
+          id: block.id,
+          name: block.name,
+          input: block.input
+        };
       }
-      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
-        });
+    }
+  } else if (raw.type === "user") {
+    const msg = raw;
+    for (const block of msg.message?.content ?? []) {
+      if (block.type === "tool_result" && block.tool_use_id) {
+        yield {
+          type: "tool_result",
+          toolUseId: block.tool_use_id,
+          content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+        };
       }
-      match = linkPattern.exec(line);
     }
+  } else if (raw.type === "result") {
+    const r = raw;
+    yield {
+      type: "result",
+      subtype: r.subtype ?? "success",
+      result: r.result,
+      error: r.error,
+      cost_usd: r.total_cost_usd ?? r.cost_usd ?? 0,
+      duration_ms: r.duration_ms ?? 0,
+      num_turns: r.num_turns ?? 0,
+      session_id: r.session_id ?? ""
+    };
   }
-  return violations;
 }
-function validateIdeaTransitionTitle(filePath, content, ideasPath, fileSystem) {
-  const title = extractTitle(content);
-  if (!title) {
-    return null;
+
+// lib/claude/tool-formatters.ts
+var DIVIDER = "────────────────────────────────";
+function formatWrite(input) {
+  const filePath = input.file_path;
+  const content = input.content;
+  const others = getUnrecognizedArgs(input, ["file_path", "content"]);
+  const lines = [];
+  lines.push(`\uD83D\uDD27 Write: ${filePath ?? "(unknown)"}`);
+  lines.push(DIVIDER);
+  if (content !== undefined) {
+    for (const line of content.split(`
+`)) {
+      lines.push(line);
+    }
   }
-  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/)`
-        };
+  lines.push(DIVIDER);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatEdit(input) {
+  const filePath = input.file_path;
+  const oldString = input.old_string;
+  const newString = input.new_string;
+  const others = getUnrecognizedArgs(input, [
+    "file_path",
+    "old_string",
+    "new_string",
+    "replace_all"
+  ]);
+  const lines = [];
+  lines.push(`\uD83D\uDD27 Edit: ${filePath ?? "(unknown)"}`);
+  lines.push("Replace:");
+  lines.push(DIVIDER);
+  if (oldString !== undefined) {
+    for (const line of oldString.split(`
+`)) {
+      lines.push(line);
+    }
+  }
+  lines.push(DIVIDER);
+  lines.push("With:");
+  lines.push(DIVIDER);
+  if (newString !== undefined) {
+    for (const line of newString.split(`
+`)) {
+      lines.push(line);
+    }
+  }
+  lines.push(DIVIDER);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatRead(input) {
+  const filePath = input.file_path;
+  const offset = input.offset;
+  const limit = input.limit;
+  const others = getUnrecognizedArgs(input, ["file_path", "offset", "limit"]);
+  const lines = [];
+  let lineRange = "";
+  if (offset !== undefined || limit !== undefined) {
+    const start = offset ?? 1;
+    const end = limit !== undefined ? start + limit - 1 : undefined;
+    lineRange = end !== undefined ? ` (lines ${start}-${end})` : ` (from line ${start})`;
+  }
+  lines.push(`\uD83D\uDD27 Read: ${filePath ?? "(unknown)"}${lineRange}`);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatBash(input) {
+  const command = input.command;
+  const description = input.description;
+  const others = getUnrecognizedArgs(input, [
+    "command",
+    "description",
+    "timeout",
+    "run_in_background",
+    "dangerouslyDisableSandbox",
+    "_simulatedSedEdit"
+  ]);
+  const lines = [];
+  const header = description ?? "Run command";
+  lines.push(`\uD83D\uDD27 Bash: ${header}`);
+  if (command !== undefined) {
+    lines.push(`$ ${command}`);
+  }
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatTodoWrite(input) {
+  const todos = input.todos;
+  const others = getUnrecognizedArgs(input, ["todos"]);
+  const lines = [];
+  const count = todos?.length ?? 0;
+  lines.push(`\uD83D\uDD27 TodoWrite: ${count} item${count === 1 ? "" : "s"}`);
+  if (todos) {
+    for (const todo of todos) {
+      const icon = todo.status === "completed" ? "☑" : "☐";
+      lines.push(`${icon} ${todo.content}`);
+    }
+  }
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatGrep(input) {
+  const pattern = input.pattern;
+  const path = input.path;
+  const glob = input.glob;
+  const type = input.type;
+  const others = getUnrecognizedArgs(input, [
+    "pattern",
+    "path",
+    "glob",
+    "type",
+    "output_mode",
+    "context",
+    "-A",
+    "-B",
+    "-C",
+    "-i",
+    "-n",
+    "head_limit",
+    "offset",
+    "multiline"
+  ]);
+  const lines = [];
+  const location = path ?? ".";
+  let filter = "";
+  if (glob) {
+    filter = ` (${glob})`;
+  } else if (type) {
+    filter = ` (type: ${type})`;
+  }
+  lines.push(`\uD83D\uDD27 Grep: "${pattern ?? ""}" in ${location}${filter}`);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatGlob(input) {
+  const pattern = input.pattern;
+  const path = input.path;
+  const others = getUnrecognizedArgs(input, ["pattern", "path"]);
+  const lines = [];
+  const location = path ?? ".";
+  lines.push(`\uD83D\uDD27 Glob: ${pattern ?? ""} in ${location}`);
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatTask(input) {
+  const description = input.description;
+  const subagentType = input.subagent_type;
+  const prompt = input.prompt;
+  const others = getUnrecognizedArgs(input, [
+    "description",
+    "subagent_type",
+    "prompt",
+    "model",
+    "max_turns",
+    "resume",
+    "run_in_background"
+  ]);
+  const lines = [];
+  const header = description ?? subagentType ?? "task";
+  lines.push(`\uD83D\uDD27 Task: ${header}`);
+  if (prompt !== undefined) {
+    const truncated = prompt.length > 100 ? `${prompt.slice(0, 100)}...` : prompt;
+    lines.push(`"${truncated}"`);
+  }
+  appendOtherArgs(lines, others);
+  return lines;
+}
+function formatFallback(name, input) {
+  const lines = [];
+  lines.push(`\uD83D\uDD27 Tool: ${name}`);
+  lines.push(`Input: ${JSON.stringify(input, null, 2)}`);
+  return lines;
+}
+var formatters = {
+  Write: formatWrite,
+  Edit: formatEdit,
+  Read: formatRead,
+  Bash: formatBash,
+  TodoWrite: formatTodoWrite,
+  Grep: formatGrep,
+  Glob: formatGlob,
+  Task: formatTask
+};
+function formatToolUse(name, input) {
+  const formatter = formatters[name];
+  if (formatter) {
+    return formatter(input);
+  }
+  return formatFallback(name, input);
+}
+function getUnrecognizedArgs(input, knownKeys) {
+  const others = {};
+  for (const key of Object.keys(input)) {
+    if (!knownKeys.includes(key)) {
+      others[key] = input[key];
+    }
+  }
+  return others;
+}
+function appendOtherArgs(lines, others) {
+  if (Object.keys(others).length > 0) {
+    lines.push("");
+    lines.push(`(Other arguments: ${JSON.stringify(others)})`);
+  }
+}
+
+// lib/claude/streamer.ts
+var DIVIDER2 = "────────────────────────────────";
+async function streamEvents(events, sink, onRawEvent) {
+  let hadTextOutput = false;
+  for await (const raw of events) {
+    onRawEvent?.(raw);
+    for (const event of parseRawEvent(raw)) {
+      processEvent(event, sink, { hadTextOutput });
+      if (event.type === "text_delta") {
+        hadTextOutput = true;
+      } else if (event.type === "tool_use") {
+        hadTextOutput = false;
+      }
+    }
+  }
+}
+function processEvent(event, sink, state) {
+  switch (event.type) {
+    case "text_delta":
+      sink.write(event.text);
+      break;
+    case "tool_use":
+      if (state.hadTextOutput) {
+        sink.line("");
+        sink.line("");
       }
+      for (const line of formatToolUse(event.name, event.input)) {
+        sink.line(line);
+      }
+      break;
+    case "tool_result":
+      sink.line("Result:");
+      sink.line(DIVIDER2);
+      sink.line(event.content);
+      sink.line(DIVIDER2);
+      sink.line("");
+      break;
+    case "result":
+      sink.line("");
+      sink.line(`\uD83C\uDFC1 Done: ${event.subtype}, ${event.num_turns} turns, $${event.cost_usd.toFixed(4)}`);
+      break;
+    case "assistant_message":
+      break;
+  }
+}
+function createStdoutSink() {
+  return {
+    write: (text) => process.stdout.write(text),
+    line: (text) => console.log(text)
+  };
+}
+
+// lib/claude/run.ts
+var defaultRunnerDependencies = {
+  spawnClaudeCode,
+  createStdoutSink,
+  streamEvents
+};
+async function run(prompt, options = {}, dependencies = defaultRunnerDependencies) {
+  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.spawnClaudeCode(prompt, spawnOptions);
+  const sink = dependencies.createStdoutSink();
+  await dependencies.streamEvents(events, sink, onRawEvent);
+}
+
+// lib/cli/commands/loop.ts
+import { spawn as nodeSpawn2 } from "node:child_process";
+
+// lib/cli/commands/next.ts
+function extractBlockedBy(content) {
+  const blockedByMatch = content.match(/^## Blocked By\s*\n([\s\S]*?)(?=\n## |\n*$)/m);
+  if (!blockedByMatch) {
+    return [];
+  }
+  const section = blockedByMatch[1].trim();
+  if (section === "(none)") {
+    return [];
+  }
+  const linkPattern = /\[.*?\]\(([^)]+\.md)\)/g;
+  const blockers = [];
+  let match = linkPattern.exec(section);
+  while (match !== null) {
+    blockers.push(match[1]);
+    match = linkPattern.exec(section);
+  }
+  return blockers;
+}
+async function findUnblockedTasks(cwd, fileSystem) {
+  const dustPath = `${cwd}/.dust`;
+  if (!fileSystem.exists(dustPath)) {
+    return { error: ".dust directory not found", tasks: [] };
+  }
+  const tasksPath = `${dustPath}/tasks`;
+  if (!fileSystem.exists(tasksPath)) {
+    return { tasks: [] };
+  }
+  const files = await fileSystem.readdir(tasksPath);
+  const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+  if (mdFiles.length === 0) {
+    return { tasks: [] };
+  }
+  const existingTasks = new Set(mdFiles);
+  const tasks = [];
+  for (const file of mdFiles) {
+    const filePath = `${tasksPath}/${file}`;
+    const content = await fileSystem.readFile(filePath);
+    const blockers = extractBlockedBy(content);
+    const hasIncompleteBlocker = blockers.some((blocker) => existingTasks.has(blocker));
+    if (!hasIncompleteBlocker) {
+      const title = extractTitle(content);
+      const openingSentence = extractOpeningSentence(content);
+      const relativePath = `.dust/tasks/${file}`;
+      tasks.push({ path: relativePath, title, openingSentence });
+    }
+  }
+  return { tasks };
+}
+function printTaskList(context, tasks) {
+  const colors = getColors();
+  context.stdout("\uD83D\uDCCB Next tasks");
+  context.stdout("");
+  for (const task of tasks) {
+    const parts = task.path.split("/");
+    const displayTitle = task.title || parts[parts.length - 1].replace(".md", "");
+    context.stdout(`${colors.bold}# ${displayTitle}${colors.reset}`);
+    if (task.openingSentence) {
+      context.stdout(`${colors.dim}${task.openingSentence}${colors.reset}`);
+    }
+    context.stdout(`${colors.cyan}→ ${task.path}${colors.reset}`);
+    context.stdout("");
+  }
+}
+async function next(dependencies) {
+  const { context, fileSystem } = dependencies;
+  const result = await findUnblockedTasks(context.cwd, fileSystem);
+  if (result.error) {
+    context.stderr(`Error: ${result.error}`);
+    context.stderr("Run 'dust init' to initialize a Dust repository");
+    return { exitCode: 1 };
+  }
+  if (result.tasks.length === 0) {
+    return { exitCode: 0 };
+  }
+  printTaskList(context, result.tasks);
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/loop.ts
+function formatEvent(event) {
+  switch (event.type) {
+    case "loop.warning":
+      return "⚠️  WARNING: This command skips all permission checks. Only use in a sandbox environment!";
+    case "loop.started":
+      return `\uD83D\uDD04 Starting dust loop claude (max ${event.maxIterations} iterations)...`;
+    case "loop.syncing":
+      return "\uD83C\uDF0D Syncing with remote";
+    case "loop.sync_skipped":
+      return `Note: git pull skipped (${event.reason})`;
+    case "loop.checking_tasks":
+      return null;
+    case "loop.no_tasks":
+      return `\uD83D\uDE34 No tasks available. Sleeping...
+`;
+    case "loop.tasks_found":
+      return `✨ Found a task. Going to work!
+`;
+    case "claude.started":
+      return "\uD83E\uDD16 Starting Claude...";
+    case "claude.ended":
+      return event.success ? "\uD83E\uDD16 Claude session ended (success)" : `\uD83E\uDD16 Claude session ended (error: ${event.error})`;
+    case "claude.raw_event":
       return null;
+    case "loop.iteration_complete":
+      return `\uD83D\uDCCB Completed iteration ${event.iteration}/${event.maxIterations}`;
+    case "loop.ended":
+      return `\uD83C\uDFC1 Reached max iterations (${event.maxIterations}). Exiting.`;
+  }
+}
+async function defaultPostEvent(url, payload) {
+  await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(payload)
+  });
+}
+function createDefaultDependencies() {
+  return {
+    spawn: nodeSpawn2,
+    run,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    postEvent: defaultPostEvent
+  };
+}
+function createEventPoster(eventsUrl, sessionId, postEvent, onError, getAgentSessionId, repository = "") {
+  let sequence = 0;
+  return (event) => {
+    if (!eventsUrl)
+      return;
+    const agentEvent = mapToAgentEvent(event);
+    if (!agentEvent)
+      return;
+    sequence++;
+    const payload = {
+      sequence,
+      timestamp: new Date().toISOString(),
+      sessionId,
+      repository,
+      event: agentEvent
+    };
+    const agentSessionId = getAgentSessionId?.();
+    if (agentSessionId) {
+      payload.agentSessionId = agentSessionId;
+    }
+    postEvent(eventsUrl, payload).catch(onError);
+  };
+}
+var SLEEP_INTERVAL_MS = 30000;
+var DEFAULT_MAX_ITERATIONS = 10;
+async function gitPull(cwd, spawn) {
+  return new Promise((resolve) => {
+    const proc = spawn("git", ["pull"], {
+      cwd,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    let stderr = "";
+    proc.stderr?.on("data", (data) => {
+      stderr += data.toString();
+    });
+    proc.on("close", (code) => {
+      if (code === 0) {
+        resolve({ success: true });
+      } else {
+        resolve({ success: false, message: stderr.trim() || "git pull failed" });
+      }
+    });
+    proc.on("error", (error) => {
+      resolve({ success: false, message: error.message });
+    });
+  });
+}
+async function hasAvailableTasks(dependencies) {
+  let hasOutput = false;
+  const captureContext = {
+    ...dependencies.context,
+    stdout: () => {
+      hasOutput = true;
     }
-  }
-  return null;
+  };
+  await next({ ...dependencies, context: captureContext });
+  return hasOutput;
 }
-function validateGoalHierarchySections(filePath, content) {
-  const violations = [];
-  for (const heading of REQUIRED_GOAL_HEADINGS) {
-    if (!content.includes(heading)) {
-      violations.push({
-        file: filePath,
-        message: `Missing required heading: "${heading}"`
+async function runOneIteration(dependencies, loopDependencies, emit, options = {}) {
+  const { context } = dependencies;
+  const { spawn, run: run2 } = loopDependencies;
+  const { onRawEvent } = options;
+  emit({ type: "loop.syncing" });
+  const pullResult = await gitPull(context.cwd, spawn);
+  if (!pullResult.success) {
+    emit({
+      type: "loop.sync_skipped",
+      reason: pullResult.message ?? "unknown error"
+    });
+    emit({ type: "claude.started" });
+    const prompt2 = `git pull failed with the following error:
+
+${pullResult.message}
+
+Please resolve this issue. Common approaches:
+1. If there are merge conflicts, resolve them
+2. If local commits need to be rebased, use git rebase
+3. After resolving, commit any changes and push to remote
+
+Make sure the repository is in a clean state and synced with remote before finishing.`;
+    try {
+      await run2(prompt2, {
+        spawnOptions: {
+          cwd: context.cwd,
+          dangerouslySkipPermissions: true,
+          env: { DUST_UNATTENDED: "1" }
+        },
+        onRawEvent
       });
+      emit({ type: "claude.ended", success: true });
+      return "resolved_pull_conflict";
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      context.stderr(`Claude failed to resolve git pull conflict: ${errorMessage}`);
+      emit({ type: "claude.ended", success: false, error: errorMessage });
     }
   }
-  return violations;
-}
-function validateGoalHierarchyLinks(filePath, content) {
-  const violations = [];
-  const lines = content.split(`
-`);
-  const fileDir = dirname2(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);
-    }
+  emit({ type: "loop.checking_tasks" });
+  const hasTasks = await hasAvailableTasks(dependencies);
+  if (!hasTasks) {
+    emit({ type: "loop.no_tasks" });
+    return "no_tasks";
   }
-  return violations;
-}
-function extractGoalRelationships(filePath, content) {
-  const lines = content.split(`
-`);
-  const fileDir = dirname2(filePath);
-  const parentGoals = [];
-  const subGoals = [];
-  let currentSection = null;
-  for (const line of lines) {
-    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("#") && !linkTarget.startsWith("http://") && !linkTarget.startsWith("https://")) {
-        const targetPath = linkTarget.split("#")[0];
-        const resolvedPath = resolve(fileDir, targetPath);
-        if (resolvedPath.includes("/.dust/goals/")) {
-          if (currentSection === "## Parent Goal") {
-            parentGoals.push(resolvedPath);
-          } else {
-            subGoals.push(resolvedPath);
-          }
-        }
-      }
-      match = linkPattern.exec(line);
-    }
+  emit({ type: "loop.tasks_found" });
+  emit({ type: "claude.started" });
+  const { dustCommand, installCommand = "npm install" } = dependencies.settings;
+  const prompt = `Run \`${installCommand} && ${dustCommand} agent && ${dustCommand} pick task\` and follow the instructions.`;
+  try {
+    await run2(prompt, {
+      spawnOptions: {
+        cwd: context.cwd,
+        dangerouslySkipPermissions: true,
+        env: { DUST_UNATTENDED: "1" }
+      },
+      onRawEvent
+    });
+    emit({ type: "claude.ended", success: true });
+    return "ran_claude";
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    context.stderr(`Claude exited with error: ${errorMessage}`);
+    emit({ type: "claude.ended", success: false, error: errorMessage });
+    return "claude_error";
   }
-  return { filePath, parentGoals, subGoals };
 }
-function validateBidirectionalLinks(allGoalRelationships) {
-  const violations = [];
-  const relationshipMap = new Map;
-  for (const rel of allGoalRelationships) {
-    relationshipMap.set(rel.filePath, rel);
+function parseMaxIterations(commandArguments) {
+  if (commandArguments.length === 0) {
+    return DEFAULT_MAX_ITERATIONS;
   }
-  for (const rel of allGoalRelationships) {
-    for (const parentPath of rel.parentGoals) {
-      const parentRel = relationshipMap.get(parentPath);
-      if (parentRel && !parentRel.subGoals.includes(rel.filePath)) {
-        violations.push({
-          file: rel.filePath,
-          message: `Parent goal "${parentPath}" does not list this goal as a sub-goal`
-        });
-      }
-    }
-    for (const subGoalPath of rel.subGoals) {
-      const subGoalRel = relationshipMap.get(subGoalPath);
-      if (subGoalRel && !subGoalRel.parentGoals.includes(rel.filePath)) {
-        violations.push({
-          file: rel.filePath,
-          message: `Sub-goal "${subGoalPath}" does not list this goal as its parent`
-        });
-      }
-    }
+  const parsed = Number.parseInt(commandArguments[0], 10);
+  if (Number.isNaN(parsed) || parsed <= 0) {
+    return DEFAULT_MAX_ITERATIONS;
   }
-  return violations;
+  return parsed;
 }
-function validateNoCycles(allGoalRelationships) {
-  const violations = [];
-  const relationshipMap = new Map;
-  for (const rel of allGoalRelationships) {
-    relationshipMap.set(rel.filePath, rel);
-  }
-  for (const rel of allGoalRelationships) {
-    const visited = new Set;
-    const path = [];
-    let current = rel.filePath;
-    while (current) {
-      if (visited.has(current)) {
-        const cycleStart = path.indexOf(current);
-        const cyclePath = path.slice(cycleStart).concat(current);
-        violations.push({
-          file: rel.filePath,
-          message: `Cycle detected in goal hierarchy: ${cyclePath.join(" -> ")}`
-        });
-        break;
-      }
-      visited.add(current);
-      path.push(current);
-      const currentRel = relationshipMap.get(current);
-      if (currentRel && currentRel.parentGoals.length > 0) {
-        current = currentRel.parentGoals[0];
-      } else {
-        current = null;
+async function loopClaude(dependencies, loopDependencies = createDefaultDependencies()) {
+  const { context, settings } = dependencies;
+  const { postEvent } = loopDependencies;
+  const maxIterations = parseMaxIterations(dependencies.arguments);
+  const eventsUrl = settings.eventsUrl;
+  const sessionId = crypto.randomUUID();
+  let agentSessionId;
+  const postEventFn = createEventPoster(eventsUrl, sessionId, postEvent, (error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    context.stderr(`Event POST failed: ${message}`);
+  }, () => agentSessionId);
+  const emit = (event) => {
+    const formatted = formatEvent(event);
+    if (formatted !== null) {
+      context.stdout(formatted);
+    }
+    postEventFn(event);
+  };
+  emit({ type: "loop.warning" });
+  emit({ type: "loop.started", maxIterations });
+  context.stdout("   Press Ctrl+C to stop");
+  context.stdout("");
+  let completedIterations = 0;
+  const iterationOptions = {};
+  if (eventsUrl) {
+    iterationOptions.onRawEvent = (rawEvent) => {
+      if (typeof rawEvent.session_id === "string" && rawEvent.session_id) {
+        agentSessionId = rawEvent.session_id;
       }
+      emit({ type: "claude.raw_event", rawEvent });
+    };
+  }
+  while (completedIterations < maxIterations) {
+    agentSessionId = undefined;
+    const result = await runOneIteration(dependencies, loopDependencies, emit, iterationOptions);
+    if (result === "no_tasks") {
+      await loopDependencies.sleep(SLEEP_INTERVAL_MS);
+    } else {
+      completedIterations++;
+      emit({
+        type: "loop.iteration_complete",
+        iteration: completedIterations,
+        maxIterations
+      });
     }
   }
-  return violations;
+  emit({ type: "loop.ended", maxIterations });
+  return { exitCode: 0 };
 }
-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 };
+
+// lib/bucket/repository.ts
+var SLEEP_INTERVAL_MS2 = 30000;
+function parseRepository(data) {
+  if (typeof data === "string") {
+    return { name: data, gitUrl: data };
+  }
+  if (typeof data === "object" && data !== null && "name" in data && "gitUrl" in data) {
+    const repositoryData = data;
+    if (typeof repositoryData.name === "string" && typeof repositoryData.gitUrl === "string") {
+      return { name: repositoryData.name, gitUrl: repositoryData.gitUrl };
     }
-    throw error;
   }
+  return null;
 }
-async function lintMarkdown(dependencies) {
-  const { context, fileSystem, globScanner: glob } = dependencies;
-  const dustPath = `${context.cwd}/.dust`;
-  const dustScan = await safeScanDir(glob, dustPath);
-  if (!dustScan.exists) {
-    context.stderr("Error: .dust directory not found");
-    context.stderr("Run 'dust init' to initialize a Dust repository");
-    return { exitCode: 1 };
-  }
-  const dustFiles = dustScan.files;
-  const violations = [];
-  context.stdout("Validating links in .dust/...");
-  for (const file of dustFiles) {
-    if (!file.endsWith(".md"))
-      continue;
-    const filePath = `${dustPath}/${file}`;
-    try {
-      const content = await fileSystem.readFile(filePath);
-      violations.push(...validateLinks(filePath, content, fileSystem));
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
+function getRepoTempPath(repoName, tempDir) {
+  const safeName = repoName.replace(/[^a-zA-Z0-9-_]/g, "-");
+  return join7(tempDir, `dust-bucket-${safeName}`);
+}
+async function cloneRepository(repository, targetPath, spawn, context) {
+  return new Promise((resolve) => {
+    const proc = spawn("git", ["clone", repository.gitUrl, targetPath], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    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);
       }
-    }
-  }
-  const contentDirs = ["goals", "facts", "ideas", "tasks"];
-  context.stdout("Validating content files...");
-  for (const dir of contentDirs) {
-    const dirPath = `${dustPath}/${dir}`;
-    const { files } = await safeScanDir(glob, dirPath);
-    for (const file of files) {
-      if (!file.endsWith(".md"))
-        continue;
-      const filePath = `${dirPath}/${file}`;
-      let content;
-      try {
-        content = await fileSystem.readFile(filePath);
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          continue;
+    });
+    proc.on("error", (error) => {
+      context.stderr(`Failed to clone ${repository.name}: ${error.message}`);
+      resolve(false);
+    });
+  });
+}
+async function removeRepository(path, spawn, context) {
+  return new Promise((resolve) => {
+    const proc = spawn("rm", ["-rf", path], {
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0);
+    });
+    proc.on("error", (error) => {
+      context.stderr(`Failed to remove ${path}: ${error.message}`);
+      resolve(false);
+    });
+  });
+}
+function createNoOpGlobScanner() {
+  return {
+    scan: async function* () {}
+  };
+}
+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 commandDeps = {
+    arguments: [],
+    context: {
+      cwd: repoState.path,
+      stdout: (msg) => appendLogLine(repoState.logBuffer, createLogLine(msg, "stdout")),
+      stderr: (msg) => appendLogLine(repoState.logBuffer, createLogLine(msg, "stderr"))
+    },
+    fileSystem,
+    globScanner: createNoOpGlobScanner(),
+    settings
+  };
+  let partialLine = "";
+  const bufferSinkDeps = {
+    ...defaultRunnerDependencies,
+    createStdoutSink: () => ({
+      write: (text) => {
+        partialLine += text;
+        const lines = partialLine.split(`
+`);
+        for (let i = 0;i < lines.length - 1; i++) {
+          appendLogLine(repoState.logBuffer, createLogLine(lines[i], "stdout"));
         }
-        throw error;
-      }
-      const openingSentenceViolation = validateOpeningSentence(filePath, content);
-      if (openingSentenceViolation) {
-        violations.push(openingSentenceViolation);
-      }
-      const openingSentenceLengthViolation = validateOpeningSentenceLength(filePath, content);
-      if (openingSentenceLengthViolation) {
-        violations.push(openingSentenceLengthViolation);
-      }
-      const titleFilenameViolation = validateTitleFilenameMatch(filePath, content);
-      if (titleFilenameViolation) {
-        violations.push(titleFilenameViolation);
-      }
-    }
-  }
-  const ideasPath = `${dustPath}/ideas`;
-  const { files: ideaFiles } = await safeScanDir(glob, ideasPath);
-  if (ideaFiles.length > 0) {
-    context.stdout("Validating idea files in .dust/ideas/...");
-    for (const file of ideaFiles) {
-      if (!file.endsWith(".md"))
-        continue;
-      const filePath = `${ideasPath}/${file}`;
-      let content;
-      try {
-        content = await fileSystem.readFile(filePath);
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          continue;
+        partialLine = lines[lines.length - 1];
+      },
+      line: (text) => {
+        if (partialLine) {
+          appendLogLine(repoState.logBuffer, createLogLine(partialLine, "stdout"));
+          partialLine = "";
         }
-        throw error;
-      }
-      violations.push(...validateIdeaOpenQuestions(filePath, content));
-    }
-  }
-  const tasksPath = `${dustPath}/tasks`;
-  const { files: taskFiles } = await safeScanDir(glob, tasksPath);
-  if (taskFiles.length > 0) {
-    context.stdout("Validating task files in .dust/tasks/...");
-    for (const file of taskFiles) {
-      if (!file.endsWith(".md"))
-        continue;
-      const filePath = `${tasksPath}/${file}`;
-      let content;
-      try {
-        content = await fileSystem.readFile(filePath);
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          continue;
+        for (const segment of text.split(`
+`)) {
+          appendLogLine(repoState.logBuffer, createLogLine(segment, "stdout"));
         }
-        throw error;
-      }
-      const filenameViolation = validateFilename(filePath);
-      if (filenameViolation) {
-        violations.push(filenameViolation);
-      }
-      violations.push(...validateTaskHeadings(filePath, content));
-      violations.push(...validateSemanticLinks(filePath, content));
-      const imperativeViolation = validateImperativeOpeningSentence(filePath, content);
-      if (imperativeViolation) {
-        violations.push(imperativeViolation);
       }
-      const ideaTransitionViolation = validateIdeaTransitionTitle(filePath, content, ideasPath, fileSystem);
-      if (ideaTransitionViolation) {
-        violations.push(ideaTransitionViolation);
+    })
+  };
+  const bufferRun = (prompt, options) => run2(prompt, options, bufferSinkDeps);
+  const loopDeps = {
+    spawn,
+    run: bufferRun,
+    sleep,
+    postEvent: async () => {}
+  };
+  let agentSessionId;
+  let sequence = 0;
+  const loopEmit = (event) => {
+    const formatted = formatEvent(event);
+    if (formatted !== null) {
+      appendLogLine(repoState.logBuffer, createLogLine(formatted, "stdout"));
+    }
+    const agentEvent = mapToAgentEvent(event);
+    if (agentEvent && sendEvent && sessionId) {
+      sequence++;
+      const msg = {
+        sequence,
+        timestamp: new Date().toISOString(),
+        sessionId,
+        repository: repoName,
+        event: agentEvent
+      };
+      if (agentSessionId) {
+        msg.agentSessionId = agentSessionId;
       }
+      sendEvent(msg);
     }
-  }
-  const goalsPath = `${dustPath}/goals`;
-  const { files: goalFiles } = await safeScanDir(glob, goalsPath);
-  if (goalFiles.length > 0) {
-    context.stdout("Validating goal hierarchy in .dust/goals/...");
-    const allGoalRelationships = [];
-    for (const file of goalFiles) {
-      if (!file.endsWith(".md"))
-        continue;
-      const filePath = `${goalsPath}/${file}`;
-      let content;
-      try {
-        content = await fileSystem.readFile(filePath);
-      } catch (error) {
-        if (error.code === "ENOENT") {
-          continue;
+  };
+  while (!repoState.stopRequested) {
+    agentSessionId = undefined;
+    const result = await runOneIteration(commandDeps, loopDeps, loopEmit, {
+      onRawEvent: (rawEvent) => {
+        if (typeof rawEvent.session_id === "string" && rawEvent.session_id) {
+          agentSessionId = rawEvent.session_id;
         }
-        throw error;
+        loopEmit({ type: "claude.raw_event", rawEvent });
       }
-      violations.push(...validateGoalHierarchySections(filePath, content));
-      violations.push(...validateGoalHierarchyLinks(filePath, content));
-      allGoalRelationships.push(extractGoalRelationships(filePath, content));
+    });
+    if (result === "no_tasks") {
+      await sleep(SLEEP_INTERVAL_MS2);
     }
-    violations.push(...validateBidirectionalLinks(allGoalRelationships));
-    violations.push(...validateNoCycles(allGoalRelationships));
   }
-  if (violations.length === 0) {
-    context.stdout("All validations passed!");
-    return { exitCode: 0 };
-  }
-  context.stderr(`Found ${violations.length} violation(s):`);
-  context.stderr("");
-  for (const v of violations) {
-    const location = v.line ? `:${v.line}` : "";
-    context.stderr(`  ${v.file}${location}`);
-    context.stderr(`    ${v.message}`);
-  }
-  return { exitCode: 1 };
-}
-
-// lib/cli/commands/check.ts
-var DEFAULT_CHECK_TIMEOUT_MS = 13000;
-async function runSingleCheck(check, cwd, runner) {
-  const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
-  const startTime = Date.now();
-  const result = await runner.run(check.command, cwd, timeoutMs);
-  const durationMs = Date.now() - startTime;
-  return {
-    name: check.name,
-    command: check.command,
-    exitCode: result.exitCode,
-    output: result.output,
-    hints: check.hints,
-    durationMs,
-    timedOut: result.timedOut,
-    timeoutSeconds: timeoutMs / 1000
-  };
-}
-async function runConfiguredChecks(checks, cwd, runner) {
-  const promises = checks.map((check) => runSingleCheck(check, cwd, runner));
-  return Promise.all(promises);
+  appendLogLine(repoState.logBuffer, createLogLine(`Stopped loop for ${repoName}`, "stdout"));
 }
-async function runConfiguredChecksSerially(checks, cwd, runner) {
-  const results = [];
-  for (const check of checks) {
-    results.push(await runSingleCheck(check, cwd, runner));
+async function addRepository(repository, manager, repoDeps, context) {
+  if (manager.repositories.has(repository.name)) {
+    return;
   }
-  return results;
-}
-async function runValidationCheck(dependencies) {
-  const outputLines = [];
-  const bufferedContext = {
-    cwd: dependencies.context.cwd,
-    stdout: (msg) => outputLines.push(msg),
-    stderr: (msg) => outputLines.push(msg)
-  };
-  const startTime = Date.now();
-  const result = await lintMarkdown({
-    ...dependencies,
-    context: bufferedContext,
-    arguments: []
-  });
-  const durationMs = Date.now() - startTime;
-  return {
-    name: "lint markdown",
-    command: "dust lint markdown",
-    exitCode: result.exitCode,
-    output: outputLines.join(`
-`),
-    isBuiltIn: true,
-    durationMs
+  const repoPath = getRepoTempPath(repository.name, repoDeps.getTempDir());
+  if (repoDeps.fileSystem.exists(repoPath)) {
+    await removeRepository(repoPath, repoDeps.spawn, context);
+  }
+  context.stdout(`Adding repository: ${repository.name}`);
+  const success = await cloneRepository(repository, repoPath, repoDeps.spawn, context);
+  if (!success) {
+    const errorEvent = {
+      type: "bucket.error",
+      repository: repository.name,
+      error: "Clone failed"
+    };
+    manager.emit(errorEvent);
+    context.stderr(formatBucketEvent(errorEvent));
+    return;
+  }
+  const repoState = {
+    repository,
+    path: repoPath,
+    loopPromise: null,
+    stopRequested: false,
+    logBuffer: manager.logBuffers.get(repository.name) ?? createLogBuffer()
+  };
+  manager.repositories.set(repository.name, repoState);
+  const addedEvent = {
+    type: "bucket.repository_added",
+    repository: repository.name
   };
+  manager.emit(addedEvent);
+  context.stdout(formatBucketEvent(addedEvent));
+  repoState.loopPromise = runRepositoryLoop(repoState, repoDeps, manager.sendEvent, manager.sessionId);
+}
+async function removeRepositoryFromManager(repoName, manager, repoDeps, context) {
+  const repoState = manager.repositories.get(repoName);
+  if (!repoState) {
+    return;
+  }
+  repoState.stopRequested = true;
+  if (repoState.loopPromise) {
+    await Promise.race([repoState.loopPromise, repoDeps.sleep(5000)]);
+  }
+  await removeRepository(repoState.path, repoDeps.spawn, context);
+  manager.repositories.delete(repoName);
+  const removedEvent = {
+    type: "bucket.repository_removed",
+    repository: repoName
+  };
+  manager.emit(removedEvent);
+  context.stdout(formatBucketEvent(removedEvent));
 }
-function displayResults(results, context) {
-  const passed = results.filter((r) => r.exitCode === 0);
-  const failed = results.filter((r) => r.exitCode !== 0);
-  for (const result of results) {
-    if (result.timedOut) {
-      context.stdout(`✗ ${result.name} [timed out after ${result.timeoutSeconds}s]`);
-    } else {
-      const timing = result.durationMs !== undefined && result.durationMs >= 1000 ? ` [${(result.durationMs / 1000).toFixed(1)}s]` : "";
-      if (result.exitCode === 0) {
-        context.stdout(`✓ ${result.name}${timing}`);
-      } else {
-        context.stdout(`✗ ${result.name}${timing}`);
-      }
+async function handleRepositoryList(repositories, manager, repoDeps, context) {
+  const incomingRepos = new Map;
+  for (const data of repositories) {
+    const repo = parseRepository(data);
+    if (repo) {
+      incomingRepos.set(repo.name, repo);
     }
   }
-  for (const result of failed) {
-    context.stdout("");
-    context.stdout(`> ${result.command}`);
-    if (result.timedOut) {
-      context.stdout(`Note: This check was killed after ${result.timeoutSeconds}s. To configure a different timeout, set "timeoutMilliseconds" in the check configuration in .dust/config/settings.json`);
+  for (const [name, repo] of incomingRepos) {
+    if (!manager.repositories.has(name)) {
+      await addRepository(repo, manager, repoDeps, context);
     }
-    if (result.output.trim()) {
-      context.stdout(result.output.trimEnd());
+  }
+  for (const name of manager.repositories.keys()) {
+    if (!incomingRepos.has(name)) {
+      await removeRepositoryFromManager(name, manager, repoDeps, context);
     }
-    if (result.hints && result.hints.length > 0) {
-      context.stdout("");
-      context.stdout(`Hints for fixing '${result.name}':`);
-      for (const hint of result.hints) {
-        context.stdout(`  - ${hint}`);
+  }
+}
+
+// lib/bucket/terminal-ui.ts
+var ANSI = {
+  HIDE_CURSOR: "\x1B[?25l",
+  SHOW_CURSOR: "\x1B[?25h",
+  MOVE_TO: (row, col) => `\x1B[${row};${col}H`,
+  CLEAR_LINE: "\x1B[2K",
+  CLEAR_SCREEN: "\x1B[2J",
+  ENTER_ALT_SCREEN: "\x1B[?1049h",
+  EXIT_ALT_SCREEN: "\x1B[?1049l",
+  RESET: "\x1B[0m",
+  BOLD: "\x1B[1m",
+  DIM: "\x1B[2m",
+  UNDERLINE: "\x1B[4m",
+  INVERSE: "\x1B[7m",
+  FG_BLACK: "\x1B[30m",
+  FG_RED: "\x1B[31m",
+  FG_GREEN: "\x1B[32m",
+  FG_YELLOW: "\x1B[33m",
+  FG_BLUE: "\x1B[34m",
+  FG_MAGENTA: "\x1B[35m",
+  FG_CYAN: "\x1B[36m",
+  FG_WHITE: "\x1B[37m",
+  BG_BLACK: "\x1B[40m",
+  BG_RED: "\x1B[41m",
+  BG_GREEN: "\x1B[42m",
+  BG_YELLOW: "\x1B[43m",
+  BG_BLUE: "\x1B[44m",
+  BG_MAGENTA: "\x1B[45m",
+  BG_CYAN: "\x1B[46m",
+  BG_WHITE: "\x1B[47m"
+};
+var REPO_COLORS = [
+  ANSI.FG_CYAN,
+  ANSI.FG_MAGENTA,
+  ANSI.FG_YELLOW,
+  ANSI.FG_GREEN,
+  ANSI.FG_BLUE,
+  ANSI.FG_RED
+];
+var SYSTEM_COLOR = ANSI.DIM;
+function visibleLength(text) {
+  return text.replace(/\x1b\[[0-9;]*m/g, "").length;
+}
+function truncateLine(text, maxWidth) {
+  if (maxWidth <= 0)
+    return "";
+  if (visibleLength(text) <= maxWidth)
+    return text;
+  const ansiRegex = /\x1b\[[0-9;]*m/g;
+  let visibleCount = 0;
+  let result = "";
+  let lastIndex = 0;
+  for (let match = ansiRegex.exec(text);match !== null; match = ansiRegex.exec(text)) {
+    const textBefore = text.slice(lastIndex, match.index);
+    for (const char of textBefore) {
+      if (visibleCount >= maxWidth - 1) {
+        result += "…";
+        return result + ANSI.RESET;
       }
+      result += char;
+      visibleCount++;
     }
+    result += match[0];
+    lastIndex = match.index + match[0].length;
   }
-  context.stdout("");
-  const indicator = failed.length > 0 ? "✗" : "✓";
-  context.stdout(`${indicator} ${passed.length}/${results.length} checks passed`);
-  return failed.length > 0 ? 1 : 0;
+  const remaining = text.slice(lastIndex);
+  for (const char of remaining) {
+    if (visibleCount >= maxWidth - 1) {
+      result += "…";
+      return result + ANSI.RESET;
+    }
+    result += char;
+    visibleCount++;
+  }
+  return result;
 }
-async function check(dependencies, shellRunner = defaultShellRunner) {
-  const {
-    arguments: commandArguments,
-    context,
-    fileSystem,
-    settings
-  } = dependencies;
-  const serial = commandArguments.includes("--serial");
-  if (!settings.checks || settings.checks.length === 0) {
-    context.stderr("Error: No checks configured in .dust/config/settings.json");
-    context.stderr("");
-    context.stderr("Add checks to your settings.json:");
-    context.stderr("  {");
-    context.stderr('    "checks": [');
-    context.stderr('      { "name": "lint", "command": "npm run lint" },');
-    context.stderr('      { "name": "test", "command": "npm test" }');
-    context.stderr("    ]");
-    context.stderr("  }");
-    return { exitCode: 1 };
+function createTerminalUIState() {
+  return {
+    repositories: [],
+    selectedIndex: -1,
+    logBuffers: new Map,
+    scrollOffset: 0,
+    autoScroll: true,
+    width: 80,
+    height: 24,
+    connectedHost: ""
+  };
+}
+function updateDimensions(state, width, height) {
+  state.width = width;
+  state.height = height;
+}
+function addRepository2(state, name, logBuffer) {
+  if (!state.repositories.includes(name)) {
+    state.repositories.push(name);
+    state.repositories.sort((a, b) => {
+      if (a === "system")
+        return 1;
+      if (b === "system")
+        return -1;
+      return a.localeCompare(b);
+    });
   }
-  const dustPath = `${context.cwd}/.dust`;
-  const hasDustDir = fileSystem.exists(dustPath);
-  if (serial) {
-    const results2 = [];
-    if (hasDustDir) {
-      results2.push(await runValidationCheck(dependencies));
+  state.logBuffers.set(name, logBuffer);
+}
+function removeRepository2(state, name) {
+  const index = state.repositories.indexOf(name);
+  if (index >= 0) {
+    state.repositories.splice(index, 1);
+    state.logBuffers.delete(name);
+    if (state.selectedIndex >= state.repositories.length) {
+      state.selectedIndex = state.repositories.length - 1;
     }
-    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner);
-    results2.push(...configuredResults);
-    const exitCode2 = displayResults(results2, context);
-    return { exitCode: exitCode2 };
   }
-  const checkPromises = [];
-  if (hasDustDir) {
-    checkPromises.push(runValidationCheck(dependencies));
+}
+function selectNext(state) {
+  if (state.repositories.length === 0)
+    return;
+  state.selectedIndex++;
+  if (state.selectedIndex >= state.repositories.length) {
+    state.selectedIndex = -1;
   }
-  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner));
-  const promiseResults = await Promise.all(checkPromises);
-  const results = [];
-  for (const result of promiseResults) {
-    if (Array.isArray(result)) {
-      results.push(...result);
+}
+function selectPrevious(state) {
+  if (state.repositories.length === 0)
+    return;
+  state.selectedIndex--;
+  if (state.selectedIndex < -1) {
+    state.selectedIndex = state.repositories.length - 1;
+  }
+}
+function scrollUp(state, lines = 1) {
+  const logs = getVisibleLogs(state);
+  const maxScroll = Math.max(0, logs.length - getLogAreaHeight(state));
+  state.scrollOffset = Math.min(state.scrollOffset + lines, maxScroll);
+  if (state.scrollOffset > 0) {
+    state.autoScroll = false;
+  }
+}
+function scrollDown(state, lines = 1) {
+  state.scrollOffset = Math.max(0, state.scrollOffset - lines);
+  if (state.scrollOffset === 0) {
+    state.autoScroll = true;
+  }
+}
+function scrollToTop(state) {
+  const logs = getVisibleLogs(state);
+  const maxScroll = Math.max(0, logs.length - getLogAreaHeight(state));
+  state.scrollOffset = maxScroll;
+  state.autoScroll = false;
+}
+function scrollToBottom(state) {
+  state.scrollOffset = 0;
+  state.autoScroll = true;
+}
+function getTabRowCount(state) {
+  if (state.width <= 0)
+    return 1;
+  const tabWidths = [5];
+  for (const name of state.repositories) {
+    tabWidths.push(name.length + 2);
+  }
+  let rows = 1;
+  let currentRowWidth = 0;
+  for (const tabWidth of tabWidths) {
+    const separatorWidth = currentRowWidth > 0 ? 1 : 0;
+    if (currentRowWidth + separatorWidth + tabWidth > state.width && currentRowWidth > 0) {
+      rows++;
+      currentRowWidth = tabWidth;
     } else {
-      results.push(result);
+      currentRowWidth += separatorWidth + tabWidth;
     }
   }
-  const exitCode = displayResults(results, context);
-  return { exitCode };
+  return rows;
 }
-
-// lib/cli/commands/focus.ts
-async function focus(dependencies) {
-  const { context, settings } = dependencies;
-  const objective = dependencies.arguments.join(" ").trim();
-  if (!objective) {
-    context.stderr("Error: No objective provided");
-    context.stderr('Usage: dust focus "your objective here"');
-    return { exitCode: 1 };
+function getLogAreaHeight(state) {
+  const tabRows = getTabRowCount(state);
+  return Math.max(1, state.height - (tabRows + 3));
+}
+function getRepoColor(name, index) {
+  if (name === "system")
+    return SYSTEM_COLOR;
+  return REPO_COLORS[index % REPO_COLORS.length];
+}
+function getVisibleLogs(state) {
+  if (state.selectedIndex === -1) {
+    const allLogs = [];
+    const repoColors = new Map;
+    for (let i = 0;i < state.repositories.length; i++) {
+      const repoName2 = state.repositories[i];
+      repoColors.set(repoName2, getRepoColor(repoName2, i));
+    }
+    for (const repoName2 of state.repositories) {
+      const buffer2 = state.logBuffers.get(repoName2);
+      if (!buffer2)
+        continue;
+      const color2 = repoColors.get(repoName2) ?? ANSI.FG_WHITE;
+      const lines = getLogLines(buffer2);
+      for (const line of lines) {
+        allLogs.push({ ...line, repository: repoName2, color: color2 });
+      }
+    }
+    allLogs.sort((a, b) => a.timestamp - b.timestamp);
+    return allLogs;
   }
-  const hooksInstalled = await manageGitHooks(dependencies);
-  const vars = templateVariables(settings, hooksInstalled);
-  context.stdout(`\uD83C\uDFAF Focus: ${objective}`);
-  context.stdout("");
-  const steps = [];
-  let step = 1;
-  steps.push(`${step}. Run \`${vars.bin} check\` to verify the project is in a good state`);
-  step++;
-  steps.push(`${step}. Implement the task`);
-  step++;
-  if (!hooksInstalled) {
-    steps.push(`${step}. Run \`${vars.bin} check\` before committing`);
-    step++;
+  const repoName = state.repositories[state.selectedIndex];
+  if (!repoName)
+    return [];
+  const buffer = state.logBuffers.get(repoName);
+  if (!buffer)
+    return [];
+  const color = getRepoColor(repoName, state.selectedIndex);
+  return getLogLines(buffer).map((line) => ({
+    ...line,
+    repository: repoName,
+    color
+  }));
+}
+function renderTabs(state) {
+  const tabs = [];
+  if (state.selectedIndex === -1) {
+    tabs.push({ text: `${ANSI.INVERSE} All ${ANSI.RESET}`, width: 5 });
+  } else {
+    tabs.push({ text: " All ", width: 5 });
+  }
+  for (let i = 0;i < state.repositories.length; i++) {
+    const name = state.repositories[i];
+    const color = getRepoColor(name, i);
+    const width = name.length + 2;
+    if (i === state.selectedIndex) {
+      tabs.push({
+        text: `${ANSI.INVERSE}${color} ${name} ${ANSI.RESET}`,
+        width
+      });
+    } else {
+      tabs.push({ text: `${color} ${name} ${ANSI.RESET}`, width });
+    }
   }
-  steps.push(`${step}. Create a single atomic commit that includes:`, "   - All implementation changes", "   - Deletion of the completed task file", "   - Updates to any facts that changed", "   - Deletion of any ideas that were fully realized", "", '   Use the task title as the commit message. Task titles are written in imperative form, which is the recommended style for git commit messages. Do not add prefixes like "Complete task:" - use the title directly.', "", '   Example: If the task title is "Add validation for user input", the commit message should be:', "   ```", "   Add validation for user input", "   ```", "");
-  step++;
-  steps.push(`${step}. Push your commit to the remote repository`);
-  steps.push("");
-  steps.push("Keep your change small and focused. One task, one commit.");
-  context.stdout(steps.join(`
-`));
-  return { exitCode: 0 };
+  const rows = [[]];
+  let currentRowWidth = 0;
+  for (const tab of tabs) {
+    const separatorWidth = currentRowWidth > 0 ? 1 : 0;
+    if (currentRowWidth + separatorWidth + tab.width > state.width && currentRowWidth > 0) {
+      rows.push([tab]);
+      currentRowWidth = tab.width;
+    } else {
+      rows[rows.length - 1].push(tab);
+      currentRowWidth += separatorWidth + tab.width;
+    }
+  }
+  return rows.map((row) => row.map((t) => t.text).join("|"));
 }
-
-// lib/cli/commands/help.ts
-function generateHelpText(settings) {
-  return loadTemplate("help", { bin: settings.dustCommand });
+function renderHelpLine() {
+  return `${ANSI.DIM}[←→] select  [↑↓] scroll  [PgUp/PgDn] page  [g/G] top/bottom  [q] quit${ANSI.RESET}`;
 }
-async function help(dependencies) {
-  dependencies.context.stdout(generateHelpText(dependencies.settings));
-  return { exitCode: 0 };
+function renderSeparator(width) {
+  return "─".repeat(width);
 }
-
-// lib/cli/commands/implement-task.ts
-async function implementTask(dependencies) {
-  const { context, settings } = dependencies;
-  const hooksInstalled = await manageGitHooks(dependencies);
-  const vars = templateVariables(settings, hooksInstalled);
-  context.stdout(`Run \`${vars.bin} focus "<task name>"\` to set your focus and see implementation instructions.`);
-  return { exitCode: 0 };
+function formatLogLine(line, prefixAlign, maxWidth) {
+  let prefix = "";
+  let prefixWidth = 0;
+  if (prefixAlign > 0) {
+    const paddedName = line.repository.padEnd(prefixAlign);
+    prefix = `${line.color}${paddedName}${ANSI.RESET} ${ANSI.DIM}|${ANSI.RESET} `;
+    prefixWidth = prefixAlign + 3;
+  }
+  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;
+  if (availableWidth <= 0)
+    return prefix;
+  return prefix + truncateLine(text, availableWidth);
 }
-
-// lib/cli/colors.ts
-var ANSI_COLORS = {
-  reset: "\x1B[0m",
-  bold: "\x1B[1m",
-  dim: "\x1B[2m",
-  cyan: "\x1B[36m",
-  green: "\x1B[32m",
-  yellow: "\x1B[33m"
-};
-var NO_COLORS = {
-  reset: "",
-  bold: "",
-  dim: "",
-  cyan: "",
-  green: "",
-  yellow: ""
+function renderFrame(state) {
+  const lines = [];
+  const hostLabel = state.connectedHost ? ` ${ANSI.DIM}[connected to ${state.connectedHost}]${ANSI.RESET}` : "";
+  lines.push(`${ANSI.BOLD}✨ dust bucket${ANSI.RESET}${hostLabel}`);
+  const tabRows = renderTabs(state);
+  for (const tabRow of tabRows) {
+    lines.push(tabRow);
+  }
+  const contentWidth = state.width - 1;
+  lines.push(truncateLine(renderHelpLine(), contentWidth));
+  lines.push(renderSeparator(contentWidth));
+  const logs = getVisibleLogs(state);
+  const logAreaHeight = getLogAreaHeight(state);
+  const prefixAlign = state.selectedIndex === -1 ? Math.max(0, ...state.repositories.map((r) => r.length)) : 0;
+  const totalLogs = logs.length;
+  const endIndex = Math.max(0, totalLogs - state.scrollOffset);
+  const startIndex = Math.max(0, endIndex - logAreaHeight);
+  for (let i = startIndex;i < endIndex; i++) {
+    const logLine = logs[i];
+    lines.push(formatLogLine(logLine, prefixAlign, contentWidth));
+  }
+  const renderedLogLines = endIndex - startIndex;
+  for (let i = renderedLogLines;i < logAreaHeight; i++) {
+    lines.push("");
+  }
+  if (state.scrollOffset > 0) {
+    const indicator = `${ANSI.DIM}↓ ${state.scrollOffset} more${ANSI.RESET}`;
+    lines[lines.length - 1] = indicator;
+  }
+  const output = [];
+  for (let i = 0;i < lines.length; i++) {
+    output.push(ANSI.MOVE_TO(i + 1, 1));
+    output.push(ANSI.CLEAR_LINE);
+    output.push(lines[i]);
+  }
+  return output.join("");
+}
+function enterAlternateScreen() {
+  return ANSI.ENTER_ALT_SCREEN + ANSI.HIDE_CURSOR + ANSI.CLEAR_SCREEN + "\x1B[?1000h" + "\x1B[?1006h";
+}
+function exitAlternateScreen() {
+  return `\x1B[?1006l\x1B[?1000l${ANSI.EXIT_ALT_SCREEN}${ANSI.SHOW_CURSOR}`;
+}
+var KEYS = {
+  UP: "\x1B[A",
+  DOWN: "\x1B[B",
+  RIGHT: "\x1B[C",
+  LEFT: "\x1B[D",
+  PAGE_UP: "\x1B[5~",
+  PAGE_DOWN: "\x1B[6~",
+  HOME: "\x1B[H",
+  END: "\x1B[F",
+  CTRL_C: "\x03"
 };
-function shouldDisableColors() {
-  if (process.env.NO_COLOR !== undefined) {
-    return true;
+var SGR_MOUSE_RE = new RegExp(String.raw`^\x1b\[<(\d+);\d+;\d+[Mm]$`);
+function parseSGRMouse(key) {
+  const match = key.match(SGR_MOUSE_RE);
+  if (!match)
+    return null;
+  return Number.parseInt(match[1], 10);
+}
+function handleKeyInput(state, key) {
+  const mouseButton = parseSGRMouse(key);
+  if (mouseButton !== null) {
+    if (mouseButton === 64) {
+      scrollUp(state, 3);
+    } else if (mouseButton === 65) {
+      scrollDown(state, 3);
+    }
+    return false;
   }
-  if (process.env.TERM === "dumb") {
-    return true;
+  switch (key) {
+    case "q":
+    case KEYS.CTRL_C:
+      return true;
+    case KEYS.LEFT:
+      selectPrevious(state);
+      state.scrollOffset = 0;
+      state.autoScroll = true;
+      break;
+    case KEYS.RIGHT:
+      selectNext(state);
+      state.scrollOffset = 0;
+      state.autoScroll = true;
+      break;
+    case KEYS.UP:
+      scrollUp(state, 1);
+      break;
+    case KEYS.DOWN:
+      scrollDown(state, 1);
+      break;
+    case KEYS.PAGE_UP:
+      scrollUp(state, getLogAreaHeight(state));
+      break;
+    case KEYS.PAGE_DOWN:
+      scrollDown(state, getLogAreaHeight(state));
+      break;
+    case "g":
+    case KEYS.HOME:
+      scrollToTop(state);
+      break;
+    case "G":
+    case KEYS.END:
+      scrollToBottom(state);
+      break;
+  }
+  return false;
+}
+
+// lib/cli/commands/bucket.ts
+var DEFAULT_DUSTBUCKET_WS_URL = "wss://dustbucket.com/agent/connect";
+var INITIAL_RECONNECT_DELAY_MS = 1000;
+var MAX_RECONNECT_DELAY_MS = 30000;
+function defaultCreateWebSocket(url, token) {
+  const ws = new WebSocket(url, {
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  return ws;
+}
+function defaultSetupKeypress(onKey) {
+  const stdin = process.stdin;
+  if (!stdin.isTTY) {
+    return () => {};
+  }
+  stdin.setRawMode(true);
+  stdin.resume();
+  stdin.setEncoding("utf8");
+  const handler = (key) => {
+    onKey(key);
+  };
+  stdin.on("data", handler);
+  return () => {
+    stdin.removeListener("data", handler);
+    stdin.setRawMode(false);
+    stdin.pause();
+  };
+}
+function defaultSetupSignals(onSignal) {
+  const handler = () => onSignal();
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+  return () => {
+    process.removeListener("SIGINT", handler);
+    process.removeListener("SIGTERM", handler);
+  };
+}
+function defaultSetupResize(onResize) {
+  const handler = () => {
+    const { columns, rows } = process.stdout;
+    onResize(columns ?? 80, rows ?? 24);
+  };
+  process.stdout.on("resize", handler);
+  return () => {
+    process.stdout.removeListener("resize", handler);
+  };
+}
+function defaultGetTerminalSize() {
+  return {
+    width: process.stdout.columns ?? 80,
+    height: process.stdout.rows ?? 24
+  };
+}
+function defaultWriteStdout(data) {
+  process.stdout.write(data);
+}
+function defaultCreateServer(handler) {
+  let resolvedPort = 0;
+  const server = httpCreateServer(async (nodeRequest, nodeResponse) => {
+    const url = new URL(nodeRequest.url ?? "/", `http://localhost:${resolvedPort}`);
+    const request = new Request(url.toString(), {
+      method: nodeRequest.method ?? "GET"
+    });
+    const response = handler(request);
+    const body = await response.text();
+    nodeResponse.writeHead(response.status, {
+      "Content-Type": response.headers.get("content-type") ?? "text/plain"
+    });
+    nodeResponse.end(body);
+  });
+  server.listen(0, () => {
+    const addr2 = server.address();
+    if (addr2 && typeof addr2 === "object") {
+      resolvedPort = addr2.port;
+    }
+  });
+  const addr = server.address();
+  if (addr && typeof addr === "object") {
+    resolvedPort = addr.port;
+  }
+  return { port: resolvedPort, stop: () => server.close() };
+}
+function defaultOpenBrowser(url) {
+  const cmd = process.platform === "darwin" ? "open" : "xdg-open";
+  nodeSpawn3(cmd, [url], { stdio: "ignore", detached: true }).unref();
+}
+function createDefaultBucketDependencies() {
+  const authFileSystem = {
+    exists: (path) => {
+      try {
+        accessSync(path);
+        return true;
+      } catch {
+        return false;
+      }
+    },
+    readFile: (path) => readFile(path, "utf8"),
+    writeFile: (path, content) => writeFile(path, content, "utf8"),
+    mkdir: (path, options) => mkdir(path, options).then(() => {}),
+    readdir: (path) => readdir(path),
+    chmod: (path, mode) => chmod(path, mode)
+  };
+  return {
+    spawn: nodeSpawn3,
+    createWebSocket: defaultCreateWebSocket,
+    setupKeypress: defaultSetupKeypress,
+    setupSignals: defaultSetupSignals,
+    setupResize: defaultSetupResize,
+    getTerminalSize: defaultGetTerminalSize,
+    writeStdout: defaultWriteStdout,
+    isTTY: process.stdout.isTTY ?? false,
+    sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
+    getTempDir: () => tmpdir(),
+    auth: {
+      createServer: defaultCreateServer,
+      openBrowser: defaultOpenBrowser,
+      getHomeDir: () => homedir(),
+      fileSystem: authFileSystem
+    }
+  };
+}
+function createInitialState() {
+  const sessionId = crypto.randomUUID();
+  const systemBuffer = createLogBuffer();
+  const state = {
+    ws: null,
+    repositories: new Map,
+    reconnectDelay: INITIAL_RECONNECT_DELAY_MS,
+    reconnectTimer: null,
+    shuttingDown: false,
+    sessionId,
+    emit: () => {},
+    sendEvent: () => {},
+    ui: createTerminalUIState(),
+    logBuffers: new Map
+  };
+  state.sendEvent = createEventMessageSender(() => state.ws);
+  state.logBuffers.set("system", systemBuffer);
+  addRepository2(state.ui, "system", systemBuffer);
+  return state;
+}
+function getWebSocketUrl() {
+  return process.env.DUST_BUCKET_AGENT_CONNECT_URL || DEFAULT_DUSTBUCKET_WS_URL;
+}
+function toRepositoryDependencies(bucketDeps, fileSystem) {
+  return {
+    spawn: bucketDeps.spawn,
+    run,
+    fileSystem,
+    sleep: bucketDeps.sleep,
+    getTempDir: bucketDeps.getTempDir
+  };
+}
+function syncUIWithRepoList(state, repos) {
+  const incomingNames = new Set;
+  for (const data of repos) {
+    const repo = parseRepository(data);
+    if (repo) {
+      incomingNames.add(repo.name);
+      if (!state.ui.repositories.includes(repo.name)) {
+        let buffer = state.logBuffers.get(repo.name);
+        if (!buffer) {
+          buffer = createLogBuffer();
+          state.logBuffers.set(repo.name, buffer);
+        }
+        addRepository2(state.ui, repo.name, buffer);
+      }
+    }
+  }
+  for (const name of [...state.ui.repositories]) {
+    if (name !== "system" && !incomingNames.has(name)) {
+      state.logBuffers.delete(name);
+      removeRepository2(state.ui, name);
+    }
+  }
+}
+function syncTUI(state) {
+  const currentUIRepos = new Set(state.ui.repositories);
+  const currentRepos = new Set(state.repositories.keys());
+  for (const [name, repoState] of state.repositories) {
+    state.logBuffers.set(name, repoState.logBuffer);
+    addRepository2(state.ui, name, repoState.logBuffer);
+  }
+  for (const name of currentUIRepos) {
+    if (name !== "system" && !currentRepos.has(name)) {
+      state.logBuffers.delete(name);
+      removeRepository2(state.ui, name);
+    }
+  }
+}
+function logMessage(state, context, useTUI, message, stream = "stdout") {
+  if (useTUI) {
+    const systemBuffer = state.logBuffers.get("system");
+    if (!systemBuffer)
+      return;
+    appendLogLine(systemBuffer, createLogLine(message, stream));
+  } else if (stream === "stderr") {
+    context.stderr(message);
+  } else {
+    context.stdout(message);
   }
-  if (!process.stdout.isTTY) {
-    return true;
+}
+function createTUIContext(state, context, useTUI) {
+  if (!useTUI)
+    return context;
+  return {
+    ...context,
+    stdout: (message) => logMessage(state, context, true, message, "stdout"),
+    stderr: (message) => logMessage(state, context, true, message, "stderr")
+  };
+}
+function waitForConnection(token, bucketDeps) {
+  const wsUrl = getWebSocketUrl();
+  const ws = bucketDeps.createWebSocket(wsUrl, token);
+  return new Promise((resolve, reject) => {
+    ws.onopen = () => resolve(ws);
+    ws.onerror = (error) => reject(new Error(error.message));
+    ws.onclose = (event) => reject(new Error(`Connection closed (code ${event.code})`));
+  });
+}
+function connectWebSocket(token, state, bucketDependencies, context, fileSystem, useTUI, connectedWs) {
+  if (state.shuttingDown)
+    return;
+  const wsUrl = getWebSocketUrl();
+  let ws;
+  if (connectedWs) {
+    ws = connectedWs;
+    state.ws = ws;
+    state.emit({ type: "bucket.connected" });
+    logMessage(state, context, useTUI, formatBucketEvent({ type: "bucket.connected" }));
+    state.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+  } else {
+    logMessage(state, context, useTUI, `Connecting to ${wsUrl}...`);
+    ws = bucketDependencies.createWebSocket(wsUrl, token);
+    state.ws = ws;
+    ws.onopen = () => {
+      state.emit({ type: "bucket.connected" });
+      logMessage(state, context, useTUI, formatBucketEvent({ type: "bucket.connected" }));
+      state.reconnectDelay = INITIAL_RECONNECT_DELAY_MS;
+    };
   }
-  return false;
+  ws.onclose = (event) => {
+    const disconnectEvent = {
+      type: "bucket.disconnected",
+      code: event.code,
+      reason: event.reason || "none"
+    };
+    state.emit(disconnectEvent);
+    logMessage(state, context, useTUI, formatBucketEvent(disconnectEvent));
+    state.ws = null;
+    if (!state.shuttingDown) {
+      logMessage(state, context, useTUI, `Reconnecting in ${state.reconnectDelay / 1000} seconds...`);
+      state.reconnectTimer = setTimeout(() => {
+        connectWebSocket(token, state, bucketDependencies, context, fileSystem, useTUI);
+      }, state.reconnectDelay);
+      state.reconnectDelay = Math.min(state.reconnectDelay * 2, MAX_RECONNECT_DELAY_MS);
+    }
+  };
+  ws.onerror = (error) => {
+    logMessage(state, context, useTUI, `WebSocket error: ${error.message}`, "stderr");
+  };
+  ws.onmessage = (event) => {
+    try {
+      const message = JSON.parse(event.data);
+      if (message.type === "repository-list") {
+        const repos = message.repositories ?? [];
+        logMessage(state, context, useTUI, `Received repository list (${repos.length} repositories)`);
+        syncUIWithRepoList(state, repos);
+        const repoDeps = toRepositoryDependencies(bucketDependencies, fileSystem);
+        const repoContext = createTUIContext(state, context, useTUI);
+        handleRepositoryList(repos, state, repoDeps, repoContext).then(() => syncTUI(state)).catch((error) => {
+          logMessage(state, context, useTUI, `Failed to handle repository list: ${error.message}`, "stderr");
+        });
+      }
+    } catch {
+      logMessage(state, context, useTUI, `Failed to parse WebSocket message: ${event.data}`, "stderr");
+    }
+  };
 }
-function getColors() {
-  return shouldDisableColors() ? NO_COLORS : ANSI_COLORS;
+async function shutdown(state, bucketDeps, context) {
+  if (state.shuttingDown)
+    return;
+  state.shuttingDown = true;
+  context.stdout("Shutting down...");
+  if (state.reconnectTimer) {
+    clearTimeout(state.reconnectTimer);
+    state.reconnectTimer = null;
+  }
+  if (state.ws && state.ws.readyState === WS_OPEN) {
+    state.ws.close();
+    state.ws = null;
+  }
+  for (const repoState of state.repositories.values()) {
+    repoState.stopRequested = true;
+  }
+  const loopPromises = Array.from(state.repositories.values()).map((rs) => rs.loopPromise).filter((p) => p !== null);
+  await Promise.all(loopPromises.map((p) => p.catch(() => {})));
+  for (const repoState of state.repositories.values()) {
+    await removeRepository(repoState.path, bucketDeps.spawn, context);
+  }
+  state.repositories.clear();
+}
+function setupTUI(state, bucketDeps) {
+  const { width, height } = bucketDeps.getTerminalSize();
+  updateDimensions(state.ui, width, height);
+  bucketDeps.writeStdout(enterAlternateScreen());
+  const cleanupResize = bucketDeps.setupResize((w, h) => {
+    updateDimensions(state.ui, w, h);
+  });
+  const renderInterval = setInterval(() => {
+    if (!state.shuttingDown) {
+      bucketDeps.writeStdout(renderFrame(state.ui));
+    }
+  }, 100);
+  return {
+    cleanup: () => {
+      clearInterval(renderInterval);
+      bucketDeps.writeStdout(exitAlternateScreen());
+      cleanupResize();
+    }
+  };
 }
-
-// lib/cli/commands/init.ts
-var DUST_DIRECTORIES = ["goals", "ideas", "tasks", "facts", "config"];
-function generateSettings(cwd, fileSystem) {
-  const dustCommand = detectDustCommand(cwd, fileSystem);
-  const testCommand = detectTestCommand(cwd, fileSystem);
-  const checks = [];
-  if (testCommand) {
-    checks.push({ name: "test", command: testCommand });
+function createKeypressHandler(useTUI, state, onQuit) {
+  if (useTUI) {
+    return (key) => {
+      const shouldQuit = handleKeyInput(state.ui, key);
+      if (shouldQuit)
+        onQuit();
+    };
   }
-  return { dustCommand, checks };
+  return (key) => {
+    if (key === "q" || key === "\x03")
+      onQuit();
+  };
 }
-var USE_DUST_FACT = `# Use dust for planning
-
-This project uses [dust](https://github.com/joshski/dust) for planning and documentation.
-`;
-async function init(dependencies) {
-  const { context, fileSystem } = dependencies;
-  const colors = getColors();
-  const dustPath = `${context.cwd}/.dust`;
-  const dustCommand = detectDustCommand(context.cwd, fileSystem);
-  const agentInstruction = `Always immediately run \`${dustCommand} agent\` when you start working in this repository.`;
-  await fileSystem.mkdir(dustPath, { recursive: true });
-  for (const dir of DUST_DIRECTORIES) {
-    await fileSystem.mkdir(`${dustPath}/${dir}`, { recursive: true });
+async function resolveToken(commandArgs, authDeps, context) {
+  if (commandArgs[0]) {
+    return commandArgs[0];
   }
-  let dustDirCreated = false;
-  try {
-    await fileSystem.writeFile(`${dustPath}/facts/use-dust-for-planning.md`, USE_DUST_FACT, { flag: "wx" });
-    dustDirCreated = true;
-  } catch (error) {
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
+  const stored = await loadStoredToken(authDeps.fileSystem, authDeps.getHomeDir());
+  if (stored) {
+    return stored;
   }
+  context.stdout("Opening browser to authenticate with dustbucket...");
   try {
-    const settings = generateSettings(context.cwd, fileSystem);
-    await fileSystem.writeFile(`${dustPath}/config/settings.json`, `${JSON.stringify(settings, null, 2)}
-`, { flag: "wx" });
+    const token = await authenticate(authDeps);
+    await storeToken(authDeps.fileSystem, authDeps.getHomeDir(), token);
+    context.stdout("Authenticated successfully");
+    return token;
   } catch (error) {
-    if (error.code !== "EEXIST") {
-      throw error;
-    }
+    context.stderr(`Authentication failed: ${error.message}`);
+    return null;
   }
-  if (dustDirCreated) {
-    context.stdout(`${colors.green}✨ Initialized${colors.reset} Dust repository in ${colors.cyan}.dust/${colors.reset}`);
-    context.stdout(`${colors.green}\uD83D\uDCC1 Created directories:${colors.reset} ${colors.dim}${DUST_DIRECTORIES.join(", ")}${colors.reset}`);
-    context.stdout(`${colors.green}\uD83D\uDCC4 Created initial fact:${colors.reset} ${colors.cyan}.dust/facts/use-dust-for-planning.md${colors.reset}`);
-    context.stdout(`${colors.green}⚙️  Created settings:${colors.reset} ${colors.cyan}.dust/config/settings.json${colors.reset}`);
-  } else {
-    context.stdout(`${colors.yellow}\uD83D\uDCE6 Note:${colors.reset} ${colors.cyan}.dust${colors.reset} directory already exists, skipping creation`);
+}
+async function bucket(dependencies, bucketDeps = createDefaultBucketDependencies()) {
+  const { arguments: commandArgs, context, fileSystem } = dependencies;
+  const token = await resolveToken(commandArgs, bucketDeps.auth, context);
+  if (!token) {
+    return { exitCode: 1 };
   }
-  const claudeMdPath = `${context.cwd}/CLAUDE.md`;
+  const wsUrl = getWebSocketUrl();
+  context.stdout(`Connecting to ${wsUrl}...`);
+  let initialWs;
   try {
-    const claudeContent = loadTemplate("claude-md", { dustCommand });
-    await fileSystem.writeFile(claudeMdPath, claudeContent, { flag: "wx" });
-    context.stdout(`${colors.green}\uD83D\uDCC4 Created${colors.reset} ${colors.cyan}CLAUDE.md${colors.reset} with agent instructions`);
+    initialWs = await waitForConnection(token, bucketDeps);
   } catch (error) {
-    if (error.code === "EEXIST") {
-      context.stdout(`${colors.yellow}⚠️  Warning:${colors.reset} ${colors.cyan}CLAUDE.md${colors.reset} already exists. Consider adding: ${colors.dim}"${agentInstruction}"${colors.reset}`);
+    if (error.message.includes("1008") || error.message.includes("401")) {
+      context.stderr("Token rejected. Clearing stored credentials...");
+      await clearToken(bucketDeps.auth.fileSystem, bucketDeps.auth.getHomeDir());
+      context.stderr("Run `dust bucket` again to re-authenticate.");
     } else {
-      throw error;
+      context.stderr(`Failed to connect: ${error.message}`);
     }
+    return { exitCode: 1 };
   }
-  const agentsMdPath = `${context.cwd}/AGENTS.md`;
+  context.stdout("Connected");
+  const state = createInitialState();
+  const useTUI = bucketDeps.isTTY;
   try {
-    const agentsContent = loadTemplate("agents-md", { dustCommand });
-    await fileSystem.writeFile(agentsMdPath, agentsContent, { flag: "wx" });
-    context.stdout(`${colors.green}\uD83D\uDCC4 Created${colors.reset} ${colors.cyan}AGENTS.md${colors.reset} with agent instructions`);
-  } catch (error) {
-    if (error.code === "EEXIST") {
-      context.stdout(`${colors.yellow}⚠️  Warning:${colors.reset} ${colors.cyan}AGENTS.md${colors.reset} already exists. Consider adding: ${colors.dim}"${agentInstruction}"${colors.reset}`);
-    } else {
-      throw error;
-    }
+    state.ui.connectedHost = new URL(wsUrl).hostname;
+  } catch {
+    state.ui.connectedHost = wsUrl;
   }
-  const runner = dustCommand.split(" ")[0];
-  context.stdout("");
-  context.stdout(`${colors.bold}\uD83D\uDE80 Next steps:${colors.reset} Commit the changes if you are happy, then get planning!`);
-  context.stdout("");
-  context.stdout(`${colors.dim}If this is a new repository, you can start adding ideas or tasks right away:${colors.reset}`);
-  context.stdout(`   ${colors.cyan}>${colors.reset} ${runner} claude "Idea: friendly UI for non-technical users"`);
-  context.stdout(`   ${colors.cyan}>${colors.reset} ${runner} codex "Task: set up code coverage"`);
-  context.stdout("");
-  context.stdout(`${colors.dim}If this is an existing codebase, you might want to backfill goals and facts:${colors.reset}`);
-  context.stdout(`   ${colors.cyan}>${colors.reset} ${runner} claude "Add goals and facts based on the code in this repository"`);
+  let tuiHandle;
+  let cleanupKeypress;
+  let cleanupSignals;
+  try {
+    if (useTUI) {
+      tuiHandle = setupTUI(state, bucketDeps);
+    }
+    await new Promise((resolve) => {
+      const doShutdown = async () => {
+        await shutdown(state, bucketDeps, context);
+        resolve();
+      };
+      const onKey = createKeypressHandler(useTUI, state, () => {
+        doShutdown();
+      });
+      cleanupKeypress = bucketDeps.setupKeypress(onKey);
+      cleanupSignals = bucketDeps.setupSignals(() => {
+        doShutdown();
+      });
+      connectWebSocket(token, state, bucketDeps, context, fileSystem, useTUI, initialWs);
+      if (!useTUI) {
+        context.stdout("   Press q or Ctrl+C to exit");
+      }
+    });
+  } finally {
+    tuiHandle?.cleanup();
+    cleanupKeypress?.();
+    cleanupSignals?.();
+  }
+  context.stdout("Goodbye!");
   return { exitCode: 0 };
 }
 
-// lib/cli/commands/list.ts
-import { basename } from "node:path";
-var VALID_TYPES = ["tasks", "ideas", "goals", "facts"];
-var SECTION_HEADERS = {
-  tasks: "\uD83D\uDCCB Tasks",
-  ideas: "\uD83D\uDCA1 Ideas",
-  goals: "\uD83C\uDFAF Goals",
-  facts: "\uD83D\uDCC4 Facts"
-};
-var TYPE_EXPLANATIONS = {
-  tasks: "Tasks are detailed work plans with dependencies and completion criteria. Each task describes a specific piece of work to be done.",
-  ideas: "Ideas are future feature notes and proposals. Ideas capture possibilities that haven't yet been refined into actionable tasks.",
-  goals: "Goals are mission statements and guiding principles. Goals describe desired outcomes and values that inform decision-making.",
-  facts: "Facts are current state documentation. Facts capture how things work today, providing context for agents and contributors."
-};
-async function buildGoalHierarchy(goalsPath, fileSystem) {
-  const files = await fileSystem.readdir(goalsPath);
-  const mdFiles = files.filter((f) => f.endsWith(".md"));
-  const relationships = [];
-  const titleMap = new Map;
-  for (const file of mdFiles) {
-    const filePath = `${goalsPath}/${file}`;
-    const content = await fileSystem.readFile(filePath);
-    relationships.push(extractGoalRelationships(filePath, content));
-    const title = extractTitle(content) || basename(file, ".md");
-    titleMap.set(filePath, title);
+// lib/cli/process-runner.ts
+import { spawn } from "node:child_process";
+function createShellRunner(spawnFn) {
+  return {
+    run: (command, cwd, timeoutMs) => runBufferedProcess(spawnFn, command, [], cwd, true, timeoutMs)
+  };
+}
+var defaultShellRunner = createShellRunner(spawn);
+function createGitRunner(spawnFn) {
+  return {
+    run: (gitArguments, cwd) => runBufferedProcess(spawnFn, "git", gitArguments, cwd, false)
+  };
+}
+var defaultGitRunner = createGitRunner(spawn);
+function runBufferedProcess(spawnFn, command, commandArguments, cwd, shell, timeoutMs) {
+  return new Promise((resolve) => {
+    const proc = spawnFn(command, commandArguments, { cwd, shell });
+    const chunks = [];
+    let resolved = false;
+    let timer;
+    if (timeoutMs !== undefined) {
+      timer = setTimeout(() => {
+        resolved = true;
+        proc.kill();
+        resolve({
+          exitCode: 1,
+          output: chunks.join(""),
+          timedOut: true
+        });
+      }, timeoutMs);
+    }
+    proc.stdout?.on("data", (data) => {
+      chunks.push(data.toString());
+    });
+    proc.stderr?.on("data", (data) => {
+      chunks.push(data.toString());
+    });
+    proc.on("close", (code) => {
+      if (resolved)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      resolve({ exitCode: code ?? 1, output: chunks.join("") });
+    });
+    proc.on("error", (error) => {
+      if (resolved)
+        return;
+      if (timer !== undefined)
+        clearTimeout(timer);
+      resolve({ exitCode: 1, output: error.message });
+    });
+  });
+}
+
+// lib/cli/commands/lint-markdown.ts
+import { dirname as dirname3, resolve } from "node:path";
+
+// lib/workflow-tasks.ts
+var IDEA_TRANSITION_PREFIXES = [
+  "Refine Idea: ",
+  "Decompose Idea: ",
+  "Shelve Idea: "
+];
+function titleToFilename(title) {
+  return `${title.toLowerCase().replace(/\./g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}.md`;
+}
+
+// lib/cli/commands/lint-markdown.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 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`
+    };
   }
-  const relMap = new Map;
-  for (const rel of relationships) {
-    relMap.set(rel.filePath, rel);
+  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;
+}
+function validateOpeningSentence(filePath, content) {
+  const openingSentence = extractOpeningSentence(content);
+  if (!openingSentence) {
+    return {
+      file: filePath,
+      message: "Missing or malformed opening sentence after H1 heading"
+    };
+  }
+  return null;
+}
+function validateOpeningSentenceLength(filePath, content) {
+  const openingSentence = extractOpeningSentence(content);
+  if (!openingSentence) {
+    return null;
+  }
+  if (openingSentence.length > MAX_OPENING_SENTENCE_LENGTH) {
+    return {
+      file: filePath,
+      message: `Opening sentence is ${openingSentence.length} characters (max ${MAX_OPENING_SENTENCE_LENGTH}). Split into multiple sentences; only the first sentence is checked.`
+    };
+  }
+  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) {
+    return null;
   }
-  const rootGoals = relationships.filter((rel) => rel.parentGoals.length === 0);
-  function buildNode(filePath) {
-    const rel = relMap.get(filePath);
-    const children = [];
-    if (rel) {
-      for (const childPath of rel.subGoals) {
-        children.push(buildNode(childPath));
-      }
-    }
+  const firstWord = openingSentence.split(/\s/)[0].replace(/[^a-zA-Z]/g, "");
+  const lower = firstWord.toLowerCase();
+  if (NON_IMPERATIVE_STARTERS.has(lower) || lower.endsWith("ing")) {
+    const preview = openingSentence.length > 40 ? `${openingSentence.slice(0, 40)}...` : openingSentence;
     return {
-      filePath,
-      title: titleMap.get(filePath) || basename(filePath, ".md"),
-      children
+      file: filePath,
+      message: `Opening sentence should use imperative form (e.g., "Add X" not "This adds X"). Found: "${preview}"`
     };
   }
-  return rootGoals.map((rel) => buildNode(rel.filePath));
+  return null;
 }
-function renderHierarchy(nodes, output, prefix = "") {
-  for (let i = 0;i < nodes.length; i++) {
-    const node = nodes[i];
-    const isLastNode = i === nodes.length - 1;
-    const connector = isLastNode ? "└── " : "├── ";
-    const childPrefix = isLastNode ? "    " : "│   ";
-    output(`${prefix}${connector}${node.title}`);
-    if (node.children.length > 0) {
-      renderHierarchy(node.children, output, prefix + childPrefix);
+function validateTaskHeadings(filePath, content) {
+  const violations = [];
+  for (const heading of REQUIRED_HEADINGS) {
+    if (!content.includes(heading)) {
+      violations.push({
+        file: filePath,
+        message: `Missing required heading: "${heading}"`
+      });
     }
   }
+  return violations;
 }
-async function list(dependencies) {
-  const { arguments: commandArguments, context, fileSystem } = dependencies;
-  const dustPath = `${context.cwd}/.dust`;
-  const colors = getColors();
-  if (!fileSystem.exists(dustPath)) {
-    context.stderr("Error: .dust directory not found");
-    context.stderr("Run 'dust init' to initialize a Dust repository");
-    return { exitCode: 1 };
-  }
-  const typesToList = commandArguments.length === 0 ? [...VALID_TYPES] : commandArguments.filter((a) => VALID_TYPES.includes(a));
-  if (commandArguments.length > 0 && typesToList.length === 0) {
-    context.stderr(`Invalid type: ${commandArguments[0]}`);
-    context.stderr(`Valid types: ${VALID_TYPES.join(", ")}`);
-    return { exitCode: 1 };
-  }
-  const specificTypeRequested = commandArguments.length > 0;
-  for (const type of typesToList) {
-    const dirPath = `${dustPath}/${type}`;
-    const dirExists = fileSystem.exists(dirPath);
-    const files = dirExists ? await fileSystem.readdir(dirPath) : [];
-    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
-    if (mdFiles.length === 0) {
-      if (specificTypeRequested) {
-        context.stdout(SECTION_HEADERS[type]);
-        context.stdout("");
-        context.stdout(TYPE_EXPLANATIONS[type]);
-        context.stdout("");
-        context.stdout(`No ${type} found.`);
-        context.stdout("");
+function validateLinks(filePath, content, 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
+          });
+        }
       }
-      continue;
+      match = linkPattern.exec(line);
     }
-    context.stdout(SECTION_HEADERS[type]);
-    context.stdout("");
-    context.stdout(TYPE_EXPLANATIONS[type]);
-    context.stdout("");
-    if (type === "goals") {
-      const hierarchy = await buildGoalHierarchy(dirPath, fileSystem);
-      if (hierarchy.length > 0) {
-        context.stdout(`${colors.dim}Hierarchy:${colors.reset}`);
-        renderHierarchy(hierarchy, (line) => context.stdout(line));
-        context.stdout("");
-      }
+  }
+  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;
     }
-    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}`;
-      if (title) {
-        context.stdout(`${colors.bold}# ${title}${colors.reset}`);
-      } else {
-        context.stdout(`${colors.bold}# ${file.replace(".md", "")}${colors.reset}`);
+    if (inCodeBlock)
+      continue;
+    if (line.startsWith("## ")) {
+      if (inOpenQuestions && currentQuestionLine !== null) {
+        violations.push({
+          file: filePath,
+          message: "Question has no options listed beneath it",
+          line: currentQuestionLine
+        });
       }
-      if (openingSentence) {
-        context.stdout(`${colors.dim}${openingSentence}${colors.reset}`);
+      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
+        });
       }
-      context.stdout(`${colors.cyan}→ ${relativePath}${colors.reset}`);
-      context.stdout("");
+      inOpenQuestions = line === "## Open Questions";
+      currentQuestionLine = null;
+      continue;
     }
-  }
-  return { exitCode: 0 };
-}
-
-// lib/cli/commands/loop.ts
-import { spawn as nodeSpawn2 } from "node:child_process";
-
-// lib/claude/spawn-claude-code.ts
-import { spawn as nodeSpawn } from "node:child_process";
-import { createInterface as nodeCreateInterface } from "node:readline";
-var defaultDependencies = {
-  spawn: nodeSpawn,
-  createInterface: nodeCreateInterface
-};
-async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDependencies) {
-  const {
-    cwd,
-    allowedTools,
-    maxTurns,
-    model,
-    systemPrompt,
-    sessionId,
-    dangerouslySkipPermissions,
-    env
-  } = options;
-  const claudeArguments = [
-    "-p",
-    prompt,
-    "--output-format",
-    "stream-json",
-    "--verbose",
-    "--include-partial-messages"
-  ];
-  if (allowedTools?.length) {
-    claudeArguments.push("--allowedTools", ...allowedTools);
-  }
-  if (maxTurns) {
-    claudeArguments.push("--max-turns", String(maxTurns));
-  }
-  if (model) {
-    claudeArguments.push("--model", model);
-  }
-  if (systemPrompt) {
-    claudeArguments.push("--system-prompt", systemPrompt);
-  }
-  if (sessionId) {
-    claudeArguments.push("--session-id", sessionId);
-  }
-  if (dangerouslySkipPermissions) {
-    claudeArguments.push("--dangerously-skip-permissions");
-  }
-  const proc = dependencies.spawn("claude", claudeArguments, {
-    cwd,
-    stdio: ["ignore", "pipe", "pipe"],
-    env: { ...process.env, ...env }
-  });
-  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())
+    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;
-    try {
-      yield JSON.parse(line);
-    } catch {}
+    }
+    if (line.startsWith("#### ")) {
+      currentQuestionLine = null;
+    }
   }
-  await new Promise((resolve2, reject) => {
-    proc.on("close", (code) => {
-      if (code === 0 || code === null)
-        resolve2();
-      else
-        reject(new Error(`claude exited with code ${code}`));
+  if (inOpenQuestions && currentQuestionLine !== null) {
+    violations.push({
+      file: filePath,
+      message: "Question has no options listed beneath it",
+      line: currentQuestionLine
     });
-    proc.on("error", reject);
-  });
+  }
+  return violations;
 }
-
-// lib/claude/event-parser.ts
-function* parseRawEvent(raw) {
-  if (raw.type === "stream_event") {
-    const event = raw.event;
-    if (event?.delta?.type === "text_delta" && event.delta.text) {
-      yield { type: "text_delta", text: event.delta.text };
+var SEMANTIC_RULES = [
+  {
+    section: "## Goals",
+    requiredPath: "/.dust/goals/",
+    description: "goal"
+  },
+  {
+    section: "## Blocked By",
+    requiredPath: "/.dust/tasks/",
+    description: "task"
+  }
+];
+function validateSemanticLinks(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;
     }
-  } else if (raw.type === "assistant") {
-    const msg = raw;
-    const content = msg.message?.content ?? [];
-    yield { type: "assistant_message", content };
-    for (const block of content) {
-      if (block.type === "tool_use" && block.id && block.name && block.input) {
-        yield {
-          type: "tool_use",
-          id: block.id,
-          name: block.name,
-          input: block.input
-        };
+    const rule = SEMANTIC_RULES.find((r) => r.section === currentSection);
+    if (!rule)
+      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);
     }
-  } else if (raw.type === "user") {
-    const msg = raw;
-    for (const block of msg.message?.content ?? []) {
-      if (block.type === "tool_result" && block.tool_use_id) {
-        yield {
-          type: "tool_result",
-          toolUseId: block.tool_use_id,
-          content: typeof block.content === "string" ? block.content : JSON.stringify(block.content)
+  }
+  return violations;
+}
+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;
     }
-  } else if (raw.type === "result") {
-    const r = raw;
-    yield {
-      type: "result",
-      subtype: r.subtype ?? "success",
-      result: r.result,
-      error: r.error,
-      cost_usd: r.total_cost_usd ?? r.cost_usd ?? 0,
-      duration_ms: r.duration_ms ?? 0,
-      num_turns: r.num_turns ?? 0,
-      session_id: r.session_id ?? ""
-    };
   }
+  return null;
 }
-
-// lib/claude/tool-formatters.ts
-var DIVIDER = "────────────────────────────────";
-function formatWrite(input) {
-  const filePath = input.file_path;
-  const content = input.content;
-  const others = getUnrecognizedArgs(input, ["file_path", "content"]);
-  const lines = [];
-  lines.push(`\uD83D\uDD27 Write: ${filePath ?? "(unknown)"}`);
-  lines.push(DIVIDER);
-  if (content !== undefined) {
-    for (const line of content.split(`
-`)) {
-      lines.push(line);
+function validateGoalHierarchySections(filePath, content) {
+  const violations = [];
+  for (const heading of REQUIRED_GOAL_HEADINGS) {
+    if (!content.includes(heading)) {
+      violations.push({
+        file: filePath,
+        message: `Missing required heading: "${heading}"`
+      });
     }
   }
-  lines.push(DIVIDER);
-  appendOtherArgs(lines, others);
-  return lines;
+  return violations;
 }
-function formatEdit(input) {
-  const filePath = input.file_path;
-  const oldString = input.old_string;
-  const newString = input.new_string;
-  const others = getUnrecognizedArgs(input, [
-    "file_path",
-    "old_string",
-    "new_string",
-    "replace_all"
-  ]);
-  const lines = [];
-  lines.push(`\uD83D\uDD27 Edit: ${filePath ?? "(unknown)"}`);
-  lines.push("Replace:");
-  lines.push(DIVIDER);
-  if (oldString !== undefined) {
-    for (const line of oldString.split(`
-`)) {
-      lines.push(line);
+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);
     }
   }
-  lines.push(DIVIDER);
-  lines.push("With:");
-  lines.push(DIVIDER);
-  if (newString !== undefined) {
-    for (const line of newString.split(`
-`)) {
-      lines.push(line);
+  return violations;
+}
+function extractGoalRelationships(filePath, content) {
+  const lines = content.split(`
+`);
+  const fileDir = dirname3(filePath);
+  const parentGoals = [];
+  const subGoals = [];
+  let currentSection = null;
+  for (const line of lines) {
+    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("#") && !linkTarget.startsWith("http://") && !linkTarget.startsWith("https://")) {
+        const targetPath = linkTarget.split("#")[0];
+        const resolvedPath = resolve(fileDir, targetPath);
+        if (resolvedPath.includes("/.dust/goals/")) {
+          if (currentSection === "## Parent Goal") {
+            parentGoals.push(resolvedPath);
+          } else {
+            subGoals.push(resolvedPath);
+          }
+        }
+      }
+      match = linkPattern.exec(line);
     }
   }
-  lines.push(DIVIDER);
-  appendOtherArgs(lines, others);
-  return lines;
+  return { filePath, parentGoals, subGoals };
 }
-function formatRead(input) {
-  const filePath = input.file_path;
-  const offset = input.offset;
-  const limit = input.limit;
-  const others = getUnrecognizedArgs(input, ["file_path", "offset", "limit"]);
-  const lines = [];
-  let lineRange = "";
-  if (offset !== undefined || limit !== undefined) {
-    const start = offset ?? 1;
-    const end = limit !== undefined ? start + limit - 1 : undefined;
-    lineRange = end !== undefined ? ` (lines ${start}-${end})` : ` (from line ${start})`;
+function validateBidirectionalLinks(allGoalRelationships) {
+  const violations = [];
+  const relationshipMap = new Map;
+  for (const rel of allGoalRelationships) {
+    relationshipMap.set(rel.filePath, rel);
   }
-  lines.push(`\uD83D\uDD27 Read: ${filePath ?? "(unknown)"}${lineRange}`);
-  appendOtherArgs(lines, others);
-  return lines;
-}
-function formatBash(input) {
-  const command = input.command;
-  const description = input.description;
-  const others = getUnrecognizedArgs(input, [
-    "command",
-    "description",
-    "timeout",
-    "run_in_background",
-    "dangerouslyDisableSandbox",
-    "_simulatedSedEdit"
-  ]);
-  const lines = [];
-  const header = description ?? "Run command";
-  lines.push(`\uD83D\uDD27 Bash: ${header}`);
-  if (command !== undefined) {
-    lines.push(`$ ${command}`);
+  for (const rel of allGoalRelationships) {
+    for (const parentPath of rel.parentGoals) {
+      const parentRel = relationshipMap.get(parentPath);
+      if (parentRel && !parentRel.subGoals.includes(rel.filePath)) {
+        violations.push({
+          file: rel.filePath,
+          message: `Parent goal "${parentPath}" does not list this goal as a sub-goal`
+        });
+      }
+    }
+    for (const subGoalPath of rel.subGoals) {
+      const subGoalRel = relationshipMap.get(subGoalPath);
+      if (subGoalRel && !subGoalRel.parentGoals.includes(rel.filePath)) {
+        violations.push({
+          file: rel.filePath,
+          message: `Sub-goal "${subGoalPath}" does not list this goal as its parent`
+        });
+      }
+    }
   }
-  appendOtherArgs(lines, others);
-  return lines;
+  return violations;
 }
-function formatTodoWrite(input) {
-  const todos = input.todos;
-  const others = getUnrecognizedArgs(input, ["todos"]);
-  const lines = [];
-  const count = todos?.length ?? 0;
-  lines.push(`\uD83D\uDD27 TodoWrite: ${count} item${count === 1 ? "" : "s"}`);
-  if (todos) {
-    for (const todo of todos) {
-      const icon = todo.status === "completed" ? "☑" : "☐";
-      lines.push(`${icon} ${todo.content}`);
+function validateNoCycles(allGoalRelationships) {
+  const violations = [];
+  const relationshipMap = new Map;
+  for (const rel of allGoalRelationships) {
+    relationshipMap.set(rel.filePath, rel);
+  }
+  for (const rel of allGoalRelationships) {
+    const visited = new Set;
+    const path = [];
+    let current = rel.filePath;
+    while (current) {
+      if (visited.has(current)) {
+        const cycleStart = path.indexOf(current);
+        const cyclePath = path.slice(cycleStart).concat(current);
+        violations.push({
+          file: rel.filePath,
+          message: `Cycle detected in goal hierarchy: ${cyclePath.join(" -> ")}`
+        });
+        break;
+      }
+      visited.add(current);
+      path.push(current);
+      const currentRel = relationshipMap.get(current);
+      if (currentRel && currentRel.parentGoals.length > 0) {
+        current = currentRel.parentGoals[0];
+      } else {
+        current = null;
+      }
     }
   }
-  appendOtherArgs(lines, others);
-  return lines;
+  return violations;
 }
-function formatGrep(input) {
-  const pattern = input.pattern;
-  const path = input.path;
-  const glob = input.glob;
-  const type = input.type;
-  const others = getUnrecognizedArgs(input, [
-    "pattern",
-    "path",
-    "glob",
-    "type",
-    "output_mode",
-    "context",
-    "-A",
-    "-B",
-    "-C",
-    "-i",
-    "-n",
-    "head_limit",
-    "offset",
-    "multiline"
-  ]);
-  const lines = [];
-  const location = path ?? ".";
-  let filter = "";
-  if (glob) {
-    filter = ` (${glob})`;
-  } else if (type) {
-    filter = ` (type: ${type})`;
+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;
   }
-  lines.push(`\uD83D\uDD27 Grep: "${pattern ?? ""}" in ${location}${filter}`);
-  appendOtherArgs(lines, others);
-  return lines;
-}
-function formatGlob(input) {
-  const pattern = input.pattern;
-  const path = input.path;
-  const others = getUnrecognizedArgs(input, ["pattern", "path"]);
-  const lines = [];
-  const location = path ?? ".";
-  lines.push(`\uD83D\uDD27 Glob: ${pattern ?? ""} in ${location}`);
-  appendOtherArgs(lines, others);
-  return lines;
 }
-function formatTask(input) {
-  const description = input.description;
-  const subagentType = input.subagent_type;
-  const prompt = input.prompt;
-  const others = getUnrecognizedArgs(input, [
-    "description",
-    "subagent_type",
-    "prompt",
-    "model",
-    "max_turns",
-    "resume",
-    "run_in_background"
-  ]);
-  const lines = [];
-  const header = description ?? subagentType ?? "task";
-  lines.push(`\uD83D\uDD27 Task: ${header}`);
-  if (prompt !== undefined) {
-    const truncated = prompt.length > 100 ? `${prompt.slice(0, 100)}...` : prompt;
-    lines.push(`"${truncated}"`);
+async function lintMarkdown(dependencies) {
+  const { context, fileSystem, globScanner: glob } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  const dustScan = await safeScanDir(glob, dustPath);
+  if (!dustScan.exists) {
+    context.stderr("Error: .dust directory not found");
+    context.stderr("Run 'dust init' to initialize a Dust repository");
+    return { exitCode: 1 };
   }
-  appendOtherArgs(lines, others);
-  return lines;
-}
-function formatFallback(name, input) {
-  const lines = [];
-  lines.push(`\uD83D\uDD27 Tool: ${name}`);
-  lines.push(`Input: ${JSON.stringify(input, null, 2)}`);
-  return lines;
-}
-var formatters = {
-  Write: formatWrite,
-  Edit: formatEdit,
-  Read: formatRead,
-  Bash: formatBash,
-  TodoWrite: formatTodoWrite,
-  Grep: formatGrep,
-  Glob: formatGlob,
-  Task: formatTask
-};
-function formatToolUse(name, input) {
-  const formatter = formatters[name];
-  if (formatter) {
-    return formatter(input);
+  const dustFiles = dustScan.files;
+  const violations = [];
+  context.stdout("Validating links in .dust/...");
+  for (const file of dustFiles) {
+    if (!file.endsWith(".md"))
+      continue;
+    const filePath = `${dustPath}/${file}`;
+    try {
+      const content = await fileSystem.readFile(filePath);
+      violations.push(...validateLinks(filePath, content, fileSystem));
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
   }
-  return formatFallback(name, input);
-}
-function getUnrecognizedArgs(input, knownKeys) {
-  const others = {};
-  for (const key of Object.keys(input)) {
-    if (!knownKeys.includes(key)) {
-      others[key] = input[key];
+  const contentDirs = ["goals", "facts", "ideas", "tasks"];
+  context.stdout("Validating content files...");
+  for (const dir of contentDirs) {
+    const dirPath = `${dustPath}/${dir}`;
+    const { files } = await safeScanDir(glob, dirPath);
+    for (const file of files) {
+      if (!file.endsWith(".md"))
+        continue;
+      const filePath = `${dirPath}/${file}`;
+      let content;
+      try {
+        content = await fileSystem.readFile(filePath);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+      const openingSentenceViolation = validateOpeningSentence(filePath, content);
+      if (openingSentenceViolation) {
+        violations.push(openingSentenceViolation);
+      }
+      const openingSentenceLengthViolation = validateOpeningSentenceLength(filePath, content);
+      if (openingSentenceLengthViolation) {
+        violations.push(openingSentenceLengthViolation);
+      }
+      const titleFilenameViolation = validateTitleFilenameMatch(filePath, content);
+      if (titleFilenameViolation) {
+        violations.push(titleFilenameViolation);
+      }
     }
   }
-  return others;
-}
-function appendOtherArgs(lines, others) {
-  if (Object.keys(others).length > 0) {
-    lines.push("");
-    lines.push(`(Other arguments: ${JSON.stringify(others)})`);
-  }
-}
-
-// lib/claude/streamer.ts
-var DIVIDER2 = "────────────────────────────────";
-async function streamEvents(events, sink, onRawEvent) {
-  let hadTextOutput = false;
-  for await (const raw of events) {
-    onRawEvent?.(raw);
-    for (const event of parseRawEvent(raw)) {
-      processEvent(event, sink, { hadTextOutput });
-      if (event.type === "text_delta") {
-        hadTextOutput = true;
-      } else if (event.type === "tool_use") {
-        hadTextOutput = false;
+  const ideasPath = `${dustPath}/ideas`;
+  const { files: ideaFiles } = await safeScanDir(glob, ideasPath);
+  if (ideaFiles.length > 0) {
+    context.stdout("Validating idea files in .dust/ideas/...");
+    for (const file of ideaFiles) {
+      if (!file.endsWith(".md"))
+        continue;
+      const filePath = `${ideasPath}/${file}`;
+      let content;
+      try {
+        content = await fileSystem.readFile(filePath);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          continue;
+        }
+        throw error;
       }
+      violations.push(...validateIdeaOpenQuestions(filePath, content));
     }
   }
-}
-function processEvent(event, sink, state) {
-  switch (event.type) {
-    case "text_delta":
-      sink.write(event.text);
-      break;
-    case "tool_use":
-      if (state.hadTextOutput) {
-        sink.line("");
-        sink.line("");
+  const tasksPath = `${dustPath}/tasks`;
+  const { files: taskFiles } = await safeScanDir(glob, tasksPath);
+  if (taskFiles.length > 0) {
+    context.stdout("Validating task files in .dust/tasks/...");
+    for (const file of taskFiles) {
+      if (!file.endsWith(".md"))
+        continue;
+      const filePath = `${tasksPath}/${file}`;
+      let content;
+      try {
+        content = await fileSystem.readFile(filePath);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          continue;
+        }
+        throw error;
       }
-      for (const line of formatToolUse(event.name, event.input)) {
-        sink.line(line);
+      const filenameViolation = validateFilename(filePath);
+      if (filenameViolation) {
+        violations.push(filenameViolation);
       }
-      break;
-    case "tool_result":
-      sink.line("Result:");
-      sink.line(DIVIDER2);
-      sink.line(event.content);
-      sink.line(DIVIDER2);
-      sink.line("");
-      break;
-    case "result":
-      sink.line("");
-      sink.line(`\uD83C\uDFC1 Done: ${event.subtype}, ${event.num_turns} turns, $${event.cost_usd.toFixed(4)}`);
-      break;
-    case "assistant_message":
-      break;
+      violations.push(...validateTaskHeadings(filePath, content));
+      violations.push(...validateSemanticLinks(filePath, content));
+      const imperativeViolation = validateImperativeOpeningSentence(filePath, content);
+      if (imperativeViolation) {
+        violations.push(imperativeViolation);
+      }
+      const ideaTransitionViolation = validateIdeaTransitionTitle(filePath, content, ideasPath, fileSystem);
+      if (ideaTransitionViolation) {
+        violations.push(ideaTransitionViolation);
+      }
+    }
+  }
+  const goalsPath = `${dustPath}/goals`;
+  const { files: goalFiles } = await safeScanDir(glob, goalsPath);
+  if (goalFiles.length > 0) {
+    context.stdout("Validating goal hierarchy in .dust/goals/...");
+    const allGoalRelationships = [];
+    for (const file of goalFiles) {
+      if (!file.endsWith(".md"))
+        continue;
+      const filePath = `${goalsPath}/${file}`;
+      let content;
+      try {
+        content = await fileSystem.readFile(filePath);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          continue;
+        }
+        throw error;
+      }
+      violations.push(...validateGoalHierarchySections(filePath, content));
+      violations.push(...validateGoalHierarchyLinks(filePath, content));
+      allGoalRelationships.push(extractGoalRelationships(filePath, content));
+    }
+    violations.push(...validateBidirectionalLinks(allGoalRelationships));
+    violations.push(...validateNoCycles(allGoalRelationships));
+  }
+  if (violations.length === 0) {
+    context.stdout("All validations passed!");
+    return { exitCode: 0 };
+  }
+  context.stderr(`Found ${violations.length} violation(s):`);
+  context.stderr("");
+  for (const v of violations) {
+    const location = v.line ? `:${v.line}` : "";
+    context.stderr(`  ${v.file}${location}`);
+    context.stderr(`    ${v.message}`);
   }
+  return { exitCode: 1 };
 }
-function createStdoutSink() {
+
+// lib/cli/commands/check.ts
+var DEFAULT_CHECK_TIMEOUT_MS = 13000;
+async function runSingleCheck(check, cwd, runner) {
+  const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
+  const startTime = Date.now();
+  const result = await runner.run(check.command, cwd, timeoutMs);
+  const durationMs = Date.now() - startTime;
   return {
-    write: (text) => process.stdout.write(text),
-    line: (text) => console.log(text)
+    name: check.name,
+    command: check.command,
+    exitCode: result.exitCode,
+    output: result.output,
+    hints: check.hints,
+    durationMs,
+    timedOut: result.timedOut,
+    timeoutSeconds: timeoutMs / 1000
   };
 }
-
-// lib/claude/run.ts
-var defaultRunnerDependencies = {
-  spawnClaudeCode,
-  createStdoutSink,
-  streamEvents
-};
-async function run(prompt, options = {}, dependencies = defaultRunnerDependencies) {
-  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.spawnClaudeCode(prompt, spawnOptions);
-  const sink = dependencies.createStdoutSink();
-  await dependencies.streamEvents(events, sink, onRawEvent);
+async function runConfiguredChecks(checks, cwd, runner) {
+  const promises = checks.map((check) => runSingleCheck(check, cwd, runner));
+  return Promise.all(promises);
 }
-
-// lib/cli/commands/next.ts
-function extractBlockedBy(content) {
-  const blockedByMatch = content.match(/^## Blocked By\s*\n([\s\S]*?)(?=\n## |\n*$)/m);
-  if (!blockedByMatch) {
-    return [];
-  }
-  const section = blockedByMatch[1].trim();
-  if (section === "(none)") {
-    return [];
-  }
-  const linkPattern = /\[.*?\]\(([^)]+\.md)\)/g;
-  const blockers = [];
-  let match = linkPattern.exec(section);
-  while (match !== null) {
-    blockers.push(match[1]);
-    match = linkPattern.exec(section);
+async function runConfiguredChecksSerially(checks, cwd, runner) {
+  const results = [];
+  for (const check of checks) {
+    results.push(await runSingleCheck(check, cwd, runner));
   }
-  return blockers;
+  return results;
 }
-async function findUnblockedTasks(cwd, fileSystem) {
-  const dustPath = `${cwd}/.dust`;
-  if (!fileSystem.exists(dustPath)) {
-    return { error: ".dust directory not found", tasks: [] };
+async function runValidationCheck(dependencies) {
+  const outputLines = [];
+  const bufferedContext = {
+    cwd: dependencies.context.cwd,
+    stdout: (msg) => outputLines.push(msg),
+    stderr: (msg) => outputLines.push(msg)
+  };
+  const startTime = Date.now();
+  const result = await lintMarkdown({
+    ...dependencies,
+    context: bufferedContext,
+    arguments: []
+  });
+  const durationMs = Date.now() - startTime;
+  return {
+    name: "lint markdown",
+    command: "dust lint markdown",
+    exitCode: result.exitCode,
+    output: outputLines.join(`
+`),
+    isBuiltIn: true,
+    durationMs
+  };
+}
+function displayResults(results, context) {
+  const passed = results.filter((r) => r.exitCode === 0);
+  const failed = results.filter((r) => r.exitCode !== 0);
+  for (const result of results) {
+    if (result.timedOut) {
+      context.stdout(`✗ ${result.name} [timed out after ${result.timeoutSeconds}s]`);
+    } else {
+      const timing = result.durationMs !== undefined && result.durationMs >= 1000 ? ` [${(result.durationMs / 1000).toFixed(1)}s]` : "";
+      if (result.exitCode === 0) {
+        context.stdout(`✓ ${result.name}${timing}`);
+      } else {
+        context.stdout(`✗ ${result.name}${timing}`);
+      }
+    }
   }
-  const tasksPath = `${dustPath}/tasks`;
-  if (!fileSystem.exists(tasksPath)) {
-    return { tasks: [] };
+  for (const result of failed) {
+    context.stdout("");
+    context.stdout(`> ${result.command}`);
+    if (result.timedOut) {
+      context.stdout(`Note: This check was killed after ${result.timeoutSeconds}s. To configure a different timeout, set "timeoutMilliseconds" in the check configuration in .dust/config/settings.json`);
+    }
+    if (result.output.trim()) {
+      context.stdout(result.output.trimEnd());
+    }
+    if (result.hints && result.hints.length > 0) {
+      context.stdout("");
+      context.stdout(`Hints for fixing '${result.name}':`);
+      for (const hint of result.hints) {
+        context.stdout(`  - ${hint}`);
+      }
+    }
   }
-  const files = await fileSystem.readdir(tasksPath);
-  const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
-  if (mdFiles.length === 0) {
-    return { tasks: [] };
+  context.stdout("");
+  const indicator = failed.length > 0 ? "✗" : "✓";
+  context.stdout(`${indicator} ${passed.length}/${results.length} checks passed`);
+  return failed.length > 0 ? 1 : 0;
+}
+async function check(dependencies, shellRunner = defaultShellRunner) {
+  const {
+    arguments: commandArguments,
+    context,
+    fileSystem,
+    settings
+  } = dependencies;
+  const serial = commandArguments.includes("--serial");
+  if (!settings.checks || settings.checks.length === 0) {
+    context.stderr("Error: No checks configured in .dust/config/settings.json");
+    context.stderr("");
+    context.stderr("Add checks to your settings.json:");
+    context.stderr("  {");
+    context.stderr('    "checks": [');
+    context.stderr('      { "name": "lint", "command": "npm run lint" },');
+    context.stderr('      { "name": "test", "command": "npm test" }');
+    context.stderr("    ]");
+    context.stderr("  }");
+    return { exitCode: 1 };
   }
-  const existingTasks = new Set(mdFiles);
-  const tasks = [];
-  for (const file of mdFiles) {
-    const filePath = `${tasksPath}/${file}`;
-    const content = await fileSystem.readFile(filePath);
-    const blockers = extractBlockedBy(content);
-    const hasIncompleteBlocker = blockers.some((blocker) => existingTasks.has(blocker));
-    if (!hasIncompleteBlocker) {
-      const title = extractTitle(content);
-      const openingSentence = extractOpeningSentence(content);
-      const relativePath = `.dust/tasks/${file}`;
-      tasks.push({ path: relativePath, title, openingSentence });
+  const dustPath = `${context.cwd}/.dust`;
+  const hasDustDir = fileSystem.exists(dustPath);
+  if (serial) {
+    const results2 = [];
+    if (hasDustDir) {
+      results2.push(await runValidationCheck(dependencies));
     }
+    const configuredResults = await runConfiguredChecksSerially(settings.checks, context.cwd, shellRunner);
+    results2.push(...configuredResults);
+    const exitCode2 = displayResults(results2, context);
+    return { exitCode: exitCode2 };
   }
-  return { tasks };
-}
-function printTaskList(context, tasks) {
-  const colors = getColors();
-  context.stdout("\uD83D\uDCCB Next tasks");
-  context.stdout("");
-  for (const task of tasks) {
-    const parts = task.path.split("/");
-    const displayTitle = task.title || parts[parts.length - 1].replace(".md", "");
-    context.stdout(`${colors.bold}# ${displayTitle}${colors.reset}`);
-    if (task.openingSentence) {
-      context.stdout(`${colors.dim}${task.openingSentence}${colors.reset}`);
+  const checkPromises = [];
+  if (hasDustDir) {
+    checkPromises.push(runValidationCheck(dependencies));
+  }
+  checkPromises.push(runConfiguredChecks(settings.checks, context.cwd, shellRunner));
+  const promiseResults = await Promise.all(checkPromises);
+  const results = [];
+  for (const result of promiseResults) {
+    if (Array.isArray(result)) {
+      results.push(...result);
+    } else {
+      results.push(result);
     }
-    context.stdout(`${colors.cyan}→ ${task.path}${colors.reset}`);
-    context.stdout("");
   }
+  const exitCode = displayResults(results, context);
+  return { exitCode };
 }
-async function next(dependencies) {
-  const { context, fileSystem } = dependencies;
-  const result = await findUnblockedTasks(context.cwd, fileSystem);
-  if (result.error) {
-    context.stderr(`Error: ${result.error}`);
-    context.stderr("Run 'dust init' to initialize a Dust repository");
+
+// lib/cli/commands/focus.ts
+async function focus(dependencies) {
+  const { context, settings } = dependencies;
+  const objective = dependencies.arguments.join(" ").trim();
+  if (!objective) {
+    context.stderr("Error: No objective provided");
+    context.stderr('Usage: dust focus "your objective here"');
     return { exitCode: 1 };
   }
-  if (result.tasks.length === 0) {
-    return { exitCode: 0 };
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(`\uD83C\uDFAF Focus: ${objective}`);
+  context.stdout("");
+  const steps = [];
+  let step = 1;
+  steps.push(`${step}. Run \`${vars.bin} check\` to verify the project is in a good state`);
+  step++;
+  steps.push(`${step}. Implement the task`);
+  step++;
+  if (!hooksInstalled) {
+    steps.push(`${step}. Run \`${vars.bin} check\` before committing`);
+    step++;
   }
-  printTaskList(context, result.tasks);
+  steps.push(`${step}. Create a single atomic commit that includes:`, "   - All implementation changes", "   - Deletion of the completed task file", "   - Updates to any facts that changed", "   - Deletion of the idea file that spawned this task (if remaining scope exists, create new ideas for it)", "", '   Use the task title as the commit message. Task titles are written in imperative form, which is the recommended style for git commit messages. Do not add prefixes like "Complete task:" - use the title directly.', "", '   Example: If the task title is "Add validation for user input", the commit message should be:', "   ```", "   Add validation for user input", "   ```", "");
+  step++;
+  steps.push(`${step}. Push your commit to the remote repository`);
+  steps.push("");
+  steps.push("Keep your change small and focused. One task, one commit.");
+  context.stdout(steps.join(`
+`));
   return { exitCode: 0 };
 }
 
-// lib/cli/commands/loop.ts
-function formatEvent(event) {
-  switch (event.type) {
-    case "loop.warning":
-      return "⚠️  WARNING: This command skips all permission checks. Only use in a sandbox environment!";
-    case "loop.started":
-      return `\uD83D\uDD04 Starting dust loop claude (max ${event.maxIterations} iterations)...`;
-    case "loop.syncing":
-      return "\uD83C\uDF0D Syncing with remote";
-    case "loop.sync_skipped":
-      return `Note: git pull skipped (${event.reason})`;
-    case "loop.checking_tasks":
-      return null;
-    case "loop.no_tasks":
-      return `\uD83D\uDE34 No tasks available. Sleeping...
-`;
-    case "loop.tasks_found":
-      return `✨ Found a task. Going to work!
-`;
-    case "claude.started":
-      return "\uD83E\uDD16 Starting Claude...";
-    case "claude.ended":
-      return event.success ? "\uD83E\uDD16 Claude session ended (success)" : `\uD83E\uDD16 Claude session ended (error: ${event.error})`;
-    case "claude.raw_event":
-      return null;
-    case "loop.iteration_complete":
-      return `\uD83D\uDCCB Completed iteration ${event.iteration}/${event.maxIterations}`;
-    case "loop.ended":
-      return `\uD83C\uDFC1 Reached max iterations (${event.maxIterations}). Exiting.`;
-  }
-}
-async function defaultPostEvent(url, payload) {
-  await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify(payload)
-  });
-}
-function createDefaultDependencies() {
-  return {
-    spawn: nodeSpawn2,
-    run,
-    sleep: (ms) => new Promise((resolve2) => setTimeout(resolve2, ms)),
-    postEvent: defaultPostEvent
-  };
-}
-function createEventPoster(eventsUrl, sessionId, postEvent, onError, getAgentSessionId) {
-  let sequence = 0;
-  return (event) => {
-    if (!eventsUrl)
-      return;
-    sequence++;
-    const payload = {
-      sequence,
-      timestamp: new Date().toISOString(),
-      sessionId,
-      event
-    };
-    if (event.type.startsWith("claude.")) {
-      payload.agentType = "claude";
-      const agentSessionId = getAgentSessionId?.();
-      if (agentSessionId) {
-        payload.agentSessionId = agentSessionId;
-      }
-    }
-    postEvent(eventsUrl, payload).catch(onError);
-  };
-}
-var SLEEP_INTERVAL_MS = 30000;
-var DEFAULT_MAX_ITERATIONS = 10;
-async function gitPull(cwd, spawn2) {
-  return new Promise((resolve2) => {
-    const proc = spawn2("git", ["pull"], {
-      cwd,
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    let stderr = "";
-    proc.stderr?.on("data", (data) => {
-      stderr += data.toString();
-    });
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve2({ success: true });
-      } else {
-        resolve2({ success: false, message: stderr.trim() || "git pull failed" });
-      }
-    });
-    proc.on("error", (error) => {
-      resolve2({ success: false, message: error.message });
-    });
-  });
+// lib/cli/commands/help.ts
+function generateHelpText(settings) {
+  return loadTemplate("help", { bin: settings.dustCommand });
 }
-async function hasAvailableTasks(dependencies) {
-  let hasOutput = false;
-  const captureContext = {
-    ...dependencies.context,
-    stdout: () => {
-      hasOutput = true;
-    }
-  };
-  await next({ ...dependencies, context: captureContext });
-  return hasOutput;
+async function help(dependencies) {
+  dependencies.context.stdout(generateHelpText(dependencies.settings));
+  return { exitCode: 0 };
 }
-async function runOneIteration(dependencies, loopDependencies, emit, options = {}) {
-  const { context } = dependencies;
-  const { spawn: spawn2, run: run2 } = loopDependencies;
-  const { onRawEvent } = options;
-  emit({ type: "loop.syncing" });
-  const pullResult = await gitPull(context.cwd, spawn2);
-  if (!pullResult.success) {
-    emit({
-      type: "loop.sync_skipped",
-      reason: pullResult.message ?? "unknown error"
-    });
-    emit({ type: "claude.started" });
-    const prompt = `git pull failed with the following error:
 
-${pullResult.message}
-
-Please resolve this issue. Common approaches:
-1. If there are merge conflicts, resolve them
-2. If local commits need to be rebased, use git rebase
-3. After resolving, commit any changes and push to remote
+// lib/cli/commands/implement-task.ts
+async function implementTask(dependencies) {
+  const { context, settings } = dependencies;
+  const hooksInstalled = await manageGitHooks(dependencies);
+  const vars = templateVariables(settings, hooksInstalled);
+  context.stdout(`Run \`${vars.bin} focus "<task name>"\` to set your focus and see implementation instructions.`);
+  return { exitCode: 0 };
+}
 
-Make sure the repository is in a clean state and synced with remote before finishing.`;
-    try {
-      await run2(prompt, {
-        spawnOptions: {
-          cwd: context.cwd,
-          dangerouslySkipPermissions: true,
-          env: { DUST_UNATTENDED: "1" }
-        },
-        onRawEvent
-      });
-      emit({ type: "claude.ended", success: true });
-      return "resolved_pull_conflict";
-    } catch (error) {
-      const errorMessage = error instanceof Error ? error.message : String(error);
-      context.stderr(`Claude failed to resolve git pull conflict: ${errorMessage}`);
-      emit({ type: "claude.ended", success: false, error: errorMessage });
-    }
+// lib/cli/commands/init.ts
+var DUST_DIRECTORIES = ["goals", "ideas", "tasks", "facts", "config"];
+function generateSettings(cwd, fileSystem) {
+  const dustCommand = detectDustCommand(cwd, fileSystem);
+  const testCommand = detectTestCommand(cwd, fileSystem);
+  const checks = [];
+  if (testCommand) {
+    checks.push({ name: "test", command: testCommand });
   }
-  emit({ type: "loop.checking_tasks" });
-  const hasTasks = await hasAvailableTasks(dependencies);
-  if (!hasTasks) {
-    emit({ type: "loop.no_tasks" });
-    return "no_tasks";
+  return { dustCommand, checks };
+}
+var USE_DUST_FACT = `# Use dust for planning
+
+This project uses [dust](https://github.com/joshski/dust) for planning and documentation.
+`;
+async function init(dependencies) {
+  const { context, fileSystem } = dependencies;
+  const colors = getColors();
+  const dustPath = `${context.cwd}/.dust`;
+  const dustCommand = detectDustCommand(context.cwd, fileSystem);
+  const agentInstruction = `Always immediately run \`${dustCommand} agent\` when you start working in this repository.`;
+  await fileSystem.mkdir(dustPath, { recursive: true });
+  for (const dir of DUST_DIRECTORIES) {
+    await fileSystem.mkdir(`${dustPath}/${dir}`, { recursive: true });
   }
-  emit({ type: "loop.tasks_found" });
-  emit({ type: "claude.started" });
+  let dustDirCreated = false;
   try {
-    await run2("go", {
-      spawnOptions: {
-        cwd: context.cwd,
-        dangerouslySkipPermissions: true,
-        env: { DUST_UNATTENDED: "1" }
-      },
-      onRawEvent
-    });
-    emit({ type: "claude.ended", success: true });
-    return "ran_claude";
+    await fileSystem.writeFile(`${dustPath}/facts/use-dust-for-planning.md`, USE_DUST_FACT, { flag: "wx" });
+    dustDirCreated = true;
   } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    context.stderr(`Claude exited with error: ${errorMessage}`);
-    emit({ type: "claude.ended", success: false, error: errorMessage });
-    return "claude_error";
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
   }
-}
-function parseMaxIterations(commandArguments) {
-  if (commandArguments.length === 0) {
-    return DEFAULT_MAX_ITERATIONS;
+  try {
+    const settings = generateSettings(context.cwd, fileSystem);
+    await fileSystem.writeFile(`${dustPath}/config/settings.json`, `${JSON.stringify(settings, null, 2)}
+`, { flag: "wx" });
+  } catch (error) {
+    if (error.code !== "EEXIST") {
+      throw error;
+    }
   }
-  const parsed = Number.parseInt(commandArguments[0], 10);
-  if (Number.isNaN(parsed) || parsed <= 0) {
-    return DEFAULT_MAX_ITERATIONS;
+  if (dustDirCreated) {
+    context.stdout(`${colors.green}✨ Initialized${colors.reset} Dust repository in ${colors.cyan}.dust/${colors.reset}`);
+    context.stdout(`${colors.green}\uD83D\uDCC1 Created directories:${colors.reset} ${colors.dim}${DUST_DIRECTORIES.join(", ")}${colors.reset}`);
+    context.stdout(`${colors.green}\uD83D\uDCC4 Created initial fact:${colors.reset} ${colors.cyan}.dust/facts/use-dust-for-planning.md${colors.reset}`);
+    context.stdout(`${colors.green}⚙️  Created settings:${colors.reset} ${colors.cyan}.dust/config/settings.json${colors.reset}`);
+  } else {
+    context.stdout(`${colors.yellow}\uD83D\uDCE6 Note:${colors.reset} ${colors.cyan}.dust${colors.reset} directory already exists, skipping creation`);
   }
-  return parsed;
-}
-async function loopClaude(dependencies, loopDependencies = createDefaultDependencies()) {
-  const { context, settings } = dependencies;
-  const { postEvent } = loopDependencies;
-  const maxIterations = parseMaxIterations(dependencies.arguments);
-  const eventsUrl = settings.eventsUrl;
-  const sessionId = crypto.randomUUID();
-  let agentSessionId;
-  const postEventFn = createEventPoster(eventsUrl, sessionId, postEvent, (error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    context.stderr(`Event POST failed: ${message}`);
-  }, () => agentSessionId);
-  const emit = (event) => {
-    const formatted = formatEvent(event);
-    if (formatted !== null) {
-      context.stdout(formatted);
+  const claudeMdPath = `${context.cwd}/CLAUDE.md`;
+  try {
+    const claudeContent = loadTemplate("claude-md", { dustCommand });
+    await fileSystem.writeFile(claudeMdPath, claudeContent, { flag: "wx" });
+    context.stdout(`${colors.green}\uD83D\uDCC4 Created${colors.reset} ${colors.cyan}CLAUDE.md${colors.reset} with agent instructions`);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      context.stdout(`${colors.yellow}⚠️  Warning:${colors.reset} ${colors.cyan}CLAUDE.md${colors.reset} already exists. Consider adding: ${colors.dim}"${agentInstruction}"${colors.reset}`);
+    } else {
+      throw error;
     }
-    postEventFn(event);
-  };
-  emit({ type: "loop.warning" });
-  emit({ type: "loop.started", maxIterations });
-  context.stdout("   Press Ctrl+C to stop");
+  }
+  const agentsMdPath = `${context.cwd}/AGENTS.md`;
+  try {
+    const agentsContent = loadTemplate("agents-md", { dustCommand });
+    await fileSystem.writeFile(agentsMdPath, agentsContent, { flag: "wx" });
+    context.stdout(`${colors.green}\uD83D\uDCC4 Created${colors.reset} ${colors.cyan}AGENTS.md${colors.reset} with agent instructions`);
+  } catch (error) {
+    if (error.code === "EEXIST") {
+      context.stdout(`${colors.yellow}⚠️  Warning:${colors.reset} ${colors.cyan}AGENTS.md${colors.reset} already exists. Consider adding: ${colors.dim}"${agentInstruction}"${colors.reset}`);
+    } else {
+      throw error;
+    }
+  }
+  const runner = dustCommand.split(" ")[0];
   context.stdout("");
-  let completedIterations = 0;
-  const iterationOptions = {};
-  if (eventsUrl) {
-    iterationOptions.onRawEvent = (rawEvent) => {
-      if (typeof rawEvent.session_id === "string" && rawEvent.session_id) {
-        agentSessionId = rawEvent.session_id;
+  context.stdout(`${colors.bold}\uD83D\uDE80 Next steps:${colors.reset} Commit the changes if you are happy, then get planning!`);
+  context.stdout("");
+  context.stdout(`${colors.dim}If this is a new repository, you can start adding ideas or tasks right away:${colors.reset}`);
+  context.stdout(`   ${colors.cyan}>${colors.reset} ${runner} claude "Idea: friendly UI for non-technical users"`);
+  context.stdout(`   ${colors.cyan}>${colors.reset} ${runner} codex "Task: set up code coverage"`);
+  context.stdout("");
+  context.stdout(`${colors.dim}If this is an existing codebase, you might want to backfill goals and facts:${colors.reset}`);
+  context.stdout(`   ${colors.cyan}>${colors.reset} ${runner} claude "Add goals and facts based on the code in this repository"`);
+  return { exitCode: 0 };
+}
+
+// lib/cli/commands/list.ts
+import { basename as basename2 } from "node:path";
+var VALID_TYPES = ["tasks", "ideas", "goals", "facts"];
+var SECTION_HEADERS = {
+  tasks: "\uD83D\uDCCB Tasks",
+  ideas: "\uD83D\uDCA1 Ideas",
+  goals: "\uD83C\uDFAF Goals",
+  facts: "\uD83D\uDCC4 Facts"
+};
+var TYPE_EXPLANATIONS = {
+  tasks: "Tasks are detailed work plans with dependencies and completion criteria. Each task describes a specific piece of work to be done.",
+  ideas: "Ideas are future feature notes and proposals. Ideas capture possibilities that haven't yet been refined into actionable tasks.",
+  goals: "Goals are mission statements and guiding principles. Goals describe desired outcomes and values that inform decision-making.",
+  facts: "Facts are current state documentation. Facts capture how things work today, providing context for agents and contributors."
+};
+async function buildGoalHierarchy(goalsPath, fileSystem) {
+  const files = await fileSystem.readdir(goalsPath);
+  const mdFiles = files.filter((f) => f.endsWith(".md"));
+  const relationships = [];
+  const titleMap = new Map;
+  for (const file of mdFiles) {
+    const filePath = `${goalsPath}/${file}`;
+    const content = await fileSystem.readFile(filePath);
+    relationships.push(extractGoalRelationships(filePath, content));
+    const title = extractTitle(content) || basename2(file, ".md");
+    titleMap.set(filePath, title);
+  }
+  const relMap = new Map;
+  for (const rel of relationships) {
+    relMap.set(rel.filePath, rel);
+  }
+  const rootGoals = relationships.filter((rel) => rel.parentGoals.length === 0);
+  function buildNode(filePath) {
+    const rel = relMap.get(filePath);
+    const children = [];
+    if (rel) {
+      for (const childPath of rel.subGoals) {
+        children.push(buildNode(childPath));
       }
-      emit({ type: "claude.raw_event", rawEvent });
+    }
+    return {
+      filePath,
+      title: titleMap.get(filePath) || basename2(filePath, ".md"),
+      children
     };
   }
-  while (completedIterations < maxIterations) {
-    agentSessionId = undefined;
-    const result = await runOneIteration(dependencies, loopDependencies, emit, iterationOptions);
-    if (result === "no_tasks") {
-      await loopDependencies.sleep(SLEEP_INTERVAL_MS);
-    } else {
-      completedIterations++;
-      emit({
-        type: "loop.iteration_complete",
-        iteration: completedIterations,
-        maxIterations
-      });
+  return rootGoals.map((rel) => buildNode(rel.filePath));
+}
+function renderHierarchy(nodes, output, prefix = "") {
+  for (let i = 0;i < nodes.length; i++) {
+    const node = nodes[i];
+    const isLastNode = i === nodes.length - 1;
+    const connector = isLastNode ? "└── " : "├── ";
+    const childPrefix = isLastNode ? "    " : "│   ";
+    output(`${prefix}${connector}${node.title}`);
+    if (node.children.length > 0) {
+      renderHierarchy(node.children, output, prefix + childPrefix);
+    }
+  }
+}
+async function list(dependencies) {
+  const { arguments: commandArguments, context, fileSystem } = dependencies;
+  const dustPath = `${context.cwd}/.dust`;
+  const colors = getColors();
+  if (!fileSystem.exists(dustPath)) {
+    context.stderr("Error: .dust directory not found");
+    context.stderr("Run 'dust init' to initialize a Dust repository");
+    return { exitCode: 1 };
+  }
+  const typesToList = commandArguments.length === 0 ? [...VALID_TYPES] : commandArguments.filter((a) => VALID_TYPES.includes(a));
+  if (commandArguments.length > 0 && typesToList.length === 0) {
+    context.stderr(`Invalid type: ${commandArguments[0]}`);
+    context.stderr(`Valid types: ${VALID_TYPES.join(", ")}`);
+    return { exitCode: 1 };
+  }
+  const specificTypeRequested = commandArguments.length > 0;
+  for (const type of typesToList) {
+    const dirPath = `${dustPath}/${type}`;
+    const dirExists = fileSystem.exists(dirPath);
+    const files = dirExists ? await fileSystem.readdir(dirPath) : [];
+    const mdFiles = files.filter((f) => f.endsWith(".md")).sort();
+    if (mdFiles.length === 0) {
+      if (specificTypeRequested) {
+        context.stdout(SECTION_HEADERS[type]);
+        context.stdout("");
+        context.stdout(TYPE_EXPLANATIONS[type]);
+        context.stdout("");
+        context.stdout(`No ${type} found.`);
+        context.stdout("");
+      }
+      continue;
+    }
+    context.stdout(SECTION_HEADERS[type]);
+    context.stdout("");
+    context.stdout(TYPE_EXPLANATIONS[type]);
+    context.stdout("");
+    if (type === "goals") {
+      const hierarchy = await buildGoalHierarchy(dirPath, fileSystem);
+      if (hierarchy.length > 0) {
+        context.stdout(`${colors.dim}Hierarchy:${colors.reset}`);
+        renderHierarchy(hierarchy, (line) => context.stdout(line));
+        context.stdout("");
+      }
+    }
+    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}`;
+      if (title) {
+        context.stdout(`${colors.bold}# ${title}${colors.reset}`);
+      } else {
+        context.stdout(`${colors.bold}# ${file.replace(".md", "")}${colors.reset}`);
+      }
+      if (openingSentence) {
+        context.stdout(`${colors.dim}${openingSentence}${colors.reset}`);
+      }
+      context.stdout(`${colors.cyan}→ ${relativePath}${colors.reset}`);
+      context.stdout("");
     }
   }
-  emit({ type: "loop.ended", maxIterations });
   return { exitCode: 0 };
 }
 
@@ -2385,6 +3704,8 @@ var commandRegistry = {
   next,
   check,
   agent,
+  audit,
+  bucket,
   focus,
   "new task": newTask,
   "new goal": newGoal,
@@ -2455,10 +3776,10 @@ function createFileSystem(primitives) {
     chmod: (path, mode) => primitives.chmod(path, mode)
   };
 }
-function createGlobScanner(readdir) {
+function createGlobScanner(readdir2) {
   return {
     scan: async function* (dir) {
-      for (const entry of await readdir(dir, { recursive: true })) {
+      for (const entry of await readdir2(dir, { recursive: true })) {
         if (entry.endsWith(".md"))
           yield entry;
       }
@@ -2482,4 +3803,4 @@ async function wireEntry(fsPrimitives, processPrimitives, consolePrimitives) {
 }
 
 // lib/cli/run.ts
-await wireEntry({ existsSync, readFile, writeFile, mkdir, readdir, chmod }, { argv: process.argv, cwd: () => process.cwd(), exit: process.exit }, { log: console.log, error: console.error });
+await wireEntry({ existsSync, readFile: readFile2, writeFile: writeFile2, mkdir: mkdir2, readdir: readdir2, chmod: chmod2 }, { argv: process.argv, cwd: () => process.cwd(), exit: process.exit }, { log: console.log, error: console.error });