@joshski/dust 0.1.103 → 0.1.105

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,11 +5,11 @@ 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 } from './workflow-tasks';
+export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedArtifact, ParsedCaptureIdeaTask, ParsedIdeaContent, ParsedMarkdownLink, ParsedSection, Principle, Task, TaskType, WorkflowTaskMatch, };
 export interface TaskGraphNode {
     task: Task;
-    workflowType: WorkflowTaskType | null;
+    workflowType: TaskType | null;
 }
 export interface TaskGraph {
     nodes: TaskGraphNode[];

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,9 +21,15 @@ export interface ParsedCaptureIdeaTask {
  * 6. Add .md extension
  */
 export declare function titleToFilename(title: string): string;
-export type WorkflowTaskType = 'refine-idea' | 'decompose-idea' | 'shelve-idea' | 'expedite-idea';
+export declare const VALID_TASK_TYPES: readonly ["implement", "capture", "refine", "decompose", "shelve"];
+export type TaskType = (typeof VALID_TASK_TYPES)[number];
+/**
+ * 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 interface WorkflowTaskMatch {
-    type: WorkflowTaskType;
+    type: TaskType;
     ideaSlug: string;
     taskSlug: string;
     resolvedQuestions: OpenQuestionResponse[];

package/dist/artifacts.js

@@ -522,25 +522,59 @@ 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;
+}
 var WORKFLOW_HINT_PATHS = {
-  "refine-idea": "config/hints/refine-idea.md",
-  "decompose-idea": "config/hints/decompose-idea.md",
-  "shelve-idea": "config/hints/shelve-idea.md",
-  "add-idea": "config/hints/add-idea.md",
-  "expedite-idea": "config/hints/expedite-idea.md"
+  refine: "config/hints/refine-idea.md",
+  decompose: "config/hints/decompose-idea.md",
+  shelve: "config/hints/shelve-idea.md",
+  capture: "config/hints/add-idea.md",
+  implement: "config/hints/expedite-idea.md"
 };
-async function readWorkflowHint(fileSystem, dustPath, workflowType) {
-  const hintPath = `${dustPath}/${WORKFLOW_HINT_PATHS[workflowType]}`;
+async function readWorkflowHint(fileSystem, dustPath, taskType) {
+  const hintPath = `${dustPath}/${WORKFLOW_HINT_PATHS[taskType]}`;
   if (!fileSystem.exists(hintPath)) {
     return null;
   }
   return fileSystem.readFile(hintPath);
 }
 var WORKFLOW_SECTION_HEADINGS = [
-  { type: "refine-idea", heading: "Refines Idea" },
-  { type: "decompose-idea", heading: "Decomposes Idea" },
-  { type: "shelve-idea", heading: "Shelves Idea" },
-  { type: "expedite-idea", heading: "Expedites Idea" }
+  { type: "refine", heading: "Refines Idea" },
+  { type: "decompose", heading: "Decomposes Idea" },
+  { type: "shelve", heading: "Shelves Idea" },
+  { type: "implement", heading: "Expedites Idea" }
 ];
 function extractIdeaSlugFromSection(content, sectionHeading) {
   const lines = content.split(`
@@ -588,16 +622,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,12 +675,23 @@ 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 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 heading = WORKFLOW_SECTION_HEADINGS.find((h) => h.type === taskType)?.heading;
+    if (heading) {
       const linkedSlug = extractIdeaSlugFromSection(content, heading);
       if (linkedSlug === ideaSlug) {
-        const taskSlug = file.replace(/\.md$/, "");
         return {
-          type,
+          type: taskType,
           ideaSlug,
           taskSlug,
           resolvedQuestions: parseResolvedQuestions(content)
@@ -638,6 +699,17 @@ async function findWorkflowTaskForIdea(fileSystem, dustPath, ideaSlug) {
       }
     }
   }
+  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;
 }
 async function readIdeaTitle(fileSystem, dustPath, ideaSlug) {
@@ -719,7 +791,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 +805,12 @@ ${renderIdeaSection(ideaSection)}
   return `# ${title}
 
 ${openingSentence}
-${descriptionParagraph}${resolvedSection}${ideaSectionContent}## Blocked By
+${descriptionParagraph}${resolvedSection}${ideaSectionContent}
+## Task Type
+
+${taskType}
+
+## Blocked By
 
 (none)
 ${repositoryHintsSection}
@@ -744,15 +821,15 @@ ${definitionOfDone.map((item) => `- ${item}`).join(`
 `)}
 `;
 }
-async function createIdeaTransitionTask(fileSystem, dustPath, workflowType, prefix, ideaSlug, openingSentenceTemplate, definitionOfDone, ideaSectionHeading, taskOptions) {
+async function createIdeaTransitionTask(fileSystem, dustPath, taskType, prefix, ideaSlug, openingSentenceTemplate, definitionOfDone, ideaSectionHeading, taskOptions) {
   const ideaTitle = await readIdeaTitle(fileSystem, dustPath, ideaSlug);
   const taskTitle = `${prefix}${ideaTitle}`;
   const filename = titleToFilename(taskTitle);
   const filePath = `${dustPath}/tasks/${filename}`;
   const baseOpeningSentence = openingSentenceTemplate(ideaTitle);
-  const hint = await readWorkflowHint(fileSystem, dustPath, workflowType);
+  const hint = await readWorkflowHint(fileSystem, dustPath, taskType);
   const ideaSection = { heading: ideaSectionHeading, ideaTitle, ideaSlug };
-  const content = renderTask(taskTitle, baseOpeningSentence, definitionOfDone, ideaSection, {
+  const content = renderTask(taskTitle, baseOpeningSentence, definitionOfDone, ideaSection, taskType, {
     description: taskOptions?.description,
     resolvedQuestions: taskOptions?.resolvedQuestions,
     repositoryHint: hint ?? undefined
@@ -762,7 +839,7 @@ async function createIdeaTransitionTask(fileSystem, dustPath, workflowType, pref
 }
 async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description, openQuestionResponses, dustCommand) {
   const cmd = dustCommand ?? "dust";
-  return createIdeaTransitionTask(fileSystem, dustPath, "refine-idea", "Refine Idea: ", ideaSlug, (ideaTitle) => `Thoroughly research this idea and refine it into a well-defined proposal. Read the idea file, explore the codebase for relevant context, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. Run \`${cmd} principles\` for alignment and \`${cmd} facts\` for relevant design decisions. See [${ideaTitle}](../ideas/${ideaSlug}.md). If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking.`, [
+  return createIdeaTransitionTask(fileSystem, dustPath, "refine", "Refine Idea: ", ideaSlug, (ideaTitle) => `Thoroughly research this idea and refine it into a well-defined proposal. Read the idea file, explore the codebase for relevant context, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. Run \`${cmd} principles\` for alignment and \`${cmd} facts\` for relevant design decisions. See [${ideaTitle}](../ideas/${ideaSlug}.md). If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking.`, [
     "Idea is thoroughly researched with relevant codebase context",
     "Open questions are added for any ambiguous or underspecified aspects",
     "Open questions follow the required heading format and focus on high-value decisions",
@@ -774,7 +851,7 @@ async function createRefineIdeaTask(fileSystem, dustPath, ideaSlug, description,
 }
 async function decomposeIdea(fileSystem, dustPath, options, dustCommand) {
   const cmd = dustCommand ?? "dust";
-  return createIdeaTransitionTask(fileSystem, dustPath, "decompose-idea", "Decompose Idea: ", options.ideaSlug, (ideaTitle) => `Create one or more well-defined tasks from this idea. Prefer smaller, narrowly scoped tasks that each deliver a thin but complete vertical slice of working software -- a path through the system that can be tested end-to-end -- rather than component-oriented tasks (like "add schema" or "build endpoint") that only work once all tasks are done. Split the idea into multiple tasks if it covers more than one logical change. Run \`${cmd} principles\` to link relevant principles and \`${cmd} facts\` for design decisions that should inform the task. See [${ideaTitle}](../ideas/${options.ideaSlug}.md).`, [
+  return createIdeaTransitionTask(fileSystem, dustPath, "decompose", "Decompose Idea: ", options.ideaSlug, (ideaTitle) => `Create one or more well-defined tasks from this idea. Prefer smaller, narrowly scoped tasks that each deliver a thin but complete vertical slice of working software -- a path through the system that can be tested end-to-end -- rather than component-oriented tasks (like "add schema" or "build endpoint") that only work once all tasks are done. Split the idea into multiple tasks if it covers more than one logical change. Run \`${cmd} principles\` to link relevant principles and \`${cmd} facts\` for design decisions that should inform the task. See [${ideaTitle}](../ideas/${options.ideaSlug}.md).`, [
     "One or more new tasks are created in .dust/tasks/",
     "Task's Principles section links to relevant principles from .dust/principles/",
     "The original idea is deleted or updated to reflect remaining scope"
@@ -784,11 +861,11 @@ async function decomposeIdea(fileSystem, dustPath, options, dustCommand) {
   });
 }
 async function createShelveIdeaTask(fileSystem, dustPath, ideaSlug, description, _dustCommand) {
-  return createIdeaTransitionTask(fileSystem, dustPath, "shelve-idea", "Shelve Idea: ", ideaSlug, (ideaTitle) => `Archive this idea and remove it from the active backlog. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, ["Idea file is deleted", "Rationale is recorded in the commit message"], "Shelves Idea", { description });
+  return createIdeaTransitionTask(fileSystem, dustPath, "shelve", "Shelve Idea: ", ideaSlug, (ideaTitle) => `Archive this idea and remove it from the active backlog. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, ["Idea file is deleted", "Rationale is recorded in the commit message"], "Shelves Idea", { description });
 }
 async function createExpediteIdeaTask(fileSystem, dustPath, ideaSlug, description, dustCommand) {
   const cmd = dustCommand ?? "dust";
-  return createIdeaTransitionTask(fileSystem, dustPath, "expedite-idea", "Expedite Idea: ", ideaSlug, (ideaTitle) => `Research this idea briefly. If confident the implementation is straightforward (clear scope, minimal risk, no open questions), implement directly and commit. Otherwise, create one or more narrowly-scoped task files in \`.dust/tasks/\`. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, [
+  return createIdeaTransitionTask(fileSystem, dustPath, "implement", "Expedite Idea: ", ideaSlug, (ideaTitle) => `Research this idea briefly. If confident the implementation is straightforward (clear scope, minimal risk, no open questions), implement directly and commit. Otherwise, create one or more narrowly-scoped task files in \`.dust/tasks/\`. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context. See [${ideaTitle}](../ideas/${ideaSlug}.md).`, [
     "Idea is implemented directly OR one or more new tasks are created in `.dust/tasks/`",
     "If tasks were created, they link to relevant principles from `.dust/principles/`",
     "Changes are committed with a clear commit message"
@@ -808,7 +885,7 @@ async function createIdeaTask(fileSystem, dustPath, options) {
     const filename2 = titleToFilename(taskTitle2);
     const filePath2 = `${dustPath}/tasks/${filename2}`;
     const baseOpeningSentence2 = `Research this idea briefly. If confident the implementation is straightforward (clear scope, minimal risk, no open questions), implement directly and commit. Otherwise, create one or more narrowly-scoped task files in \`.dust/tasks/\`. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context.`;
-    const hint2 = await readWorkflowHint(fileSystem, dustPath, "expedite-idea");
+    const hint2 = await readWorkflowHint(fileSystem, dustPath, "implement");
     const repositoryHintsSection2 = renderRepositoryHintsSection(hint2 ?? undefined);
     const content2 = `# ${taskTitle2}
 
@@ -818,6 +895,10 @@ ${baseOpeningSentence2}
 
 ${description}
 
+## Task Type
+
+implement
+
 ## Blocked By
 
 (none)
@@ -836,7 +917,7 @@ ${repositoryHintsSection2}
   const filename = titleToFilename(taskTitle);
   const filePath = `${dustPath}/tasks/${filename}`;
   const baseOpeningSentence = `Research this idea thoroughly, then create one or more idea files in \`.dust/ideas/\`. Read the codebase for relevant context, flesh out the description, and identify any ambiguity. Where aspects are unclear or could go multiple ways, add open questions to the idea file. If you add open questions, use \`## Open Questions\` with \`### Question?\` headings and one or more \`#### Option\` headings beneath each question, and only add questions that are meaningful decisions worth asking. Run \`${cmd} principles\` and \`${cmd} facts\` for relevant context.`;
-  const hint = await readWorkflowHint(fileSystem, dustPath, "add-idea");
+  const hint = await readWorkflowHint(fileSystem, dustPath, "capture");
   const repositoryHintsSection = renderRepositoryHintsSection(hint ?? undefined);
   const content = `# ${taskTitle}
 
@@ -846,6 +927,10 @@ ${baseOpeningSentence}
 
 ${description}
 
+## Task Type
+
+capture
+
 ## Blocked By
 
 (none)
@@ -873,9 +958,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>;