@joshski/dust 0.1.96 → 0.1.98

package/dist/agent-events.d.ts

@@ -29,6 +29,19 @@ export type AgentSessionEvent = {
 } | {
     type: 'command-event';
     commandEvent: CommandEvent;
+} | {
+    type: 'preflight-started';
+    step: string;
+    title?: string;
+} | {
+    type: 'preflight-completed';
+    step: string;
+    output?: string;
+} | {
+    type: 'preflight-failed';
+    step: string;
+    output: string;
+    title?: string;
 };
 export interface EventMessage {
     sequence: number;

package/dist/artifacts/ideas.d.ts

@@ -14,6 +14,11 @@ export interface Idea {
     content: string;
     openQuestions: IdeaOpenQuestion[];
 }
+export interface ParsedIdeaContent {
+    title: string | null;
+    body: string;
+    openQuestions: IdeaOpenQuestion[];
+}
 /**
  * Parses the ## Open Questions section from idea markdown content.
  * Extracts each ### question heading and its #### option children.
@@ -23,3 +28,15 @@ 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>;
+/**
+ * Parses idea markdown into a structured object that can be bound to a UI
+ * and serialized back to markdown.
+ */
+export declare function parseIdeaContent(markdown: string): ParsedIdeaContent;
+/**
+ * Serializes a ParsedIdeaContent back to markdown.
+ * Open Questions are appended as the last section.
+ */
+export declare function ideaContentToMarkdown(content: ParsedIdeaContent, options?: {
+    includeOpenQuestions?: boolean;
+}): string;

package/dist/artifacts/index.d.ts

@@ -1,10 +1,12 @@
 import type { FileSystem, ReadableFileSystem } from '../filesystem/types';
 import { type Fact } from './facts';
-import { type Idea, type IdeaOpenQuestion, type IdeaOption, parseOpenQuestions } from './ideas';
+import { type Idea, type IdeaOpenQuestion, type IdeaOption, type ParsedIdeaContent, ideaContentToMarkdown, parseIdeaContent, parseOpenQuestions } from './ideas';
+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, ParsedCaptureIdeaTask, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
+export type { AllWorkflowTasks, CreateIdeaTransitionTaskResult, DecomposeIdeaOptions, Fact, Idea, IdeaOpenQuestion, IdeaOption, OpenQuestionResponse, ParsedArtifact, ParsedCaptureIdeaTask, ParsedIdeaContent, ParsedMarkdownLink, ParsedSection, Principle, Task, WorkflowTaskMatch, WorkflowTaskType, };
 export interface TaskGraphNode {
     task: Task;
     workflowType: WorkflowTaskType | null;
@@ -16,9 +18,19 @@ export interface TaskGraph {
         to: string;
     }>;
 }
-export { CAPTURE_IDEA_PREFIX, findAllWorkflowTasks, parseOpenQuestions, parseResolvedQuestions, };
+export { CAPTURE_IDEA_PREFIX, extractTitle, findAllWorkflowTasks, ideaContentToMarkdown, parseArtifact, parseIdeaContent, parseOpenQuestions, parseResolvedQuestions, };
 export type { IdeaInProgress };
 export type ArtifactType = 'ideas' | 'tasks' | 'principles' | 'facts';
+export declare const DUST_PATH_PREFIX = ".dust/";
+/**
+ * Parses an artifact path into its type and slug components.
+ * This is the inverse of ArtifactsRepository.artifactPath().
+ * Works with relative paths (e.g., '.dust/tasks/my-task.md').
+ */
+export declare function parseArtifactPath(path: string): {
+    type: ArtifactType;
+    slug: string;
+} | null;
 export interface ReadOnlyArtifactsRepository {
     artifactPath(type: ArtifactType, slug: string): string;
     parseIdea(options: {

package/dist/artifacts/parsed-artifact.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Parsed artifact types with positional metadata for validation.
+ *
+ * These types enrich artifact parsing with line numbers to support
+ * single-pass validation and better error reporting.
+ */
+export interface ParsedMarkdownLink {
+    text: string;
+    target: string;
+    line: number;
+}
+export interface ParsedSection {
+    heading: string;
+    level: number;
+    startLine: number;
+    endLine: number;
+    links: ParsedMarkdownLink[];
+}
+export interface ParsedArtifact {
+    filePath: string;
+    rawContent: string;
+    title: string | null;
+    titleLine: number | null;
+    openingSentence: string | null;
+    openingSentenceLine: number | null;
+    sections: ParsedSection[];
+    allLinks: ParsedMarkdownLink[];
+}
+/**
+ * Parses markdown content into a ParsedArtifact with positional metadata.
+ */
+export declare function parseArtifact(filePath: string, content: string): ParsedArtifact;

package/dist/artifacts.js

@@ -4,50 +4,68 @@ function extractTitle(content) {
   return match ? match[1].trim() : null;
 }
 var MARKDOWN_LINK_PATTERN = /\[([^\]]+)\]\(([^)]+)\)/;
-function extractOpeningSentence(content) {
-  const lines = content.split(`
-`);
-  let h1Index = -1;
+function findH1Index(lines) {
   for (let i = 0;i < lines.length; i++) {
     if (lines[i].match(/^#\s+.+$/)) {
-      h1Index = i;
-      break;
+      return i;
     }
   }
-  if (h1Index === -1) {
-    return null;
+  return -1;
+}
+function findFirstNonBlankLineAfter(lines, startIndex) {
+  for (let i = startIndex + 1;i < lines.length; i++) {
+    if (lines[i].trim() !== "") {
+      return i;
+    }
+  }
+  return -1;
+}
+var LIST_ITEM_PREFIXES = ["-", "*", "+"];
+var STRUCTURAL_PREFIXES = ["#", "```", ">"];
+function isStructuralElement(line) {
+  if (STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  if (LIST_ITEM_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
   }
-  let paragraphStart = -1;
-  for (let i = h1Index + 1;i < lines.length; i++) {
+  return /^\d+\./.test(line);
+}
+function isBlockBreak(line) {
+  return STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix));
+}
+function collectParagraph(lines, startIndex) {
+  const parts = [];
+  for (let i = startIndex;i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line !== "") {
-      paragraphStart = i;
+    if (line === "" || isBlockBreak(line)) {
       break;
     }
+    parts.push(line);
   }
-  if (paragraphStart === -1) {
+  return parts.join(" ");
+}
+function extractFirstSentence(paragraph) {
+  const match = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  return match ? match[1] : null;
+}
+function extractOpeningSentence(content) {
+  const lines = content.split(`
+`);
+  const h1Index = findH1Index(lines);
+  if (h1Index === -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(">")) {
+  const paragraphStart = findFirstNonBlankLineAfter(lines, h1Index);
+  if (paragraphStart === -1) {
     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) {
+  const trimmedFirstLine = lines[paragraphStart].trim();
+  if (isStructuralElement(trimmedFirstLine)) {
     return null;
   }
-  return sentenceMatch[1];
+  const paragraph = collectParagraph(lines, paragraphStart);
+  return extractFirstSentence(paragraph);
 }
 
 // lib/artifacts/facts.ts
@@ -162,6 +180,83 @@ async function parseIdea(fileSystem, dustPath, slug) {
     openQuestions
   };
 }
+function stripOpenQuestionsSection(content) {
+  const lines = content.split(`
+`);
+  const result = [];
+  let inOpenQuestions = false;
+  let inCodeFence = false;
+  for (const line of lines) {
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      if (!inOpenQuestions)
+        result.push(line);
+      continue;
+    }
+    if (inCodeFence) {
+      if (!inOpenQuestions)
+        result.push(line);
+      continue;
+    }
+    if (line.startsWith("## ")) {
+      inOpenQuestions = line.trimEnd() === "## Open Questions";
+      if (!inOpenQuestions)
+        result.push(line);
+      continue;
+    }
+    if (!inOpenQuestions) {
+      result.push(line);
+    }
+  }
+  while (result.length > 0 && result[result.length - 1].trim() === "") {
+    result.pop();
+  }
+  return result.join(`
+`) + `
+`;
+}
+function stripTitle(content) {
+  const match = content.match(/^#\s+.+\n+/);
+  if (!match)
+    return content;
+  return content.slice(match[0].length);
+}
+function parseIdeaContent(markdown) {
+  const title = extractTitle(markdown);
+  const openQuestions = parseOpenQuestions(markdown);
+  const body = stripTitle(stripOpenQuestionsSection(markdown));
+  return { title, body, openQuestions };
+}
+function ideaContentToMarkdown(content, options) {
+  const includeOQ = options?.includeOpenQuestions ?? true;
+  const parts = [];
+  if (content.title) {
+    parts.push(`# ${content.title}`);
+    parts.push("");
+  }
+  if (content.body) {
+    parts.push(content.body.trimEnd());
+    parts.push("");
+  }
+  if (includeOQ && content.openQuestions.length > 0) {
+    parts.push("## Open Questions");
+    parts.push("");
+    for (const q of content.openQuestions) {
+      parts.push(`### ${q.question}`);
+      parts.push("");
+      for (const o of q.options) {
+        parts.push(`#### ${o.name}`);
+        parts.push("");
+        if (o.description) {
+          parts.push(o.description);
+          parts.push("");
+        }
+      }
+    }
+  }
+  return parts.join(`
+`);
+}
 
 // lib/artifacts/principles.ts
 function extractLinksFromSection(content, sectionHeading) {
@@ -284,6 +379,143 @@ async function parseTask(fileSystem, dustPath, slug) {
   };
 }
 
+// lib/artifacts/parsed-artifact.ts
+var MARKDOWN_LINK_PATTERN2 = /\[([^\]]+)\]\(([^)]+)\)/g;
+function parseArtifact(filePath, content) {
+  const lines = content.split(`
+`);
+  let title = null;
+  let titleLine = null;
+  let openingSentence = null;
+  let openingSentenceLine = null;
+  const sections = [];
+  const allLinks = [];
+  let currentSection = null;
+  let inCodeFence = false;
+  let openingSentenceResolved = false;
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    if (line.startsWith("```")) {
+      inCodeFence = !inCodeFence;
+      continue;
+    }
+    if (inCodeFence) {
+      continue;
+    }
+    const h1Match = line.match(/^#\s+(.+)$/);
+    if (h1Match) {
+      if (title === null) {
+        title = h1Match[1].trim();
+        titleLine = lineNumber;
+      } else {
+        if (currentSection !== null) {
+          currentSection.endLine = findLastNonEmptyLine(lines, currentSection.startLine, lineNumber - 2);
+          sections.push(currentSection);
+          currentSection = null;
+        }
+      }
+      continue;
+    }
+    const headingMatch = line.match(/^(#{2,6})\s+(.+)$/);
+    if (headingMatch) {
+      openingSentenceResolved = true;
+      if (currentSection !== null) {
+        currentSection.endLine = findLastNonEmptyLine(lines, currentSection.startLine, lineNumber - 2);
+        sections.push(currentSection);
+      }
+      currentSection = {
+        heading: headingMatch[2].trim(),
+        level: headingMatch[1].length,
+        startLine: lineNumber,
+        endLine: -1,
+        links: []
+      };
+      continue;
+    }
+    if (shouldCheckForOpeningSentence(title, openingSentenceResolved, line)) {
+      const result = tryExtractOpeningSentence(lines, i);
+      openingSentence = result.sentence;
+      openingSentenceLine = result.sentence !== null ? lineNumber : null;
+      openingSentenceResolved = true;
+    }
+    const linkMatches = line.matchAll(MARKDOWN_LINK_PATTERN2);
+    for (const match of linkMatches) {
+      const link = {
+        text: match[1],
+        target: match[2],
+        line: lineNumber
+      };
+      allLinks.push(link);
+      if (currentSection !== null) {
+        currentSection.links.push(link);
+      }
+    }
+  }
+  if (currentSection !== null) {
+    currentSection.endLine = findLastNonEmptyLine(lines, currentSection.startLine, lines.length - 1);
+    sections.push(currentSection);
+  }
+  return {
+    filePath,
+    rawContent: content,
+    title,
+    titleLine,
+    openingSentence,
+    openingSentenceLine,
+    sections,
+    allLinks
+  };
+}
+function shouldCheckForOpeningSentence(title, resolved, line) {
+  if (title === null || resolved) {
+    return false;
+  }
+  const trimmed = line.trim();
+  return trimmed !== "" && !isStructuralElement2(trimmed);
+}
+function tryExtractOpeningSentence(lines, startIndex) {
+  const paragraph = collectParagraph2(lines, startIndex);
+  return { sentence: extractFirstSentence2(paragraph) };
+}
+function findLastNonEmptyLine(lines, contentStartIndex, fromIndex) {
+  for (let i = fromIndex;i >= contentStartIndex; i--) {
+    if (lines[i].trim() !== "") {
+      return i + 1;
+    }
+  }
+  return contentStartIndex;
+}
+var LIST_ITEM_PREFIXES2 = ["-", "*", "+"];
+var STRUCTURAL_PREFIXES2 = ["#", "```", ">"];
+function isStructuralElement2(line) {
+  if (STRUCTURAL_PREFIXES2.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  if (LIST_ITEM_PREFIXES2.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  return /^\d+\./.test(line);
+}
+function isBlockBreak2(line) {
+  return STRUCTURAL_PREFIXES2.some((prefix) => line.startsWith(prefix));
+}
+function collectParagraph2(lines, startIndex) {
+  const parts = [];
+  for (let i = startIndex;i < lines.length; i++) {
+    const line = lines[i].trim();
+    if (line === "" || isBlockBreak2(line)) {
+      break;
+    }
+    parts.push(line);
+  }
+  return parts.join(" ");
+}
+function extractFirstSentence2(paragraph) {
+  const match = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  return match ? match[1] : null;
+}
+
 // lib/artifacts/workflow-tasks.ts
 var CAPTURE_IDEA_PREFIX = "Add Idea: ";
 var EXPEDITE_IDEA_PREFIX = "Expedite Idea: ";
@@ -661,6 +893,25 @@ async function parseCaptureIdeaTask(fileSystem, dustPath, taskSlug) {
 }
 
 // lib/artifacts/index.ts
+var ARTIFACT_TYPES = ["ideas", "tasks", "principles", "facts"];
+var DUST_PATH_PREFIX = ".dust/";
+function parseArtifactPath(path) {
+  if (!path.startsWith(DUST_PATH_PREFIX) || !path.endsWith(".md")) {
+    return null;
+  }
+  const withoutPrefix = path.slice(DUST_PATH_PREFIX.length);
+  const slashIndex = withoutPrefix.indexOf("/");
+  if (slashIndex === -1) {
+    return null;
+  }
+  const type = withoutPrefix.slice(0, slashIndex);
+  if (!ARTIFACT_TYPES.includes(type)) {
+    return null;
+  }
+  const filename = withoutPrefix.slice(slashIndex + 1);
+  const slug = filename.slice(0, -3);
+  return { type, slug };
+}
 function buildReadOperations(fileSystem, dustPath) {
   return {
     artifactPath(type, slug) {
@@ -765,8 +1016,14 @@ function buildReadOnlyArtifactsRepository(fileSystem, dustPath) {
 export {
   parseResolvedQuestions,
   parseOpenQuestions,
+  parseIdeaContent,
+  parseArtifactPath,
+  parseArtifact,
+  ideaContentToMarkdown,
   findAllWorkflowTasks,
+  extractTitle,
   buildReadOnlyArtifactsRepository,
   buildArtifactsRepository,
+  DUST_PATH_PREFIX,
   CAPTURE_IDEA_PREFIX
 };

package/dist/audits.js

@@ -6,50 +6,68 @@ 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;
+function findH1Index(lines) {
   for (let i = 0;i < lines.length; i++) {
     if (lines[i].match(/^#\s+.+$/)) {
-      h1Index = i;
-      break;
+      return i;
     }
   }
-  if (h1Index === -1) {
-    return null;
+  return -1;
+}
+function findFirstNonBlankLineAfter(lines, startIndex) {
+  for (let i = startIndex + 1;i < lines.length; i++) {
+    if (lines[i].trim() !== "") {
+      return i;
+    }
   }
-  let paragraphStart = -1;
-  for (let i = h1Index + 1;i < lines.length; i++) {
+  return -1;
+}
+var LIST_ITEM_PREFIXES = ["-", "*", "+"];
+var STRUCTURAL_PREFIXES = ["#", "```", ">"];
+function isStructuralElement(line) {
+  if (STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  if (LIST_ITEM_PREFIXES.some((prefix) => line.startsWith(prefix))) {
+    return true;
+  }
+  return /^\d+\./.test(line);
+}
+function isBlockBreak(line) {
+  return STRUCTURAL_PREFIXES.some((prefix) => line.startsWith(prefix));
+}
+function collectParagraph(lines, startIndex) {
+  const parts = [];
+  for (let i = startIndex;i < lines.length; i++) {
     const line = lines[i].trim();
-    if (line !== "") {
-      paragraphStart = i;
+    if (line === "" || isBlockBreak(line)) {
       break;
     }
+    parts.push(line);
   }
-  if (paragraphStart === -1) {
+  return parts.join(" ");
+}
+function extractFirstSentence(paragraph) {
+  const match = paragraph.match(/^(.+?[.?!])(?:\s|$)/);
+  return match ? match[1] : null;
+}
+function extractOpeningSentence(content) {
+  const lines = content.split(`
+`);
+  const h1Index = findH1Index(lines);
+  if (h1Index === -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(">")) {
+  const paragraphStart = findFirstNonBlankLineAfter(lines, h1Index);
+  if (paragraphStart === -1) {
     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) {
+  const trimmedFirstLine = lines[paragraphStart].trim();
+  if (isStructuralElement(trimmedFirstLine)) {
     return null;
   }
-  return sentenceMatch[1];
+  const paragraph = collectParagraph(lines, paragraphStart);
+  return extractFirstSentence(paragraph);
 }
 
 // lib/cli/dedent.ts
@@ -214,19 +232,33 @@ function coverageExclusions() {
   return dedent`
     # Coverage Exclusions
 
-    Review coverage exclusion configuration to identify opportunities for removal through refactoring.
+    Audit all coverage exclusions to identify opportunities for removal through refactoring.
 
     ${ideasHint}
 
     ## Scope
 
-    Focus on these areas:
+    Search for exclusions in both configuration and source code:
+
+    1. **Configuration-level exclusions** - Review test framework configuration for file/directory exclusion patterns
+    2. **Inline escape directives** - Search for comments that exclude code from coverage (e.g., ignore directives in source files)
+    3. **Test files** - Include test code in the search; inline directives may hide flaky or unclear test logic
+
+    ## Analysis
+
+    For each exclusion found:
 
-    1. **Current exclusions** - Review all exclusions in \`vitest.config.ts\` or equivalent
-    2. **Justification** - Is each exclusion still necessary?
-    3. **Tooling limitations** - Can workarounds be found for coverage tool issues?
-    4. **Decoupling opportunities** - Can excluded code be restructured to enable testing?
-    5. **Entry point patterns** - Can hard-to-test entry points be decoupled from logic?
+    1. **Document the location** - File path and line number (or config section)
+    2. **Identify the reason** - Why was this exclusion added?
+    3. **Categorize by justification**:
+       - Native wrapper (code that wraps platform APIs with no testable logic)
+       - Defensive guard (unreachable error handling for type safety)
+       - Integration boundary (code that requires external systems)
+       - Tooling limitation (coverage tool bug or limitation)
+       - Technical debt (code that should be testable but isn't)
+       - Unknown (no clear justification found)
+    4. **Label justification quality** - Is the justification well-documented, reasonable, or questionable?
+    5. **Evaluate removal potential** - Can the exclusion be removed through decoupling or refactoring?
 
     ## Principles
 
@@ -241,9 +273,11 @@ function coverageExclusions() {
 
     ## Definition of Done
 
-    - Identified all coverage exclusions in the project
+    - Identified all configuration-level coverage exclusions
+    - Searched source and test files for inline escape directives
     - Documented the reason each exclusion exists
-    - Evaluated whether each exclusion is still necessary
+    - Categorized each exclusion by justification type
+    - Labeled justification quality for visibility
     - Identified exclusions that could be removed through decoupling
     - Proposed ideas for refactoring where feasible
   `;

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

@@ -0,0 +1,38 @@
+/**
+ * Repository lifecycle state type for dust bucket.
+ *
+ * Represents all valid states in the repository lifecycle as a discriminated union,
+ * making invalid state combinations unrepresentable.
+ */
+export type RepositoryLifecycleState = {
+    type: 'idle';
+} | {
+    type: 'starting';
+} | {
+    type: 'running';
+    loopPromise: Promise<void>;
+    cancel: () => void;
+} | {
+    type: 'stopping';
+} | {
+    type: 'stopped';
+};
+export type LifecycleAction = {
+    type: 'start';
+} | {
+    type: 'started';
+    loopPromise: Promise<void>;
+    cancel: () => void;
+} | {
+    type: 'stop';
+} | {
+    type: 'stopped';
+};
+export type TransitionResult = {
+    ok: true;
+    state: RepositoryLifecycleState;
+} | {
+    ok: false;
+    error: string;
+};
+export declare function transition(current: RepositoryLifecycleState, action: LifecycleAction): TransitionResult;