@joshski/dust 0.1.102 → 0.1.104

package/.dust/principles/{enable-flow-state.md → agentic-flow-state.md}

@@ -1,14 +1,18 @@
-# Enable Flow State
+# Agentic Flow State
 
 Flow is the mental state where work becomes effortless - where you're fully immersed, losing track of time, operating at peak performance. Psychologist Mihaly Csikszentmihalyi identified three conditions that create flow: clear goals, immediate feedback, and challenge-skill balance.
 
+For AI agents, achieving flow state means staying engaged and productive without interruption. Agents enter flow when they have optimal context, comprehensive guard rails, and minimal friction. Context window optimization ensures agents have exactly what they need without cognitive overload. In-session guard rails prevent agents from straying off course or making mistakes that break their momentum.
+
 Dust's design targets these conditions directly:
 
 - **Clear goals**: Task files and lightweight planning give you a concrete target. You know exactly what you're building next.
 - **Immediate feedback**: Fast feedback loops let you see results quickly. Each change confirms you're on track or shows you what to adjust.
 - **Challenge-skill balance**: Small units of work and agent autonomy keep you in the zone - challenged enough to stay engaged, supported enough to succeed.
+- **Context window efficiency**: Progressive disclosure and artifact summarization ensure agents have the right context without overflow.
+- **Comprehensive guard rails**: Lint rules, type checks, and automated validation catch mistakes before they compound.
 
-Everything dust does serves flow. When developers stay in flow, they produce better work, sustain their energy, and enjoy the process.
+Everything dust does serves flow. When agents stay in flow, they produce better work, sustain their momentum, and complete tasks autonomously.
 
 ## Parent Principle
 

package/.dust/principles/human-ai-collaboration.md

@@ -8,7 +8,7 @@ Today's AI coding tools keep humans in a tight loop with agents. Dust is designe
 
 ## Parent Principle
 
-- [Enable Flow State](enable-flow-state.md)
+- [Agentic Flow State](agentic-flow-state.md)
 
 ## Sub-Principles
 

package/.dust/principles/maintainable-codebase.md

@@ -6,7 +6,7 @@ This principle governs how we develop and maintain dust itself, separate from th
 
 ## Parent Principle
 
-- [Enable Flow State](enable-flow-state.md)
+- [Agentic Flow State](agentic-flow-state.md)
 
 ## Sub-Principles
 

package/dist/agent-events.d.ts

@@ -50,6 +50,7 @@ export interface EventMessage {
     repository: string;
     repoId?: number;
     agentSessionId?: string;
+    traceId?: string;
     event: AgentSessionEvent;
 }
 /**

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

@@ -67,7 +67,21 @@ export interface RepositoryDependencies {
     revealFamily?: (familyName: string) => void;
     /** Shell runner for pre-flight commands (install, check) */
     shellRunner?: import('../cli/process-runner').ShellRunner;
+    /** Force Docker mode using bundled default Dockerfile */
+    forceDocker?: boolean;
+    /** 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

@@ -48,6 +48,10 @@ export interface OutputSink {
     line(text: string): void;
 }
 export interface DockerSpawnConfig {
+    /** CLI command for running containers (e.g., 'docker', 'container') */
+    runCommand?: string;
+    /** Hostname or IP the container uses to reach the host */
+    hostAddress?: string;
     /** Docker image tag to use */
     imageTag: string;
     /** Path to the repository (used for volume mounts) */
@@ -75,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

@@ -1,8 +1,12 @@
-import type { RawEvent, SpawnOptions } from '../claude/types';
+import type { DockerSpawnConfig, RawEvent, SpawnOptions } from '../claude/types';
 import type { CreateReadlineForEvents, SpawnForEvents } from '../process/spawn-contract';
 export interface EventSourceDependencies {
     spawn: SpawnForEvents;
     createInterface: CreateReadlineForEvents;
 }
 export declare const defaultDependencies: EventSourceDependencies;
-export declare function spawnCodex(prompt: string, options?: SpawnOptions, dependencies?: EventSourceDependencies): AsyncGenerator<RawEvent>;
+/**
+ * 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>;

package/dist/command-events.d.ts

@@ -53,10 +53,11 @@ export type CommandEvent = {
 export interface CommandEventMessage {
     sequence: number;
     timestamp: string;
+    traceId?: string;
     event: CommandEvent;
 }
 /**
  * Creates an event emitter function that writes command events to a callback.
  * Each event is wrapped in a CommandEventMessage envelope with sequence and timestamp.
  */
-export declare function createEventEmitter(writeEvent: (message: CommandEventMessage) => void): (event: CommandEvent) => void;
+export declare function createEventEmitter(writeEvent: (message: CommandEventMessage) => void, traceId?: string): (event: CommandEvent) => void;