@joshski/dust 0.1.77 → 0.1.79

package/dist/agent-events.d.ts

@@ -40,4 +40,15 @@ export interface EventMessage {
  * is forwarded as a claude-event.
  */
 export declare function rawEventToAgentEvent(rawEvent: Record<string, unknown>): AgentSessionEvent;
+/**
+ * Create a heartbeat throttler that limits agent-session-activity events
+ * to at most once per interval (default: 5 seconds).
+ *
+ * The returned callback converts raw Claude events to AgentSessionEvents,
+ * throttling stream_event heartbeats while forwarding all other events.
+ */
+export declare function createHeartbeatThrottler(onAgentEvent: (event: AgentSessionEvent) => void, options?: {
+    intervalMs?: number;
+    now?: () => number;
+}): (rawEvent: Record<string, unknown>) => void;
 export declare function formatAgentEvent(event: AgentSessionEvent): string | null;

package/dist/artifacts/index.d.ts

@@ -3,11 +3,24 @@ import { type Fact } from './facts';
 import { type Idea, type IdeaOpenQuestion, type IdeaOption, parseOpenQuestions } from './ideas';
 import { type Principle } from './principles';
 import { type Task } from './tasks';
-import { type AllWorkflowTasks, CAPTURE_IDEA_PREFIX, type CreateIdeaTransitionTaskResult, type DecomposeIdeaOptions, findAllWorkflowTasks, type IdeaInProgress, type OpenQuestionResponse, type ParsedCaptureIdeaTask, type WorkflowTaskMatch } from './workflow-tasks';
-export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedCaptureIdeaTask, Principle, Task, WorkflowTaskMatch, };
+import { type AllWorkflowTasks, CAPTURE_IDEA_PREFIX, type CreateIdeaTransitionTaskResult, type DecomposeIdeaOptions, findAllWorkflowTasks, type IdeaInProgress, type OpenQuestionResponse, type ParsedCaptureIdeaTask, type WorkflowTaskMatch, type WorkflowTaskType } from './workflow-tasks';
+export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedCaptureIdeaTask, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
+export interface TaskGraphNode {
+    task: Task;
+    workflowType: WorkflowTaskType | null;
+}
+export interface TaskGraph {
+    nodes: TaskGraphNode[];
+    edges: Array<{
+        from: string;
+        to: string;
+    }>;
+}
 export { CAPTURE_IDEA_PREFIX, findAllWorkflowTasks, parseOpenQuestions };
 export type { IdeaInProgress };
