@joshski/dust 0.1.103 → 0.1.104

package/dist/agents/detection.d.ts

@@ -27,4 +27,4 @@ export type AgentType = Agent['type'];
  * 3. CODEX_HOME or CODEX_CI → Codex
  * 4. Fallback → unknown Agent
  */
-export declare function detectAgent(env?: NodeJS.ProcessEnv): Agent;
+export declare function detectAgent(env: NodeJS.ProcessEnv): Agent;

package/dist/agents.js

@@ -1,5 +1,5 @@
 // lib/agents/detection.ts
-function detectAgent(env = process.env) {
+function detectAgent(env) {
   if (env.CLAUDECODE) {
     if (env.CLAUDE_CODE_REMOTE) {
       return { type: "claude-code-web", name: "Claude Code Web" };

package/dist/artifacts/facts.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableFileSystem } from '../filesystem/types';
+import type { FileReader } from '../filesystem/types';
 export interface Fact {
     slug: string;
     title: string;
@@ -7,4 +7,4 @@ export interface Fact {
 /**
  * Parses a fact markdown file into a structured Fact object.
  */
-export declare function parseFact(fileSystem: ReadableFileSystem, dustPath: string, slug: string): Promise<Fact>;
+export declare function parseFact(fileSystem: FileReader, dustPath: string, slug: string): Promise<Fact>;

package/dist/artifacts/ideas.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableFileSystem } from '../filesystem/types';
+import type { FileReader } from '../filesystem/types';
 export interface IdeaOption {
     name: string;
     description: string;
@@ -27,7 +27,7 @@ export declare function parseOpenQuestions(content: string): IdeaOpenQuestion[];
 /**
  * Parses an idea markdown file into a structured Idea object.
  */
-export declare function parseIdea(fileSystem: ReadableFileSystem, dustPath: string, slug: string): Promise<Idea>;
+export declare function parseIdea(fileSystem: FileReader, dustPath: string, slug: string): Promise<Idea>;
 /**
  * Parses idea markdown into a structured object that can be bound to a UI
  * and serialized back to markdown.

package/dist/artifacts/index.d.ts

@@ -5,8 +5,8 @@ import { extractTitle } from '../markdown/markdown-utilities';
 import { type Principle } from './principles';
 import { type Task } from './tasks';
 import { type ParsedArtifact, type ParsedMarkdownLink, type ParsedSection, parseArtifact } from './parsed-artifact';
-import { type AllWorkflowTasks, CAPTURE_IDEA_PREFIX, type CreateIdeaTransitionTaskResult, type DecomposeIdeaOptions, findAllWorkflowTasks, type IdeaInProgress, type OpenQuestionResponse, type ParsedCaptureIdeaTask, parseResolvedQuestions, type WorkflowTaskMatch, type WorkflowTaskType } from './workflow-tasks';
-export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedArtifact, ParsedCaptureIdeaTask, ParsedIdeaContent, ParsedMarkdownLink, ParsedSection, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
+import { type AllWorkflowTasks, CAPTURE_IDEA_PREFIX, type CreateIdeaTransitionTaskResult, type DecomposeIdeaOptions, findAllWorkflowTasks, type IdeaInProgress, type OpenQuestionResponse, type ParsedCaptureIdeaTask, parseResolvedQuestions, type TaskType, type WorkflowTaskMatch, type WorkflowTaskType } from './workflow-tasks';
+export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedArtifact, ParsedCaptureIdeaTask, ParsedIdeaContent, ParsedMarkdownLink, ParsedSection, Principle, Task, TaskType, WorkflowTaskMatch, WorkflowTaskType, };
 export interface TaskGraphNode {
     task: Task;
     workflowType: WorkflowTaskType | null;

package/dist/artifacts/principles.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableFileSystem } from '../filesystem/types';
+import type { FileReader } from '../filesystem/types';
 export interface Principle {
     slug: string;
     title: string;
@@ -9,4 +9,4 @@ export interface Principle {
 /**
  * Parses a principle markdown file into a structured Principle object.
  */
-export declare function parsePrinciple(fileSystem: ReadableFileSystem, dustPath: string, slug: string): Promise<Principle>;
+export declare function parsePrinciple(fileSystem: FileReader, dustPath: string, slug: string): Promise<Principle>;

package/dist/artifacts/tasks.d.ts

@@ -1,4 +1,4 @@
-import type { ReadableFileSystem } from '../filesystem/types';
+import type { FileReader } from '../filesystem/types';
 export interface Task {
     slug: string;
     title: string;
@@ -10,4 +10,4 @@ export interface Task {
 /**
  * Parses a task markdown file into a structured Task object.
  */
-export declare function parseTask(fileSystem: ReadableFileSystem, dustPath: string, slug: string): Promise<Task>;
+export declare function parseTask(fileSystem: FileReader, dustPath: string, slug: string): Promise<Task>;

package/dist/artifacts/workflow-tasks.d.ts

@@ -21,6 +21,12 @@ export interface ParsedCaptureIdeaTask {
  * 6. Add .md extension
  */
 export declare function titleToFilename(title: string): string;
+export type TaskType = 'implement' | 'capture' | 'refine' | 'decompose' | 'shelve';
+/**
+ * Extracts and validates the task type from the ## Task Type section.
+ * Returns the task type if found and valid, null otherwise.
+ */
+export declare function parseTaskType(content: string): TaskType | null;
 export type WorkflowTaskType = 'refine-idea' | 'decompose-idea' | 'shelve-idea' | 'expedite-idea';
 export interface WorkflowTaskMatch {
     type: WorkflowTaskType;

package/dist/artifacts.js

@@ -522,6 +522,54 @@ var EXPEDITE_IDEA_PREFIX = "Expedite Idea: ";
 function titleToFilename(title) {
   return `${title.toLowerCase().replace(/\./g, "-").replace(/[^a-z0-9\s-]/g, "").replace(/\s+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "")}.md`;
 }
+var VALID_TASK_TYPES = [
+  "implement",
+  "capture",
+  "refine",
+  "decompose",
+  "shelve"
+];
+function parseTaskType(content) {
+  const lines = content.split(`
+`);
+  let inSection = false;
+  let inCodeFence = false;
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      continue;
+    }
+    if (inCodeFence)
+      continue;
+    if (line.startsWith("## ")) {
+      inSection = line.trimEnd() === "## Task Type";
+      continue;
+    }
+    if (!inSection)
+      continue;
+    if (line.startsWith("# "))
+      break;
+    const trimmed = line.trim();
+    if (trimmed && VALID_TASK_TYPES.includes(trimmed)) {
+      return trimmed;
+    }
+  }
+  return null;
+}
+function taskTypeToWorkflowType(taskType) {
+  switch (taskType) {
+    case "refine":
+      return "refine-idea";
+    case "decompose":
+      return "decompose-idea";
+    case "shelve":
+      return "shelve-idea";
+    case "implement":
+      return "expedite-idea";
+    default:
+      return null;
+  }
+}
 var WORKFLOW_HINT_PATHS = {
   "refine-idea": "config/hints/refine-idea.md",
   "decompose-idea": "config/hints/decompose-idea.md",
@@ -588,16 +636,32 @@ async function findAllWorkflowTasks(fileSystem, dustPath) {
       continue;
     const title = titleMatch[1].trim();
     const taskSlug = file.replace(/\.md$/, "");
-    if (title.startsWith(CAPTURE_IDEA_PREFIX)) {
-      captureIdeaTasks.push({
-        taskSlug,
-        ideaTitle: title.slice(CAPTURE_IDEA_PREFIX.length)
-      });
-    } else if (title.startsWith(EXPEDITE_IDEA_PREFIX)) {
-      captureIdeaTasks.push({
-        taskSlug,
-        ideaTitle: title.slice(EXPEDITE_IDEA_PREFIX.length)
-      });
+    const taskType = parseTaskType(content);
+    if (taskType === "capture" || taskType === "implement") {
+      let ideaTitle = null;
+      if (title.startsWith(CAPTURE_IDEA_PREFIX)) {
+        ideaTitle = title.slice(CAPTURE_IDEA_PREFIX.length);
+      } else if (title.startsWith(EXPEDITE_IDEA_PREFIX)) {
+        ideaTitle = title.slice(EXPEDITE_IDEA_PREFIX.length);
+      }
+      if (ideaTitle) {
+        captureIdeaTasks.push({
+          taskSlug,
+          ideaTitle
+        });
+      }
+    } else if (!taskType) {
+      if (title.startsWith(CAPTURE_IDEA_PREFIX)) {
+        captureIdeaTasks.push({
+          taskSlug,
+          ideaTitle: title.slice(CAPTURE_IDEA_PREFIX.length)
+        });
+      } else if (title.startsWith(EXPEDITE_IDEA_PREFIX)) {
+        captureIdeaTasks.push({
+          taskSlug,
+          ideaTitle: title.slice(EXPEDITE_IDEA_PREFIX.length)
+        });
+      }
     }
     for (const { type, heading } of WORKFLOW_SECTION_HEADINGS) {
       const linkedSlug = extractIdeaSlugFromSection(content, heading);
@@ -625,17 +689,49 @@ async function findWorkflowTaskForIdea(fileSystem, dustPath, ideaSlug) {
   const files = await fileSystem.readdir(tasksPath);
   for (const file of files.filter((f) => f.endsWith(".md")).toSorted()) {
     const content = await fileSystem.readFile(`${tasksPath}/${file}`);
-    for (const { type, heading } of WORKFLOW_SECTION_HEADINGS) {
-      const linkedSlug = extractIdeaSlugFromSection(content, heading);
-      if (linkedSlug === ideaSlug) {
-        const taskSlug = file.replace(/\.md$/, "");
-        return {
-          type,
-          ideaSlug,
-          taskSlug,
-          resolvedQuestions: parseResolvedQuestions(content)
-        };
-      }
+    const taskSlug = file.replace(/\.md$/, "");
+    const match = findWorkflowMatch(content, ideaSlug, taskSlug);
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+}
+function findWorkflowMatch(content, ideaSlug, taskSlug) {
+  const taskType = parseTaskType(content);
+  if (taskType) {
+    const workflowType = taskTypeToWorkflowType(taskType);
+    if (workflowType) {
+      const match = findWorkflowMatchByType(content, ideaSlug, taskSlug, workflowType);
+      if (match)
+        return match;
+    }
+  }
+  for (const { type, heading } of WORKFLOW_SECTION_HEADINGS) {
+    const linkedSlug = extractIdeaSlugFromSection(content, heading);
+    if (linkedSlug === ideaSlug) {
+      return {
+        type,
+        ideaSlug,
+        taskSlug,
+        resolvedQuestions: parseResolvedQuestions(content)
+      };
+    }
+  }
+  return null;
+}
+function findWorkflowMatchByType(content, ideaSlug, taskSlug, workflowType) {
+  for (const { type, heading } of WORKFLOW_SECTION_HEADINGS) {
+    if (type !== workflowType)
+      continue;
+    const linkedSlug = extractIdeaSlugFromSection(content, heading);
+    if (linkedSlug === ideaSlug) {
+      return {
+        type: workflowType,
+        ideaSlug,
+        taskSlug,
+        resolvedQuestions: parseResolvedQuestions(content)
+      };
     }
   }
   return null;
@@ -719,7 +815,7 @@ function renderRepositoryHintsSection(repositoryHint) {
 ${repositoryHint}
 `;
 }
-function renderTask(title, openingSentence, definitionOfDone, ideaSection, options) {
+function renderTask(title, openingSentence, definitionOfDone, ideaSection, taskType, options) {
   const descriptionParagraph = options?.description !== undefined ? `
 ${options.description}
 ` : "";
@@ -733,7 +829,12 @@ ${renderIdeaSection(ideaSection)}
   return `# ${title}
 
 ${openingSentence}
-${descriptionParagraph}${resolvedSection}${ideaSectionContent}## Blocked By
+${descriptionParagraph}${resolvedSection}${ideaSectionContent}
+## Task Type
+
+${taskType}
+
+## Blocked By
 
 (none)
 ${repositoryHintsSection}
@@ -752,7 +853,8 @@ async function createIdeaTransitionTask(fileSystem, dustPath, workflowType, pref
   const baseOpeningSentence = openingSentenceTemplate(ideaTitle);
   const hint = await readWorkflowHint(fileSystem, dustPath, workflowType);
   const ideaSection = { heading: ideaSectionHeading, ideaTitle, ideaSlug };
-  const content = renderTask(taskTitle, baseOpeningSentence, definitionOfDone, ideaSection, {
+  const taskType = workflowType === "refine-idea" ? "refine" : workflowType === "decompose-idea" ? "decompose" : workflowType === "shelve-idea" ? "shelve" : "implement";
+  const content = renderTask(taskTitle, baseOpeningSentence, definitionOfDone, ideaSection, taskType, {
     description: taskOptions?.description,
     resolvedQuestions: taskOptions?.resolvedQuestions,
     repositoryHint: hint ?? undefined
@@ -818,6 +920,10 @@ ${baseOpeningSentence2}
 
 ${description}
 
+## Task Type
+
+implement
+
 ## Blocked By
 
 (none)
@@ -846,6 +952,10 @@ ${baseOpeningSentence}
 
 ${description}
 
+## Task Type
+
+capture
+
 ## Blocked By
 
 (none)
@@ -873,9 +983,16 @@ async function parseCaptureIdeaTask(fileSystem, dustPath, taskSlug) {
     return null;
   }
   const title = titleMatch[1].trim();
+  const taskType = parseTaskType(content);
   let ideaTitle;
   let expedite;
-  if (title.startsWith(EXPEDITE_IDEA_PREFIX)) {
+  if (taskType === "implement") {
+    expedite = true;
+    ideaTitle = title.startsWith(EXPEDITE_IDEA_PREFIX) ? title.slice(EXPEDITE_IDEA_PREFIX.length) : title;
+  } else if (taskType === "capture") {
+    expedite = false;
+    ideaTitle = title.startsWith(CAPTURE_IDEA_PREFIX) ? title.slice(CAPTURE_IDEA_PREFIX.length) : title;
+  } else if (title.startsWith(EXPEDITE_IDEA_PREFIX)) {
     ideaTitle = title.slice(EXPEDITE_IDEA_PREFIX.length);
     expedite = true;
   } else if (title.startsWith(CAPTURE_IDEA_PREFIX)) {

package/dist/audits/index.d.ts

@@ -32,6 +32,7 @@ export interface AuditsRepository {
 /**
  * Transforms audit template content for the task file.
  * Changes the title from "# Original Title" to "# Audit: Original Title"
+ * and adds the Task Type section.
  */
 export declare function transformAuditContent(content: string): string;
 /**

package/dist/audits.js

@@ -2497,7 +2497,30 @@ function transformAuditContent(content) {
     return content;
   }
   const originalTitle = titleMatch[1];
-  return content.replace(/^#\s+.+$/m, `# Audit: ${originalTitle}`);
+  let transformed = content.replace(/^#\s+.+$/m, `# Audit: ${originalTitle}`);
+  const lines = transformed.split(`
+`);
+  let inCodeFence = false;
+  let blockedByIndex = -1;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      continue;
+    }
+    if (inCodeFence)
+      continue;
+    if (line === "## Blocked By") {
+      blockedByIndex = i;
+      break;
+    }
+  }
+  if (blockedByIndex !== -1) {
+    lines.splice(blockedByIndex, 0, "## Task Type", "", "implement", "");
+    transformed = lines.join(`
+`);
+  }
+  return transformed;
 }
 function injectComment(content, comment) {
   const scopeMatch = content.match(/\n## Scope\n/);

package/dist/bucket/repository-loop.d.ts

@@ -5,8 +5,8 @@
  * for a single repository.
  */
 import type { EventMessage } from '../agent-events';
-import { type run as claudeRun, type RunnerDependencies } from '../claude/run';
-import type { OutputSink } from '../claude/types';
+import { type RunnerDependencies } from '../claude/run';
+import type { BoundRunFn, OutputSink } from '../claude/types';
 import { type LoopEmitFn } from '../loop/events';
 import type { SendAgentEventFn } from '../loop/wire-events';
 import { type RunnerDependencies as CodexRunnerDependencies, run as codexRun } from '../codex/run';
@@ -64,11 +64,11 @@ export declare function createStdoutSinkFactory(loopState: LoopState, logBuffer:
 /**
  * Create a run function that redirects Claude output to a log buffer.
  */
-export declare function createBufferRun(run: RepositoryDependencies['run'], bufferSinkDeps: RunnerDependencies): typeof claudeRun;
+export declare function createBufferRun(run: RepositoryDependencies['run'], bufferSinkDeps: RunnerDependencies): BoundRunFn;
 /**
  * Create a run function that redirects Codex output to a log buffer.
  */
-export declare function createCodexBufferRun(run: typeof codexRun, codexBufferSinkDeps: CodexRunnerDependencies): typeof claudeRun;
+export declare function createCodexBufferRun(run: typeof codexRun, codexBufferSinkDeps: CodexRunnerDependencies): BoundRunFn;
 /** No-op postEvent for LoopDependencies. */
 export declare function noOpPostEvent(): Promise<void>;
 /**

package/dist/bucket/repository.d.ts

@@ -72,6 +72,16 @@ export interface RepositoryDependencies {
     /** Force Apple Container mode using bundled default Dockerfile */
     forceAppleContainer?: boolean;
 }
+/**
+ * Handle loop completion: transition lifecycle and reset agent status.
+ * Extracted as a named function for testability.
+ */
+export declare function handleLoopFinished(repoState: RepositoryState): void;
+/**
+ * Create a cancel function for a running repository loop.
+ * Extracted as a named function for testability.
+ */
+export declare function createLoopCancel(repoState: RepositoryState): () => void;
 /**
  * Start (or restart) the per-repository loop and keep lifecycle state accurate.
  */

package/dist/claude/run.d.ts

@@ -1,15 +1,9 @@
-import { spawnClaudeCode as defaultSpawnClaudeCode } from './spawn-claude-code';
 import { createStdoutSink as defaultCreateStdoutSink, streamEvents as defaultStreamEvents } from './streamer';
-import type { RawEventCallback, SpawnOptions } from './types';
-interface RunOptions {
-    spawnOptions?: SpawnOptions;
-    onRawEvent?: RawEventCallback;
-}
+import type { RawEvent, RunOptions, SpawnOptions } from './types';
 export interface RunnerDependencies {
-    spawnClaudeCode: typeof defaultSpawnClaudeCode;
+    spawnClaudeCode: (prompt: string, options: SpawnOptions) => AsyncGenerator<RawEvent>;
     createStdoutSink: typeof defaultCreateStdoutSink;
     streamEvents: typeof defaultStreamEvents;
 }
 export declare const defaultRunnerDependencies: RunnerDependencies;
-export declare function run(prompt: string, options?: SpawnOptions | RunOptions, dependencies?: RunnerDependencies): Promise<void>;
-export {};
+export declare function run(prompt: string, options: SpawnOptions | RunOptions, dependencies: RunnerDependencies): Promise<void>;

package/dist/claude/spawn-claude-code.d.ts

@@ -21,4 +21,4 @@ export declare const defaultDependencies: EventSourceDependencies;
  * Build docker run arguments for spawning claude in a container.
  */
 export declare function buildDockerRunArguments(docker: DockerSpawnConfig, claudeArguments: string[], env: Record<string, string>): string[];
-export declare function spawnClaudeCode(prompt: string, options?: SpawnOptions, dependencies?: EventSourceDependencies): AsyncGenerator<RawEvent>;
+export declare function spawnClaudeCode(prompt: string, options: SpawnOptions, dependencies: EventSourceDependencies): AsyncGenerator<RawEvent>;

package/dist/claude/types.d.ts

@@ -79,3 +79,12 @@ export interface SpawnOptions {
     docker?: DockerSpawnConfig;
 }
 export type RawEventCallback = (event: RawEvent) => void;
+export interface RunOptions {
+    spawnOptions?: SpawnOptions;
+    onRawEvent?: RawEventCallback;
+}
+/**
+ * A run function with its runner dependencies already bound.
+ * Used in LoopDependencies, AgentRunParams, etc.
+ */
+export type BoundRunFn = (prompt: string, options: SpawnOptions | RunOptions) => Promise<void>;

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

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

package/dist/cli/shared/agent-shared.d.ts

@@ -4,7 +4,7 @@
  * Provides common functionality used across all agent-* command files.
  */
 import { type AgentType } from '../../agents/detection';
-import type { CommandDependencies, DustSettings, ReadableFileSystem } from '../types';
+import type { CommandDependencies, DustSettings, FileReader } from '../types';
 /**
  * Type-safe template variables for agent commands.
  * Uses real booleans instead of string-encoded booleans.
@@ -23,14 +23,14 @@ export interface TemplateVarsWithInstructions extends TemplateVars {
  * Loads agent-specific instructions from .dust/config/agents/{agent-type}.md
  * Returns empty string if file doesn't exist.
  */
-export declare function loadAgentInstructions(cwd: string, fileSystem: ReadableFileSystem, agentType: AgentType): Promise<string>;
-export declare function templateVariables(settings: DustSettings, hooksInstalled: boolean, env?: NodeJS.ProcessEnv, options?: {
+export declare function loadAgentInstructions(cwd: string, fileSystem: FileReader, agentType: AgentType): Promise<string>;
+export declare function templateVariables(settings: DustSettings, hooksInstalled: boolean, env: NodeJS.ProcessEnv, options?: {
     hasIdeaFile?: boolean;
 }): TemplateVars;
 /**
  * Creates template variables with agent-specific instructions loaded.
  */
-export declare function templateVariablesWithInstructions(cwd: string, fileSystem: ReadableFileSystem, settings: DustSettings, hooksInstalled: boolean, env?: NodeJS.ProcessEnv, options?: {
+export declare function templateVariablesWithInstructions(cwd: string, fileSystem: FileReader, settings: DustSettings, hooksInstalled: boolean, env: NodeJS.ProcessEnv, options?: {
     hasIdeaFile?: boolean;
 }): Promise<TemplateVarsWithInstructions>;
 /**

package/dist/cli/types.d.ts

@@ -4,7 +4,7 @@
 import type { CommandEvent } from '../command-events';
 import type { RuntimeConfig } from '../env-config';
 import type { FileSystem, GlobScanner } from '../filesystem/types';
-export type { FileSystem, GlobScanner, ReadableFileSystem, } from '../filesystem/types';
+export type { FileReader, FileSystem, GlobScanner, ReadableFileSystem, } from '../filesystem/types';
 export interface CommandContext {
     cwd: string;
     stdout: (message: string) => void;

package/dist/codex/run.d.ts

@@ -1,16 +1,10 @@
 import { createStdoutSink as defaultCreateStdoutSink } from '../claude/streamer';
-import type { RawEventCallback, SpawnOptions } from '../claude/types';
-import { spawnCodex as defaultSpawnCodex } from './spawn-codex';
+import type { RawEvent, RunOptions, SpawnOptions } from '../claude/types';
 import { streamCodexEvents as defaultStreamCodexEvents } from './streamer';
-interface RunOptions {
-    spawnOptions?: SpawnOptions;
-    onRawEvent?: RawEventCallback;
-}
 export interface RunnerDependencies {
-    spawnCodex: typeof defaultSpawnCodex;
+    spawnCodex: (prompt: string, options: SpawnOptions) => AsyncGenerator<RawEvent>;
     createStdoutSink: typeof defaultCreateStdoutSink;
     streamCodexEvents: typeof defaultStreamCodexEvents;
 }
 export declare const defaultRunnerDependencies: RunnerDependencies;
-export declare function run(prompt: string, options?: SpawnOptions | RunOptions, dependencies?: RunnerDependencies): Promise<void>;
-export {};
+export declare function run(prompt: string, options: SpawnOptions | RunOptions, dependencies: RunnerDependencies): Promise<void>;

package/dist/codex/spawn-codex.d.ts

@@ -9,4 +9,4 @@ export declare const defaultDependencies: EventSourceDependencies;
  * Build docker run arguments for spawning codex in a container.
  */
 export declare function buildDockerRunArguments(docker: DockerSpawnConfig, codexArguments: string[], env: Record<string, string>): string[];
-export declare function spawnCodex(prompt: string, options?: SpawnOptions, dependencies?: EventSourceDependencies): AsyncGenerator<RawEvent>;
+export declare function spawnCodex(prompt: string, options: SpawnOptions, dependencies: EventSourceDependencies): AsyncGenerator<RawEvent>;

package/dist/config/settings.d.ts

@@ -3,7 +3,7 @@
  *
  * Reads optional configuration from .dust/config/settings.json
  */
-import type { CheckConfig, DustSettings, ReadableFileSystem } from '../cli/types';
+import type { CheckConfig, DustSettings, FileReader } from '../cli/types';
 import type { RuntimeConfig } from '../env-config';
 export type { CheckConfig, DustSettings };
 interface SettingsViolation {
@@ -19,7 +19,7 @@ export declare function validateSettingsJson(content: string): SettingsViolation
  * 4. No lockfile + BUN_INSTALL env var set → bunx dust
  * 5. Default → npx dust
  */
-export declare function detectDustCommand(cwd: string, fileSystem: ReadableFileSystem, runtime: RuntimeConfig): string;
+export declare function detectDustCommand(cwd: string, fileSystem: FileReader, runtime: RuntimeConfig): string;
 /**
  * Detects the appropriate install command based on lockfiles.
  * Returns null when:
@@ -28,7 +28,7 @@ export declare function detectDustCommand(cwd: string, fileSystem: ReadableFileS
  *
  * Priority within each ecosystem follows the order in LOCKFILE_COMMANDS.
  */
-export declare function detectInstallCommand(cwd: string, fileSystem: ReadableFileSystem): string | null;
+export declare function detectInstallCommand(cwd: string, fileSystem: FileReader): string | null;
 /**
  * Detects the appropriate test command based on lockfiles and environment.
  * Priority:
@@ -40,5 +40,5 @@ export declare function detectInstallCommand(cwd: string, fileSystem: ReadableFi
  * 6. package.json exists → npm test
  * 7. Default → null (no test command)
  */
-export declare function detectTestCommand(cwd: string, fileSystem: ReadableFileSystem, runtime: RuntimeConfig): string | null;
-export declare function loadSettings(cwd: string, fileSystem: ReadableFileSystem, runtime: RuntimeConfig): Promise<DustSettings>;
+export declare function detectTestCommand(cwd: string, fileSystem: FileReader, runtime: RuntimeConfig): string | null;
+export declare function loadSettings(cwd: string, fileSystem: FileReader, runtime: RuntimeConfig): Promise<DustSettings>;

package/dist/core-principles.js

@@ -1,7 +1,7 @@
 // lib/core-principles.ts
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-import { existsSync, readdirSync, statSync } from "node:fs";
+import { existsSync, readdirSync } from "node:fs";
 import { readFile } from "node:fs/promises";
 
 // lib/markdown/markdown-utilities.ts
@@ -111,10 +111,7 @@ function getCorePrincipleTree(allPrinciples, config) {
     if (!parentSlug || !filteredSlugs.has(parentSlug)) {
       roots.push(node);
     } else {
-      const parentNode = nodeBySlug.get(parentSlug);
-      if (parentNode) {
-        parentNode.children.push(node);
-      }
+      nodeBySlug.get(parentSlug).children.push(node);
     }
   }
   sortNodes(roots);
@@ -122,18 +119,10 @@ function getCorePrincipleTree(allPrinciples, config) {
 }
 
 // lib/core-principles.ts
-function createReadableFileSystem() {
+function createFileReader() {
   return {
     exists: existsSync,
-    isDirectory: (path) => {
-      try {
-        return statSync(path).isDirectory();
-      } catch {
-        return false;
-      }
-    },
-    readFile: (path) => readFile(path, "utf-8"),
-    readdir: async (path) => readdirSync(path)
+    readFile: (path) => readFile(path, "utf-8")
   };
 }
 function locatePackagePrinciplesDir() {
@@ -150,7 +139,7 @@ async function readAllCorePrinciples() {
   const principlesDir = locatePackagePrinciplesDir();
   const packageRoot = dirname(dirname(principlesDir));
   const dustPath = join(packageRoot, ".dust");
-  const fileSystem = createReadableFileSystem();
+  const fileSystem = createFileReader();
   const files = readdirSync(principlesDir);
   const mdFiles = files.filter((f) => f.endsWith(".md"));
   const principles = [];

package/dist/docker/docker-agent.d.ts

@@ -23,10 +23,6 @@ export declare function buildDockerImage(config: {
     success: false;
     error: string;
 }>;
-/**
- * Check if a Dockerfile exists at the legacy .dust/Dockerfile location.
- */
-export declare function hasLegacyDockerfile(repoPath: string, dependencies: ContainerDependencies): boolean;
 type ContainerPrepareEvent = {
     type: 'loop.docker_detected';
     imageTag: string;