@joshski/dust 0.1.56 → 0.1.58

package/dist/dust.js

@@ -1177,7 +1177,7 @@ function getLogLines(buffer) {
 }
 
 // lib/bucket/repository.ts
-import { dirname as dirname2, join as join8 } from "node:path";
+import { dirname as dirname3, join as join8 } from "node:path";
 
 // lib/claude/spawn-claude-code.ts
 import { spawn as nodeSpawn } from "node:child_process";
@@ -1595,6 +1595,9 @@ async function run(prompt, options = {}, dependencies = defaultRunnerDependencie
   await dependencies.streamEvents(events, sink, onRawEvent);
 }
 
+// lib/logging/index.ts
+import { join as join5 } from "node:path";
+
 // lib/logging/match.ts
 function parsePatterns(debug) {
   if (!debug)
@@ -1617,56 +1620,105 @@ function formatLine(name, messages) {
 
 // lib/logging/sink.ts
 import { appendFileSync, mkdirSync } from "node:fs";
-import { join as join5 } from "node:path";
-var logPath;
-var ready = false;
-var scope = process.env.DEBUG_LOG_SCOPE || "debug";
-function ensureLogFile() {
-  if (ready)
-    return logPath;
-  ready = true;
-  const dir = join5(process.cwd(), "log", "dust");
-  logPath = join5(dir, `${scope}.log`);
-  try {
-    mkdirSync(dir, { recursive: true });
-  } catch {
-    logPath = undefined;
-  }
-  return logPath;
-}
-function setLogScope(name) {
-  scope = name;
-  process.env.DEBUG_LOG_SCOPE = name;
-  logPath = undefined;
+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 {}
+  }
 }
-var writeToFile = (line) => {
-  const path = ensureLogFile();
-  if (!path)
-    return;
-  try {
-    appendFileSync(path, line);
-  } catch {}
-};
 
 // lib/logging/index.ts
-var patterns = null;
-var initialized = false;
-function init() {
-  if (initialized)
-    return;
-  initialized = true;
-  const parsed = parsePatterns(process.env.DEBUG);
-  patterns = parsed.length > 0 ? parsed : null;
-}
-function createLogger(name, write = writeToFile) {
-  return (...messages) => {
-    init();
-    if (!patterns || !matchesAny(name, patterns))
+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;
-    write(formatLine(name, messages));
+    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 ?? join5(process.cwd(), "log");
+      const path = existing ?? join5(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 join6 } from "node:path";
@@ -1742,7 +1794,7 @@ function formatAgentEvent(event) {
 import { spawn as nodeSpawn2 } from "node:child_process";
 import { readFileSync } from "node:fs";
 import os from "node:os";
-import { dirname, join as join7 } from "node:path";
+import { dirname as dirname2, join as join7 } from "node:path";
 import { fileURLToPath } from "node:url";
 
 // lib/workflow-tasks.ts
@@ -1887,7 +1939,7 @@ async function next(dependencies) {
 }
 
 // lib/cli/commands/loop.ts
-var __dirname2 = dirname(fileURLToPath(import.meta.url));
+var __dirname2 = dirname2(fileURLToPath(import.meta.url));
 function getDustVersion() {
   const candidates = [
     join7(__dirname2, "../../../package.json"),
@@ -1970,7 +2022,7 @@ function createWireEventSender(eventsUrl, sessionId, postEvent, onError, getAgen
     postEvent(eventsUrl, payload).catch(onError);
   };
 }
-var log = createLogger("dust.cli.commands.loop");
+var log = createLogger("dust:cli:commands:loop");
 var SLEEP_INTERVAL_MS = 30000;
 var SLEEP_STEP_MS = 1000;
 var DEFAULT_MAX_ITERATIONS = 10;
@@ -2137,6 +2189,7 @@ function parseMaxIterations(commandArguments) {
   return parsed;
 }
 async function loopClaude(dependencies, loopDependencies = createDefaultDependencies()) {
+  enableFileLogs("loop");
   const { context, settings } = dependencies;
   const { postEvent } = loopDependencies;
   const maxIterations = parseMaxIterations(dependencies.arguments);
@@ -2200,7 +2253,7 @@ async function loopClaude(dependencies, loopDependencies = createDefaultDependen
 }
 
 // lib/bucket/repository-loop.ts
-var log2 = createLogger("dust.bucket.repository-loop");
+var log2 = createLogger("dust:bucket:repository-loop");
 var FALLBACK_TIMEOUT_MS = 300000;
 function createNoOpGlobScanner() {
   return {
@@ -2349,7 +2402,7 @@ async function runRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
 }
 
 // lib/bucket/repository.ts
-var log3 = createLogger("dust.bucket.repository");
+var log3 = createLogger("dust:bucket:repository");
 function startRepositoryLoop(repoState, repoDeps, sendEvent, sessionId) {
   log3(`starting loop for ${repoState.repository.name}`);
   repoState.stopRequested = false;
@@ -2391,7 +2444,7 @@ async function addRepository(repository, manager, repoDeps, context) {
   }
   log3(`adding repository ${repository.name}`);
   const repoPath = getRepoPath(repository.name, repoDeps.getReposDir());
-  await repoDeps.fileSystem.mkdir(dirname2(repoPath), { recursive: true });
+  await repoDeps.fileSystem.mkdir(dirname3(repoPath), { recursive: true });
   if (repoDeps.fileSystem.exists(repoPath)) {
     await removeRepository(repoPath, repoDeps.spawn, context);
   }
@@ -2884,7 +2937,7 @@ function handleKeyInput(state, key, options) {
 }
 
 // lib/cli/commands/bucket.ts
-var log4 = createLogger("dust.cli.commands.bucket");
+var log4 = createLogger("dust:cli:commands:bucket");
 var DEFAULT_DUSTBUCKET_WS_URL = "wss://dustbucket.com/agent/connect";
 var INITIAL_RECONNECT_DELAY_MS = 1000;
 var MAX_RECONNECT_DELAY_MS = 30000;
@@ -3312,6 +3365,7 @@ async function resolveToken(authDeps, context) {
   }
 }
 async function bucket(dependencies, bucketDeps = createDefaultBucketDependencies()) {
+  enableFileLogs("bucket");
   const { context, fileSystem } = dependencies;
   const token = await resolveToken(bucketDeps.auth, context);
   if (!token) {
@@ -3602,7 +3656,7 @@ function validateTitleFilenameMatch(filePath, content) {
 }
 
 // lib/lint/validators/goal-hierarchy.ts
-import { dirname as dirname3, resolve } from "node:path";
+import { dirname as dirname4, resolve } from "node:path";
 var REQUIRED_GOAL_HEADINGS = ["## Parent Goal", "## Sub-Goals"];
 function validateGoalHierarchySections(filePath, content) {
   const violations = [];
@@ -3619,7 +3673,7 @@ function validateGoalHierarchySections(filePath, content) {
 function extractGoalRelationships(filePath, content) {
   const lines = content.split(`
 `);
-  const fileDir = dirname3(filePath);
+  const fileDir = dirname4(filePath);
   const parentGoals = [];
   const subGoals = [];
   let currentSection = null;
@@ -3828,7 +3882,7 @@ function validateIdeaTransitionTitle(filePath, content, ideasPath, fileSystem) {
 }
 
 // lib/lint/validators/link-validator.ts
-import { dirname as dirname4, resolve as resolve2 } from "node:path";
+import { dirname as dirname5, resolve as resolve2 } from "node:path";
 var SEMANTIC_RULES = [
   {
     section: "## Goals",
@@ -3845,7 +3899,7 @@ function validateLinks(filePath, content, fileSystem) {
   const violations = [];
   const lines = content.split(`
 `);
-  const fileDir = dirname4(filePath);
+  const fileDir = dirname5(filePath);
   for (let i = 0;i < lines.length; i++) {
     const line = lines[i];
     const linkPattern = new RegExp(MARKDOWN_LINK_PATTERN.source, "g");
@@ -3872,7 +3926,7 @@ function validateSemanticLinks(filePath, content) {
   const violations = [];
   const lines = content.split(`
 `);
-  const fileDir = dirname4(filePath);
+  const fileDir = dirname5(filePath);
   let currentSection = null;
   for (let i = 0;i < lines.length; i++) {
     const line = lines[i];
@@ -3923,7 +3977,7 @@ function validateGoalHierarchyLinks(filePath, content) {
   const violations = [];
   const lines = content.split(`
 `);
-  const fileDir = dirname4(filePath);
+  const fileDir = dirname5(filePath);
   let currentSection = null;
   for (let i = 0;i < lines.length; i++) {
     const line = lines[i];
@@ -4160,8 +4214,26 @@ async function lintMarkdown(dependencies) {
 }
 
 // lib/cli/commands/check.ts
-var log5 = createLogger("dust.cli.commands.check");
+var log5 = createLogger("dust:cli:commands:check");
 var DEFAULT_CHECK_TIMEOUT_MS = 13000;
+var MAX_OUTPUT_LINES = 500;
+var KEEP_LINES = 250;
+function truncateOutput(output) {
+  const lines = output.split(`
+`);
+  if (lines.length <= MAX_OUTPUT_LINES) {
+    return output;
+  }
+  const snippedCount = lines.length - KEEP_LINES * 2;
+  const firstLines = lines.slice(0, KEEP_LINES);
+  const lastLines = lines.slice(-KEEP_LINES);
+  return [
+    ...firstLines,
+    `[...snip ${snippedCount} lines...]`,
+    ...lastLines
+  ].join(`
+`);
+}
 async function runSingleCheck(check, cwd, runner) {
   const timeoutMs = check.timeoutMilliseconds ?? DEFAULT_CHECK_TIMEOUT_MS;
   log5(`running check ${check.name}: ${check.command}`);
@@ -4241,7 +4313,7 @@ function displayResults(results, context) {
       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());
+      context.stdout(truncateOutput(result.output).trimEnd());
     }
     if (result.hints && result.hints.length > 0) {
       context.stdout("");
@@ -4264,7 +4336,7 @@ async function check(dependencies, shellRunner = defaultShellRunner) {
     settings
   } = dependencies;
   const serial = commandArguments.includes("--serial");
-  setLogScope("check");
+  enableFileLogs("check");
   if (!settings.checks || settings.checks.length === 0) {
     context.stderr("Error: No checks configured in .dust/config/settings.json");
     context.stderr("");
@@ -4396,7 +4468,7 @@ function agentsMdContent(dustCommand) {
     Always immediately run \`${dustCommand} agent\` when you start working in this repository.
   `;
 }
-async function init2(dependencies) {
+async function init(dependencies) {
   const { context, fileSystem } = dependencies;
   const colors = getColors();
   const dustPath = `${context.cwd}/.dust`;
@@ -5042,7 +5114,7 @@ async function facts(dependencies) {
 
 // lib/cli/main.ts
 var commandRegistry = {
-  init: init2,
+  init,
   lint: lintMarkdown,
   list,
   tasks,
@@ -5066,7 +5138,6 @@ var commandRegistry = {
   help
 };
 var COMMANDS = Object.keys(commandRegistry).filter((cmd) => !cmd.includes(" "));
-var HELP_TEXT = generateHelpText({ dustCommand: "dust" });
 function isHelpRequest(command) {
   return !command || command === "help" || command === "--help" || command === "-h";
 }

package/dist/ideas.js

@@ -0,0 +1,135 @@
+// lib/markdown/markdown-utilities.ts
+function extractTitle(content) {
+  const match = content.match(/^#\s+(.+)$/m);
+  return match ? match[1].trim() : null;
+}
+function extractOpeningSentence(content) {
+  const lines = content.split(`
+`);
+  let h1Index = -1;
+  for (let i = 0;i < lines.length; i++) {
+    if (lines[i].match(/^#\s+.+$/)) {
+      h1Index = i;
+      break;
+    }
+  }
+  if (h1Index === -1) {
+    return null;
+  }
+  let paragraphStart = -1;
+  for (let i = h1Index + 1;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line !== "") {
+      paragraphStart = i;
+      break;
+    }
+  }
+  if (paragraphStart === -1) {
+    return null;
+  }
+  const firstLine = lines[paragraphStart];
+  const trimmedFirstLine = firstLine.trim();
+  if (trimmedFirstLine.startsWith("#") || trimmedFirstLine.startsWith("-") || trimmedFirstLine.startsWith("*") || trimmedFirstLine.startsWith("+") || trimmedFirstLine.match(/^\d+\./) || trimmedFirstLine.startsWith("```") || trimmedFirstLine.startsWith(">")) {
+    return null;
+  }
+  let paragraph = "";
+  for (let i = paragraphStart;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "")
+      break;
+    if (line.startsWith("#") || line.startsWith("```") || line.startsWith(">")) {
+      break;
+    }
+    paragraph += (paragraph ? " " : "") + line;
+  }
+  const sentenceMatch = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  if (!sentenceMatch) {
+    return null;
+  }
+  return sentenceMatch[1];
+}
+
+// lib/ideas.ts
+function parseOpenQuestions(content) {
+  const lines = content.split(`
+`);
+  const questions = [];
+  let inOpenQuestions = false;
+  let currentQuestion = null;
+  let currentOption = null;
+  let descriptionLines = [];
+  function flushOption() {
+    if (currentOption) {
+      currentOption.description = descriptionLines.join(`
+`).trim();
+      descriptionLines = [];
+      currentOption = null;
+    }
+  }
+  function flushQuestion() {
+    flushOption();
+    if (currentQuestion) {
+      questions.push(currentQuestion);
+      currentQuestion = null;
+    }
+  }
+  for (const line of lines) {
+    if (line.startsWith("## ")) {
+      if (inOpenQuestions) {
+        flushQuestion();
+      }
+      inOpenQuestions = line.trimEnd() === "## Open Questions";
+      continue;
+    }
+    if (!inOpenQuestions)
+      continue;
+    if (line.startsWith("### ")) {
+      flushQuestion();
+      currentQuestion = {
+        question: line.slice(4).trim(),
+        options: []
+      };
+      continue;
+    }
+    if (line.startsWith("#### ")) {
+      flushOption();
+      currentOption = {
+        name: line.slice(5).trim(),
+        description: ""
+      };
+      if (currentQuestion) {
+        currentQuestion.options.push(currentOption);
+      }
+      continue;
+    }
+    if (currentOption) {
+      descriptionLines.push(line);
+    }
+  }
+  flushQuestion();
+  return questions;
+}
+async function parseIdea(fileSystem, dustPath, slug) {
+  const ideaPath = `${dustPath}/ideas/${slug}.md`;
+  if (!fileSystem.exists(ideaPath)) {
+    throw new Error(`Idea not found: "${slug}" (expected file at ${ideaPath})`);
+  }
+  const content = await fileSystem.readFile(ideaPath);
+  const title = extractTitle(content);
+  if (!title) {
+    throw new Error(`Idea file has no title: ${ideaPath}`);
+  }
+  const openingSentence = extractOpeningSentence(content);
+  const openQuestions = parseOpenQuestions(content);
+  return {
+    slug,
+    title,
+    openingSentence,
+    content,
+    openQuestions
+  };
+}
+export {
+  parseOpenQuestions,
+  parseIdea
+};

package/dist/logging/index.d.ts

@@ -1,12 +1,19 @@
 /**
  * Minimal debug logging framework.
  *
- * When the DEBUG environment variable is set, matching loggers write
- * timestamped lines to `<cwd>/log/dust/<scope>.log`.
+ * Two independent output channels:
  *
- * The scope defaults to "debug" but can be changed via setLogScope()
- * so that different commands (e.g. `loop`, `check`, `bucket`) write
- * to separate log files.
+ * - **File logging** — activated by `enableFileLogs(scope)` at command startup.
+ *   Writes all logs to `./log/<scope>.log` by default. Two env vars control routing:
+ *
+ *   Routing rules for enableFileLogs(scope):
+ *   1. If DUST_LOG_FILE is already set (inherited from a parent process such as
+ *      `dust check`), use that path — all scopes land in the same file.
+ *   2. Otherwise compute the path from DUST_LOG_DIR (if set) or `<cwd>/log`, set
+ *      DUST_LOG_FILE so child processes inherit the same destination, then write there.
+ *
+ * - **Stdout logging** — activated by `DEBUG=pattern`. Writes matching logs to
+ *   stdout. Works in any command, regardless of whether file logging is enabled.
  *
  * DEBUG is a comma-separated list of match expressions. Each expression
  * can contain `*` as a wildcard (matches any sequence of characters).
@@ -21,24 +28,53 @@
  * structure under `lib/`. For example, `lib/bucket/repository-loop.ts` uses
  * the logger name `dust.bucket.repository-loop`.
  *
+ * ## Per-logger file routing
+ *
+ * `createLogger(name, { file })` accepts an optional `file` override:
+ * - `file: "path/to/file.log"` — route this logger to a dedicated file instead
+ *   of the global sink set by `enableFileLogs`. The path is resolved relative to
+ *   the log directory.
+ * - `file: false` — suppress file output for this logger entirely, even if
+ *   `enableFileLogs` has been called. Stdout behavior (DEBUG matching) is
+ *   unchanged.
+ * - When `file` is omitted, the logger uses the global file sink (if any).
+ *
+ * Sink selection precedence: per-logger sink → global sink → no file sink.
+ * File sinks are cached by path so multiple loggers targeting the same file
+ * share one sink instance.
+ *
  * No external dependencies.
  */
-import { type WriteFn } from './sink';
-export { setLogScope } from './sink';
+import { type LogSink } from './sink';
 export type LogFn = (...messages: unknown[]) => void;
+export interface LoggerOptions {
+    /**
+     * Per-logger file routing override.
+     * - `string` — path to a dedicated log file (e.g. `"./log/custom.log"`)
+     * - `false` — suppress file output for this logger
+     * - `undefined` — use the global file sink from `enableFileLogs` (default)
+     */
+    file?: string | false;
+}
+export interface LoggingService {
+    enableFileLogs(scope: string, sinkForTesting?: LogSink): void;
+    createLogger(name: string, options?: LoggerOptions): LogFn;
+    isEnabled(name: string): boolean;
+}
 /**
- * Create a named logger function. The returned function writes to
- * `log/dust/<scope>.log` when the logger name matches the DEBUG patterns.
- *
- * @param name - Logger name, e.g. `dust.bucket.loop`
- * @param write - Override the default file writer (for testing)
+ * Create an isolated logging service instance. All mutable state is
+ * encapsulated inside the returned object.
+ */
+export declare function createLoggingService(): LoggingService;
+/**
+ * Activate file logging for this command. See {@link LoggingService.enableFileLogs}.
  */
-export declare function createLogger(name: string, write?: WriteFn): LogFn;
+export declare const enableFileLogs: LoggingService['enableFileLogs'];
 /**
- * Check whether a logger name would be enabled under the current DEBUG value.
+ * Create a named logger function. See {@link LoggingService.createLogger}.
  */
-export declare function isEnabled(name: string): boolean;
+export declare const createLogger: LoggingService['createLogger'];
 /**
- * Reset internal state (for testing only).
+ * Check whether a logger name would produce stdout output under the current DEBUG value.
  */
-export declare function _reset(): void;
+export declare const isEnabled: LoggingService['isEnabled'];

package/dist/logging/sink.d.ts

@@ -1,24 +1,29 @@
 /**
  * File-based log sink — the imperative shell for debug logging.
  *
- * Lazily creates `<cwd>/log/dust/<scope>.log` and appends lines to it.
- * The scope defaults to "debug" but can be changed via setLogScope()
- * so that different commands write to separate log files.
+ * Writes log lines to an arbitrary file path, creating the directory lazily
+ * on first write. The path is determined by the caller (enableFileLogs in
+ * index.ts) rather than this class.
  */
-export type WriteFn = (line: string) => void;
-/**
- * Set the log scope, which determines the output filename.
- * Must be called before any logger writes (i.e. at command startup).
- *
- * For example, `setLogScope('loop')` writes to `log/dust/loop.log`.
- */
-export declare function setLogScope(name: string): void;
-/**
- * Write a line to the debug log file.
- * Silently no-ops if the file cannot be opened.
- */
-export declare const writeToFile: WriteFn;
-/**
- * Reset sink state (for testing only).
- */
-export declare function _resetSink(): void;
+export interface LogSink {
+    write(line: string): void;
+}
+type AppendFileSyncFn = (path: string, data: string) => void;
+type MkdirSyncFn = (path: string, options: {
+    recursive: boolean;
+}) => void;
+export declare class FileSink implements LogSink {
+    private readonly logPath;
+    private readonly _appendFileSync;
+    private readonly _mkdirSync;
+    private resolvedPath;
+    private ready;
+    constructor(logPath: string, _appendFileSync?: AppendFileSyncFn, _mkdirSync?: MkdirSyncFn);
+    private ensureLogFile;
+    /**
+     * Write a line to the log file.
+     * Silently no-ops if the file cannot be opened.
+     */
+    write(line: string): void;
+}
+export {};

package/dist/logging.js

@@ -1,3 +1,6 @@
+// lib/logging/index.ts
+import { join } from "node:path";
+
 // lib/logging/match.ts
 function parsePatterns(debug) {
   if (!debug)
@@ -20,67 +23,108 @@ function formatLine(name, messages) {
 
 // lib/logging/sink.ts
 import { appendFileSync, mkdirSync } from "node:fs";
-import { join } from "node:path";
-var logPath;
-var ready = false;
-var scope = process.env.DEBUG_LOG_SCOPE || "debug";
-function ensureLogFile() {
-  if (ready)
-    return logPath;
-  ready = true;
-  const dir = join(process.cwd(), "log", "dust");
-  logPath = join(dir, `${scope}.log`);
-  try {
-    mkdirSync(dir, { recursive: true });
-  } catch {
-    logPath = undefined;
-  }
-  return logPath;
-}
-function setLogScope(name) {
-  scope = name;
-  process.env.DEBUG_LOG_SCOPE = name;
-  logPath = undefined;
+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 {}
+  }
 }
-var writeToFile = (line) => {
-  const path = ensureLogFile();
-  if (!path)
-    return;
-  try {
-    appendFileSync(path, line);
-  } catch {}
-};
 
 // lib/logging/index.ts
-var patterns = null;
-var initialized = false;
-function init() {
-  if (initialized)
-    return;
-  initialized = true;
-  const parsed = parsePatterns(process.env.DEBUG);
-  patterns = parsed.length > 0 ? parsed : null;
-}
-function createLogger(name, write = writeToFile) {
-  return (...messages) => {
-    init();
-    if (!patterns || !matchesAny(name, patterns))
+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;
-    write(formatLine(name, messages));
+    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 ?? join(process.cwd(), "log");
+      const path = existing ?? join(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);
+    }
   };
 }
-function isEnabled(name) {
-  init();
-  return patterns !== null && matchesAny(name, patterns);
-}
-function _reset() {
-  initialized = false;
-  patterns = null;
-}
+var defaultService = createLoggingService();
+var enableFileLogs = defaultService.enableFileLogs.bind(defaultService);
+var createLogger = defaultService.createLogger.bind(defaultService);
+var isEnabled = defaultService.isEnabled.bind(defaultService);
 export {
-  setLogScope,
   isEnabled,
-  createLogger,
-  _reset
+  enableFileLogs,
+  createLoggingService,
+  createLogger
 };

package/lib/istanbul/minimal-reporter.cjs

@@ -21,25 +21,36 @@ function formatMetrics(metrics) {
   return parts.join(', ')
 }
 
-function getUncoveredLines(fileCoverage) {
+function getGapLines(fileCoverage) {
+  const gapLines = new Set()
+
   const lineCoverage = fileCoverage.getLineCoverage()
+  for (const [lineStr, hits] of Object.entries(lineCoverage)) {
+    if (hits === 0) gapLines.add(Number.parseInt(lineStr, 10))
+  }
+
+  const { branchMap, b } = fileCoverage
+  for (const [id, branch] of Object.entries(branchMap)) {
+    if (b[id].some(hits => hits === 0)) {
+      gapLines.add(branch.loc.start.line)
+    }
+  }
+
+  const sorted = [...gapLines].sort((a, b) => a - b)
   const ranges = []
   let rangeStart = null
   let rangeEnd = null
 
-  for (const [lineStr, hits] of Object.entries(lineCoverage)) {
-    const line = Number.parseInt(lineStr, 10)
-    if (hits === 0) {
-      if (rangeStart === null) {
-        rangeStart = line
-        rangeEnd = line
-      } else if (line === rangeEnd + 1) {
-        rangeEnd = line
-      } else {
-        ranges.push([rangeStart, rangeEnd])
-        rangeStart = line
-        rangeEnd = line
-      }
+  for (const line of sorted) {
+    if (rangeStart === null) {
+      rangeStart = line
+      rangeEnd = line
+    } else if (line === rangeEnd + 1) {
+      rangeEnd = line
+    } else {
+      ranges.push([rangeStart, rangeEnd])
+      rangeStart = line
+      rangeEnd = line
     }
   }
 
@@ -68,7 +79,12 @@ class IncompleteCoverageReporter extends ReportBase {
       },
     })
 
-    if (incompleteFiles.length === 0) return
+    if (incompleteFiles.length === 0) {
+      const cw = context.writer.writeFile(null)
+      cw.println('✔ 100% coverage!')
+      cw.close()
+      return
+    }
 
     const cw = context.writer.writeFile(null)
     const count = incompleteFiles.length
@@ -78,7 +94,7 @@ class IncompleteCoverageReporter extends ReportBase {
     for (const file of incompleteFiles) {
       cw.println('')
       cw.println(`${file.name} (${formatMetrics(file.metrics)})`)
-      for (const line of getUncoveredLines(file.fileCoverage)) {
+      for (const line of getGapLines(file.fileCoverage)) {
         cw.println(`- ${line}`)
       }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joshski/dust",
-  "version": "0.1.56",
+  "version": "0.1.58",
   "description": "Flow state for AI coding agents",
   "type": "module",
   "bin": {
@@ -22,6 +22,10 @@
       "import": "./dist/agents.js",
       "types": "./dist/agents/detection.d.ts"
     },
+    "./ideas": {
+      "import": "./dist/ideas.js",
+      "types": "./dist/ideas.d.ts"
+    },
     "./istanbul/minimal-reporter": "./lib/istanbul/minimal-reporter.cjs"
   },
   "files": [
@@ -42,7 +46,7 @@
   "author": "joshski",
   "license": "MIT",
   "scripts": {
-    "build": "bun build lib/cli/run.ts --target node --outfile dist/dust.js && printf '%s\\n%s' '#!/usr/bin/env node' \"$(cat dist/dust.js)\" > dist/dust.js && bun build lib/workflow-tasks.ts --target node --outfile dist/workflow-tasks.js && bun build lib/logging/index.ts --target node --outfile dist/logging.js && bun build lib/agents/detection.ts --target node --outfile dist/agents.js && bunx tsc --project tsconfig.build.json",
+    "build": "bun build lib/cli/run.ts --target node --outfile dist/dust.js && printf '%s\\n%s' '#!/usr/bin/env node' \"$(cat dist/dust.js)\" > dist/dust.js && bun build lib/workflow-tasks.ts --target node --outfile dist/workflow-tasks.js && bun build lib/logging/index.ts --target node --outfile dist/logging.js && bun build lib/agents/detection.ts --target node --outfile dist/agents.js && bun build lib/ideas.ts --target node --outfile dist/ideas.js && bunx tsc --project tsconfig.build.json",
     "test": "vitest run",
     "test:coverage": "vitest run --coverage",
     "eval": "bun run ./evals/run.ts"