+export type ArtifactType = 'ideas' | 'tasks' | 'principles' | 'facts';
 export interface ArtifactsRepository {
+    artifactPath(type: ArtifactType, slug: string): string;
     parseIdea(options: {
         slug: string;
     }): Promise<Idea>;
@@ -49,6 +62,7 @@ export interface ArtifactsRepository {
     parseCaptureIdeaTask(options: {
         taskSlug: string;
     }): Promise<ParsedCaptureIdeaTask | null>;
+    buildTaskGraph(): Promise<TaskGraph>;
 }
 export declare function buildArtifactsRepository(fileSystem: FileSystem, dustPath: string): ArtifactsRepository;
-export declare function buildReadOnlyArtifactsRepository(fileSystem: ReadableFileSystem, dustPath: string): Pick<ArtifactsRepository, 'parseIdea' | 'listIdeas' | 'parsePrinciple' | 'listPrinciples' | 'parseFact' | 'listFacts' | 'parseTask' | 'listTasks' | 'findWorkflowTaskForIdea' | 'parseCaptureIdeaTask'>;
+export declare function buildReadOnlyArtifactsRepository(fileSystem: ReadableFileSystem, dustPath: string): Pick<ArtifactsRepository, 'artifactPath' | 'parseIdea' | 'listIdeas' | 'parsePrinciple' | 'listPrinciples' | 'parseFact' | 'listFacts' | 'parseTask' | 'listTasks' | 'findWorkflowTaskForIdea' | 'parseCaptureIdeaTask' | 'buildTaskGraph'>;

package/dist/artifacts.js

@@ -548,6 +548,9 @@ async function parseCaptureIdeaTask(fileSystem, dustPath, taskSlug) {
 // lib/artifacts/index.ts
 function buildArtifactsRepository(fileSystem, dustPath) {
   return {
+    artifactPath(type, slug) {
+      return `${dustPath}/${type}/${slug}.md`;
+    },
     async parseIdea(options) {
       return parseIdea(fileSystem, dustPath, options.slug);
     },
@@ -609,11 +612,35 @@ function buildArtifactsRepository(fileSystem, dustPath) {
     },
     async parseCaptureIdeaTask(options) {
       return parseCaptureIdeaTask(fileSystem, dustPath, options.taskSlug);
+    },
+    async buildTaskGraph() {
+      const taskSlugs = await this.listTasks();
+      const allWorkflowTasks = await findAllWorkflowTasks(fileSystem, dustPath);
+      const workflowTypeByTaskSlug = new Map;
+      for (const match of allWorkflowTasks.workflowTasksByIdeaSlug.values()) {
+        workflowTypeByTaskSlug.set(match.taskSlug, match.type);
+      }
+      const nodes = [];
+      const edges = [];
+      for (const slug of taskSlugs) {
+        const task = await this.parseTask({ slug });
+        nodes.push({
+          task,
+          workflowType: workflowTypeByTaskSlug.get(slug) ?? null
+        });
+        for (const blockerSlug of task.blockedBy) {
+          edges.push({ from: blockerSlug, to: slug });
+        }
+      }
+      return { nodes, edges };
     }
   };
 }
 function buildReadOnlyArtifactsRepository(fileSystem, dustPath) {
   return {
+    artifactPath(type, slug) {
+      return `${dustPath}/${type}/${slug}.md`;
+    },
     async parseIdea(options) {
       return parseIdea(fileSystem, dustPath, options.slug);
     },
@@ -663,6 +690,27 @@ function buildReadOnlyArtifactsRepository(fileSystem, dustPath) {
     },
     async parseCaptureIdeaTask(options) {
       return parseCaptureIdeaTask(fileSystem, dustPath, options.taskSlug);
+    },
+    async buildTaskGraph() {
+      const taskSlugs = await this.listTasks();
+      const allWorkflowTasks = await findAllWorkflowTasks(fileSystem, dustPath);
+      const workflowTypeByTaskSlug = new Map;
+      for (const match of allWorkflowTasks.workflowTasksByIdeaSlug.values()) {
+        workflowTypeByTaskSlug.set(match.taskSlug, match.type);
+      }
+      const nodes = [];
+      const edges = [];
+      for (const slug of taskSlugs) {
+        const task = await this.parseTask({ slug });
+        nodes.push({
+          task,
+          workflowType: workflowTypeByTaskSlug.get(slug) ?? null
+        });
+        for (const blockerSlug of task.blockedBy) {
+          edges.push({ from: blockerSlug, to: slug });
+        }
+      }
+      return { nodes, edges };
     }
   };
 }

package/dist/cli/colors.d.ts

@@ -17,7 +17,7 @@ interface Colors {
 /**
  * Determines whether colors should be disabled based on environment.
  */
-export declare function shouldDisableColors(): boolean;
+export declare function shouldDisableColors(env?: NodeJS.ProcessEnv): boolean;
 /**
  * Returns the appropriate colors object based on environment detection.
  */

package/dist/cli/commands/focus.d.ts

@@ -7,5 +7,5 @@
  * Usage: dust focus "add login box"
  */
 import type { CommandDependencies, CommandResult } from '../types';
-export declare function buildImplementationInstructions(bin: string, hooksInstalled: boolean, taskTitle?: string): string;
+export declare function buildImplementationInstructions(bin: string, hooksInstalled: boolean, taskTitle?: string, taskPath?: string, installCommand?: string): string;
 export declare function focus(dependencies: CommandDependencies): Promise<CommandResult>;

package/dist/config/settings.d.ts

@@ -20,15 +20,14 @@ export declare function validateSettingsJson(content: string): SettingsViolation
  */
 export declare function detectDustCommand(cwd: string, fileSystem: ReadableFileSystem): string;
 /**
- * Detects the appropriate install command based on lockfiles and environment.
- * Priority:
- * 1. bun.lockb exists → bun install
- * 2. pnpm-lock.yaml exists → pnpm install
- * 3. package-lock.json exists → npm install
- * 4. No lockfile + BUN_INSTALL env var set → bun install
- * 5. Default → npm install
+ * Detects the appropriate install command based on lockfiles.
+ * Returns null when:
+ * - No recognized lockfile is found
+ * - Multiple ecosystems are detected (requires explicit configuration)
+ *
+ * Priority within each ecosystem follows the order in LOCKFILE_COMMANDS.
  */
-export declare function detectInstallCommand(cwd: string, fileSystem: ReadableFileSystem): string;
+export declare function detectInstallCommand(cwd: string, fileSystem: ReadableFileSystem): string | null;
 /**
  * Detects the appropriate test command based on lockfiles and environment.
  * Priority:

package/dist/dust.js

@@ -170,8 +170,7 @@ function validateSettingsJson(content) {
   return violations;
 }
 var DEFAULT_SETTINGS = {
-  dustCommand: "npx dust",
-  installCommand: "npm install"
+  dustCommand: "npx dust"
 };
 function detectDustCommand(cwd, fileSystem) {
   if (fileSystem.exists(join(cwd, "bun.lockb"))) {
@@ -188,20 +187,38 @@ function detectDustCommand(cwd, fileSystem) {
   }
   return "npx dust";
 }
+var LOCKFILE_COMMANDS = [
+  { file: "bun.lockb", command: "bun install", ecosystem: "js" },
+  { file: "pnpm-lock.yaml", command: "pnpm install", ecosystem: "js" },
+  { file: "package-lock.json", command: "npm install", ecosystem: "js" },
+  { file: "Gemfile.lock", command: "bundle install", ecosystem: "ruby" },
+  { file: "poetry.lock", command: "poetry install", ecosystem: "python" },
+  { file: "Pipfile.lock", command: "pipenv install", ecosystem: "python" },
+  {
+    file: "requirements.txt",
+    command: "pip install -r requirements.txt",
+    ecosystem: "python"
+  },
+  { file: "go.sum", command: "go mod download", ecosystem: "go" },
+  { file: "Cargo.lock", command: "cargo build", ecosystem: "rust" },
+  { file: "composer.lock", command: "composer install", ecosystem: "php" },
+  { file: "mix.lock", command: "mix deps.get", ecosystem: "elixir" }
+];
 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";
+  const foundEcosystems = new Set;
+  let firstCommand = null;
+  for (const { file, command, ecosystem } of LOCKFILE_COMMANDS) {
+    if (fileSystem.exists(join(cwd, file))) {
+      if (firstCommand === null) {
+        firstCommand = command;
+      }
+      foundEcosystems.add(ecosystem);
+    }
   }
-  if (process.env.BUN_INSTALL) {
-    return "bun install";
+  if (foundEcosystems.size > 1) {
+    return null;
   }
-  return "npm install";
+  return firstCommand;
 }
 function detectTestCommand(cwd, fileSystem) {
   if (fileSystem.exists(join(cwd, "bun.lockb")) || fileSystem.exists(join(cwd, "bun.lock"))) {
@@ -234,9 +251,12 @@ async function loadSettings(cwd, fileSystem) {
   const settingsPath = join(cwd, ".dust", "config", "settings.json");
   if (!fileSystem.exists(settingsPath)) {
     const result = {
-      dustCommand: detectDustCommand(cwd, fileSystem),
-      installCommand: detectInstallCommand(cwd, fileSystem)
+      dustCommand: detectDustCommand(cwd, fileSystem)
     };
+    const installCommand = detectInstallCommand(cwd, fileSystem);
+    if (installCommand !== null) {
+      result.installCommand = installCommand;
+    }
     if (process.env.DUST_EVENTS_URL) {
       result.eventsUrl = process.env.DUST_EVENTS_URL;
     }
@@ -256,26 +276,37 @@ async function loadSettings(cwd, fileSystem) {
       result.dustCommand = detectDustCommand(cwd, fileSystem);
     }
     if (!parsed.installCommand) {
-      result.installCommand = detectInstallCommand(cwd, fileSystem);
+      const installCommand = detectInstallCommand(cwd, fileSystem);
+      if (installCommand !== null) {
+        result.installCommand = installCommand;
+      } else {
+        delete result.installCommand;
+      }
     }
     if (process.env.DUST_EVENTS_URL) {
       result.eventsUrl = process.env.DUST_EVENTS_URL;
     }
     return result;
-  } catch {
-    const result = {
-      dustCommand: detectDustCommand(cwd, fileSystem),
-      installCommand: detectInstallCommand(cwd, fileSystem)
-    };
-    if (process.env.DUST_EVENTS_URL) {
-      result.eventsUrl = process.env.DUST_EVENTS_URL;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      const result = {
+        dustCommand: detectDustCommand(cwd, fileSystem)
+      };
+      const installCommand = detectInstallCommand(cwd, fileSystem);
+      if (installCommand !== null) {
+        result.installCommand = installCommand;
+      }
+      if (process.env.DUST_EVENTS_URL) {
+        result.eventsUrl = process.env.DUST_EVENTS_URL;
+      }
+      return result;
     }
-    return result;
+    throw error;
   }
 }
 
 // lib/version.ts
-var DUST_VERSION = "0.1.77";
+var DUST_VERSION = "0.1.79";
 
 // lib/session.ts
 var DUST_UNATTENDED = "DUST_UNATTENDED";
@@ -460,8 +491,11 @@ async function loadAgentInstructions(cwd, fileSystem, agentType) {
   try {
     const content = await fileSystem.readFile(instructionsPath);
     return content.trim();
-  } catch {
-    return "";
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return "";
+    }
+    throw error;
   }
 }
 function templateVariables(settings, hooksInstalled, env = process.env, options) {
@@ -1521,11 +1555,11 @@ var NO_COLORS = {
   green: "",
   yellow: ""
 };
-function shouldDisableColors() {
-  if (process.env.NO_COLOR !== undefined) {
+function shouldDisableColors(env = process.env) {
+  if (env.NO_COLOR !== undefined) {
     return true;
   }
-  if (process.env.TERM === "dumb") {
+  if (env.TERM === "dumb") {
     return true;
   }
   if (!process.stdout.isTTY) {
@@ -1641,8 +1675,8 @@ 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 getDustbucketHost(env = process.env) {
+  return env.DUST_BUCKET_HOST || DEFAULT_DUSTBUCKET_HOST;
 }
 function credentialsPath(homeDir) {
   return join4(homeDir, CREDENTIALS_DIR, CREDENTIALS_FILE);
@@ -1653,8 +1687,11 @@ async function loadStoredToken(fileSystem, homeDir) {
     const content = await fileSystem.readFile(path);
     const data = JSON.parse(content);
     return typeof data.token === "string" ? data.token : null;
-  } catch {
-    return null;
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return null;
+    }
+    throw error;
   }
 }
 async function storeToken(fileSystem, homeDir, token) {
@@ -1666,7 +1703,12 @@ async function clearToken(fileSystem, homeDir) {
   const path = credentialsPath(homeDir);
   try {
     await fileSystem.writeFile(path, "{}");
-  } catch {}
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
 }
 async function defaultExchangeCode(code) {
   const host = getDustbucketHost();
@@ -1847,6 +1889,134 @@ import { dirname as dirname2 } from "node:path";
 // lib/claude/spawn-claude-code.ts
 import { spawn as nodeSpawn2 } from "node:child_process";
 import { createInterface as nodeCreateInterface } from "node:readline";
+
+// lib/logging/index.ts
+import { join as join6 } from "node:path";
+
+// lib/logging/match.ts
+function parsePatterns(debug) {
+  if (!debug)
+    return [];
+  const expressions = debug.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
+  return expressions.map((expr) => {
+    const escaped = expr.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = escaped.replace(/\*/g, ".*");
+    return new RegExp(`^${pattern}$`);
+  });
+}
+function matchesAny(name, patterns) {
+  return patterns.some((re) => re.test(name));
+}
+function formatLine(name, messages) {
+  const text = messages.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
+  return `${new Date().toISOString()} [${name}] ${text}
+`;
+}
+
+// lib/logging/sink.ts
+import { appendFileSync, mkdirSync } from "node:fs";
+import { dirname } from "node:path";
+
+class FileSink {
+  logPath;
+  _appendFileSync;
+  _mkdirSync;
+  resolvedPath;
+  ready = false;
+  constructor(logPath, _appendFileSync = appendFileSync, _mkdirSync = mkdirSync) {
+    this.logPath = logPath;
+    this._appendFileSync = _appendFileSync;
+    this._mkdirSync = _mkdirSync;
+  }
+  ensureLogFile() {
+    if (this.ready)
+      return this.resolvedPath;
+    this.ready = true;
+    this.resolvedPath = this.logPath;
+    try {
+      this._mkdirSync(dirname(this.logPath), { recursive: true });
+    } catch {
+      this.resolvedPath = undefined;
+    }
+    return this.resolvedPath;
+  }
+  write(line) {
+    const path = this.ensureLogFile();
+    if (!path)
+      return;
+    try {
+      this._appendFileSync(path, line);
+    } catch {}
+  }
+}
+
+// lib/logging/index.ts
+var DUST_LOG_FILE = "DUST_LOG_FILE";
+function createLoggingService() {
+  let patterns = null;
+  let initialized = false;
+  let activeFileSink = null;
+  const fileSinkCache = new Map;
+  function init() {
+    if (initialized)
+      return;
+    initialized = true;
+    const parsed = parsePatterns(process.env.DEBUG);
+    patterns = parsed.length > 0 ? parsed : null;
+  }
+  function getOrCreateFileSink(path) {
+    let sink = fileSinkCache.get(path);
+    if (!sink) {
+      sink = new FileSink(path);
+      fileSinkCache.set(path, sink);
+    }
+    return sink;
+  }
+  return {
+    enableFileLogs(scope, sinkForTesting) {
+      const existing = process.env[DUST_LOG_FILE];
+      const logDir = process.env.DUST_LOG_DIR ?? join6(process.cwd(), "log");
+      const path = existing ?? join6(logDir, `${scope}.log`);
+      if (!existing) {
+        process.env[DUST_LOG_FILE] = path;
+      }
+      activeFileSink = sinkForTesting ?? new FileSink(path);
+    },
+    createLogger(name, options) {
+      let perLoggerSink;
+      if (options?.file === false) {
+        perLoggerSink = null;
+      } else if (typeof options?.file === "string") {
+        perLoggerSink = getOrCreateFileSink(options.file);
+      }
+      return (...messages) => {
+        init();
+        const line = formatLine(name, messages);
+        if (perLoggerSink !== undefined) {
+          if (perLoggerSink !== null) {
+            perLoggerSink.write(line);
+          }
+        } else if (activeFileSink) {
+          activeFileSink.write(line);
+        }
+        if (patterns && matchesAny(name, patterns)) {
+          process.stdout.write(line);
+        }
+      };
+    },
+    isEnabled(name) {
+      init();
+      return patterns !== null && matchesAny(name, patterns);
+    }
+  };
+}
+var defaultService = createLoggingService();
+var enableFileLogs = defaultService.enableFileLogs.bind(defaultService);
+var createLogger = defaultService.createLogger.bind(defaultService);
+var isEnabled = defaultService.isEnabled.bind(defaultService);
+
+// lib/claude/spawn-claude-code.ts
+var debug = createLogger("dust.claude.spawn-claude-code");
 var defaultDependencies = {
   spawn: nodeSpawn2,
   createInterface: nodeCreateInterface
@@ -1929,7 +2099,9 @@ async function* spawnClaudeCode(prompt, options = {}, dependencies = defaultDepe
         continue;
       try {
         yield JSON.parse(line);
-      } catch {}
+      } catch {
+        debug("Skipping malformed JSON line: %s", line.slice(0, 200));
+      }
     }
     await closePromise;
   } finally {
@@ -2260,131 +2432,6 @@ async function run(prompt, options = {}, dependencies = defaultRunnerDependencie
   await dependencies.streamEvents(events, sink, onRawEvent);
 }
 
-// lib/logging/index.ts
-import { join as join6 } from "node:path";
-
-// lib/logging/match.ts
-function parsePatterns(debug) {
-  if (!debug)
-    return [];
-  const expressions = debug.split(",").map((s) => s.trim()).filter((s) => s.length > 0);
-  return expressions.map((expr) => {
-    const escaped = expr.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
-    const pattern = escaped.replace(/\*/g, ".*");
-    return new RegExp(`^${pattern}$`);
-  });
-}
-function matchesAny(name, patterns) {
-  return patterns.some((re) => re.test(name));
-}
-function formatLine(name, messages) {
-  const text = messages.map((a) => typeof a === "string" ? a : JSON.stringify(a)).join(" ");
-  return `${new Date().toISOString()} [${name}] ${text}
-`;
-}
-
-// lib/logging/sink.ts
-import { appendFileSync, mkdirSync } from "node:fs";
-import { dirname } from "node:path";
-
-class FileSink {
-  logPath;
-  _appendFileSync;
-  _mkdirSync;
-  resolvedPath;
-  ready = false;
-  constructor(logPath, _appendFileSync = appendFileSync, _mkdirSync = mkdirSync) {
-    this.logPath = logPath;
-    this._appendFileSync = _appendFileSync;
-    this._mkdirSync = _mkdirSync;
-  }
-  ensureLogFile() {
-    if (this.ready)
-      return this.resolvedPath;
-    this.ready = true;
-    this.resolvedPath = this.logPath;
-    try {
-      this._mkdirSync(dirname(this.logPath), { recursive: true });
-    } catch {
-      this.resolvedPath = undefined;
-    }
-    return this.resolvedPath;
-  }
-  write(line) {
-    const path = this.ensureLogFile();
-    if (!path)
-      return;
-    try {
-      this._appendFileSync(path, line);
-    } catch {}
-  }
-}
-
-// lib/logging/index.ts
-var DUST_LOG_FILE = "DUST_LOG_FILE";
-function createLoggingService() {
-  let patterns = null;
-  let initialized = false;
-  let activeFileSink = null;
-  const fileSinkCache = new Map;
-  function init() {
-    if (initialized)
-      return;
-    initialized = true;
-    const parsed = parsePatterns(process.env.DEBUG);
-    patterns = parsed.length > 0 ? parsed : null;
-  }
-  function getOrCreateFileSink(path) {
-    let sink = fileSinkCache.get(path);
-    if (!sink) {
-      sink = new FileSink(path);
-      fileSinkCache.set(path, sink);
-    }
-    return sink;
-  }
-  return {
-    enableFileLogs(scope, sinkForTesting) {
-      const existing = process.env[DUST_LOG_FILE];
-      const logDir = process.env.DUST_LOG_DIR ?? join6(process.cwd(), "log");
-      const path = existing ?? join6(logDir, `${scope}.log`);
-      if (!existing) {
-        process.env[DUST_LOG_FILE] = path;
-      }
-      activeFileSink = sinkForTesting ?? new FileSink(path);
-    },
-    createLogger(name, options) {
-      let perLoggerSink;
-      if (options?.file === false) {
-        perLoggerSink = null;
-      } else if (typeof options?.file === "string") {
-        perLoggerSink = getOrCreateFileSink(options.file);
-      }
-      return (...messages) => {
-        init();
-        const line = formatLine(name, messages);
-        if (perLoggerSink !== undefined) {
-          if (perLoggerSink !== null) {
-            perLoggerSink.write(line);
-          }
-        } else if (activeFileSink) {
-          activeFileSink.write(line);
-        }
-        if (patterns && matchesAny(name, patterns)) {
-          process.stdout.write(line);
-        }
-      };
-    },
-    isEnabled(name) {
-      init();
-      return patterns !== null && matchesAny(name, patterns);
-    }
-  };
-}
-var defaultService = createLoggingService();
-var enableFileLogs = defaultService.enableFileLogs.bind(defaultService);
-var createLogger = defaultService.createLogger.bind(defaultService);
-var isEnabled = defaultService.isEnabled.bind(defaultService);
-
 // lib/bucket/repository-git.ts
 import { join as join7 } from "node:path";
 function getRepoPath(repoName, reposDir) {
@@ -2437,6 +2484,23 @@ function rawEventToAgentEvent(rawEvent) {
   }
   return { type: "claude-event", rawEvent };
 }
+var DEFAULT_HEARTBEAT_INTERVAL_MS = 5000;
+function createHeartbeatThrottler(onAgentEvent, options) {
+  const intervalMs = options?.intervalMs ?? DEFAULT_HEARTBEAT_INTERVAL_MS;
+  const now = options?.now ?? Date.now;
+  let lastHeartbeatTime;
+  return (rawEvent) => {
+    const event = rawEventToAgentEvent(rawEvent);
+    if (event.type === "agent-session-activity") {
+      const currentTime = now();
+      if (lastHeartbeatTime !== undefined && currentTime - lastHeartbeatTime < intervalMs) {
+        return;
+      }
+      lastHeartbeatTime = currentTime;
+    }
+    onAgentEvent(event);
+  };
+}
 function agentDisplayName(agentType) {
   if (agentType === "codex")
     return "Codex";
@@ -2472,11 +2536,15 @@ function titleToFilename(title) {
 }
 
 // lib/cli/commands/focus.ts
-function buildImplementationInstructions(bin, hooksInstalled, taskTitle) {
+function buildImplementationInstructions(bin, hooksInstalled, taskTitle, taskPath, installCommand) {
   const steps = [];
   let step = 1;
   const hasIdeaFile = !taskTitle?.startsWith(EXPEDITE_IDEA_PREFIX);
   steps.push(`Note: Do NOT run \`${bin} agent\`.`, "");
+  if (installCommand) {
+    steps.push(`${step}. Run \`${installCommand}\` to install dependencies`);
+    step++;
+  }
   steps.push(`${step}. Run \`${bin} check\` to verify the project is in a good state`);
   step++;
   steps.push(`${step}. Implement the task`);
@@ -2486,10 +2554,11 @@ function buildImplementationInstructions(bin, hooksInstalled, taskTitle) {
     step++;
   }
   const commitMessageLine = taskTitle ? `   Use this exact commit message: "${taskTitle}". Do not add any prefix.` : '   Use the task title as the commit message. Do not add prefixes like "Complete task:" - use the title directly.';
+  const deleteTaskLine = taskPath ? `   - Deletion of the completed task file (\`${taskPath}\`)` : "   - Deletion of the completed task file";
   const commitItems = [
     "   - All implementation changes",
-    "   - Deletion of the completed task file",
-    "   - Updates to any facts that changed"
+    deleteTaskLine,
+    `   - Updates to any facts that changed (run \`${bin} facts\` if needed)`
   ];
   if (hasIdeaFile) {
     commitItems.push("   - Deletion of the idea file that spawned this task (if remaining scope exists, create new ideas for it)");
@@ -2795,18 +2864,14 @@ Make sure the repository is in a clean state and synced with remote before finis
   onLoopEvent({ type: "loop.tasks_found" });
   const taskContent = await dependencies.fileSystem.readFile(`${dependencies.context.cwd}/${task.path}`);
   const { dustCommand, installCommand = "npm install" } = dependencies.settings;
-  const instructions = buildImplementationInstructions(dustCommand, hooksInstalled, task.title ?? undefined);
-  const prompt = `Run \`${installCommand}\` to install dependencies, then implement the following task.
-
-The following is the contents of the task file \`${task.path}\`:
+  const instructions = buildImplementationInstructions(dustCommand, hooksInstalled, task.title ?? undefined, task.path, installCommand);
+  const prompt = `Implement the task at \`${task.path}\`:
 
 ----------
 ${taskContent}
 ----------
 
-When the task is complete, delete the task file \`${task.path}\`.
-
-## Instructions
+## How to implement the task
 
 ${instructions}`;
   onAgentEvent?.({
@@ -2894,9 +2959,7 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
   let completedIterations = 0;
   const iterationOptions = { hooksInstalled };
   if (eventsUrl) {
-    iterationOptions.onRawEvent = (rawEvent) => {
-      onAgentEvent(rawEventToAgentEvent(rawEvent));
-    };
+    iterationOptions.onRawEvent = createHeartbeatThrottler(onAgentEvent);
   }
   while (completedIterations < maxIterations) {
     agentSessionId = crypto.randomUUID();
@@ -3057,9 +3120,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
         hooksInstalled,
         signal: abortController.signal,
         repositoryId: repoState.repository.id.toString(),
-        onRawEvent: (rawEvent) => {
-          onAgentEvent(rawEventToAgentEvent(rawEvent));
-        }
+        onRawEvent: createHeartbeatThrottler(onAgentEvent)
       });
     } catch (error) {
       const msg = error instanceof Error ? error.message : String(error);
@@ -4039,7 +4100,12 @@ async function shutdown(state, bucketDeps, context) {
     repoState.wakeUp?.();
   }
   const loopPromises = Array.from(state.repositories.values()).map((rs) => rs.loopPromise).filter((p) => p !== null);
-  await Promise.all(loopPromises.map((p) => p.catch(() => {})));
+  const results = await Promise.allSettled(loopPromises);
+  for (const result of results) {
+    if (result.status === "rejected") {
+      context.stderr(`Repository loop failed: ${result.reason}`);
+    }
+  }
   for (const repoState of state.repositories.values()) {
     await removeRepository(repoState.path, bucketDeps.spawn, context);
   }
@@ -5698,6 +5764,7 @@ async function list(dependencies) {
 // lib/codex/spawn-codex.ts
 import { spawn as nodeSpawn5 } from "node:child_process";
 import { createInterface as nodeCreateInterface2 } from "node:readline";
+var debug2 = createLogger("dust.codex.spawn-codex");
 var defaultDependencies2 = {
   spawn: nodeSpawn5,
   createInterface: nodeCreateInterface2
@@ -5747,7 +5814,9 @@ async function* spawnCodex(prompt, options = {}, dependencies = defaultDependenc
         continue;
       try {
         yield JSON.parse(line);
-      } catch {}
+      } catch {
+        debug2("Skipping malformed JSON line: %s", line.slice(0, 200));
+      }
     }
     await closePromise;
   } finally {

package/dist/types.d.ts

@@ -6,5 +6,7 @@
  */
 export type { AgentSessionEvent, EventMessage } from './agent-events';
 export type { Idea, IdeaOpenQuestion, IdeaOption } from './artifacts/ideas';
+export type { ArtifactType, TaskGraph, TaskGraphNode } from './artifacts/index';
+export type { Task } from './artifacts/tasks';
 export type { CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, IdeaInProgress, OpenQuestionResponse, ParsedCaptureIdeaTask, WorkflowTaskMatch, WorkflowTaskType, } from './artifacts/workflow-tasks';
 export type { Repository } from './bucket/repository';

package/dist/validation.js

@@ -730,7 +730,11 @@ function createOverlayFileSystem(base, patchFiles, deletedPaths = new Set) {
             entries.add(entry);
           }
         }
-      } catch {}
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
       return Array.from(entries);
     },
     isDirectory(path) {
@@ -821,7 +825,11 @@ async function validatePatch(fileSystem, dustPath, patch) {
         const content = await overlayFs.readFile(filePath);
         allRelationships.push(extractPrincipleRelationships(filePath, content));
       }
-    } catch {}
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
     violations.push(...validateBidirectionalLinks(allRelationships));
     violations.push(...validateNoCycles(allRelationships));
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.77",
+  "version": "0.1.79",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {