@p10i/rundown 1.0.0-rc.12

package/dist/index.js

@@ -0,0 +1,2328 @@
+// src/application/run-task.ts
+import path from "path";
+
+// src/domain/defaults.ts
+var DEFAULT_TEMPLATE_SHARED_PREFIX = `{{context}}
+
+---
+
+The Markdown above is the source document up to but not including the selected unchecked task.
+
+## Source file
+
+\`{{file}}\` (line {{taskLine}})
+
+## Selected task
+
+{{task}}
+`;
+var DEFAULT_TASK_TEMPLATE = `${DEFAULT_TEMPLATE_SHARED_PREFIX}
+
+## Phase
+
+Execute the selected task.
+
+Complete the task described above. Make the necessary changes to the project, but do not edit the source Markdown task file as part of completion tracking.
+
+- Do not change the checkbox in the source Markdown file.
+- Do not rewrite the task item to make it look completed.
+- Do not treat editing the TODO file itself as evidence that the task is done unless the task explicitly requires documentation changes in that file.
+- rundown is responsible for marking the task complete after validation succeeds.
+`;
+var DEFAULT_VALIDATE_TEMPLATE = `${DEFAULT_TEMPLATE_SHARED_PREFIX}
+
+## Phase
+
+Verify whether the selected task is complete.
+
+Evaluate whether the task above has been completed.
+
+Write your result to a file named \`{{file}}.{{taskIndex}}.validation\` next to the source file.
+
+- If the task is complete, write exactly: OK
+- If the task is not complete, write a short explanation of what is still missing.
+
+Do not modify the source Markdown task file or change its checkbox state. Validation is determined only by the actual project state and the sidecar file above.
+
+Do not write anything else.
+`;
+var DEFAULT_CORRECT_TEMPLATE = `${DEFAULT_TEMPLATE_SHARED_PREFIX}
+
+## Phase
+
+Repair the selected task after a failed verification pass.
+
+## Previous validation result
+
+{{validationResult}}
+
+Please fix what is missing or incorrect. The validation above explains what still needs to be done.
+
+- Do not change the checkbox in the source Markdown file.
+- Do not mark the task complete yourself.
+- rundown will update task completion only after validation succeeds.
+
+After making corrections, the task will be validated again.
+`;
+var DEFAULT_VARS_FILE_CONTENT = `{
+	"branch": "main",
+	"ticket": "ENG-42"
+}
+`;
+var DEFAULT_PLAN_TEMPLATE = `${DEFAULT_TEMPLATE_SHARED_PREFIX}
+
+## Phase
+
+Plan the selected task by decomposing it into concrete subtasks.
+
+Break this task into smaller, actionable subtasks.
+
+Return ONLY a Markdown list of unchecked task items using \`- [ ]\` syntax, one per subtask.
+
+Rules:
+- Each subtask should be a single clear action.
+- Together the subtasks should fully cover the parent task.
+- Do not include the parent task itself.
+- Do not include any other text, headings, or explanation.
+- Do not modify the source Markdown file.
+
+Example output format:
+
+- [ ] First concrete step
+- [ ] Second concrete step
+- [ ] Third concrete step
+`;
+
+// src/domain/checkbox.ts
+function markChecked(source, task) {
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const lines = source.split(/\r?\n/);
+  const lineIndex = task.line - 1;
+  if (lineIndex < 0 || lineIndex >= lines.length) {
+    throw new Error(`Task line ${task.line} is out of range in ${task.file}`);
+  }
+  const line = lines[lineIndex];
+  const updated = line.replace(/\[ \]/, "[x]");
+  if (updated === line) {
+    throw new Error(`Could not find unchecked checkbox on line ${task.line} in ${task.file}`);
+  }
+  lines[lineIndex] = updated;
+  return lines.join(eol);
+}
+
+// src/domain/run-options.ts
+function resolveRunBehavior(input) {
+  const maxRetries = Number.isFinite(input.retries) && input.retries > 0 ? Math.floor(input.retries) : 0;
+  const onlyValidate = input.onlyValidate;
+  const shouldValidate = input.validate || onlyValidate;
+  const allowCorrection = !input.noCorrect && maxRetries > 0;
+  return {
+    shouldValidate,
+    onlyValidate,
+    allowCorrection,
+    maxRetries
+  };
+}
+function requiresWorkerCommand(input) {
+  if (input.workerCommand.length > 0) {
+    return false;
+  }
+  if (input.onlyValidate) {
+    return true;
+  }
+  if (!input.isInlineCli) {
+    return true;
+  }
+  return input.shouldValidate;
+}
+
+// src/domain/template.ts
+function renderTemplate(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_match, key) => {
+    if (key in vars) {
+      return String(vars[key] ?? "");
+    }
+    return `{{${key}}}`;
+  });
+}
+
+// src/domain/template-vars.ts
+var DEFAULT_TEMPLATE_VARS_FILE = ".rundown/vars.json";
+var TEMPLATE_VAR_KEY = /^[A-Za-z_]\w*$/;
+function parseCliTemplateVars(entries) {
+  const vars = {};
+  for (const entry of entries) {
+    const equalsIndex = entry.indexOf("=");
+    if (equalsIndex <= 0) {
+      throw new Error(`Invalid template variable "${entry}". Use key=value.`);
+    }
+    const key = entry.slice(0, equalsIndex).trim();
+    const value = entry.slice(equalsIndex + 1);
+    if (!TEMPLATE_VAR_KEY.test(key)) {
+      throw new Error(`Invalid template variable name "${key}". Use letters, numbers, and underscores only.`);
+    }
+    vars[key] = value;
+  }
+  return vars;
+}
+function resolveTemplateVarsFilePath(option) {
+  if (option === true) {
+    return DEFAULT_TEMPLATE_VARS_FILE;
+  }
+  return typeof option === "string" ? option : void 0;
+}
+
+// src/application/run-task.ts
+function createRunTask(dependencies) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  return async function runTask(options) {
+    const {
+      source,
+      mode,
+      transport,
+      sortMode,
+      verify,
+      onlyVerify,
+      noRepair,
+      retries,
+      dryRun,
+      printPrompt,
+      keepArtifacts,
+      varsFileOption,
+      cliTemplateVarArgs,
+      workerCommand,
+      commitAfterComplete,
+      commitMessageTemplate,
+      onCompleteCommand
+    } = options;
+    const runBehavior = resolveRunBehavior({
+      validate: verify,
+      onlyValidate: onlyVerify,
+      noCorrect: noRepair,
+      retries
+    });
+    const shouldValidate = runBehavior.shouldValidate;
+    const onlyValidate = runBehavior.onlyValidate;
+    const allowCorrection = runBehavior.allowCorrection;
+    const maxRetries = runBehavior.maxRetries;
+    const varsFilePath = resolveTemplateVarsFilePath(varsFileOption);
+    const fileTemplateVars = varsFilePath ? loadTemplateVarsFileFromPorts(varsFilePath, dependencies.workingDirectory.cwd(), dependencies.fileSystem) : {};
+    const cliTemplateVars = parseCliTemplateVars(cliTemplateVarArgs);
+    const extraTemplateVars = {
+      ...fileTemplateVars,
+      ...cliTemplateVars
+    };
+    let artifactContext = null;
+    let artifactsFinalized = false;
+    const finalizeArtifacts = (status, preserve = keepArtifacts) => {
+      if (!artifactContext || artifactsFinalized) {
+        return;
+      }
+      finalizeRunArtifacts(dependencies.artifactStore, artifactContext, preserve, status, emit);
+      artifactsFinalized = true;
+    };
+    const finishRun = (code, status, preserve = keepArtifacts) => {
+      finalizeArtifacts(status, preserve);
+      return code;
+    };
+    try {
+      const files = await dependencies.sourceResolver.resolveSources(source);
+      if (files.length === 0) {
+        emit({ kind: "warn", message: "No Markdown files found matching: " + source });
+        return 3;
+      }
+      const result = dependencies.taskSelector.selectNextTask(files, sortMode);
+      if (!result) {
+        emit({ kind: "info", message: "No unchecked tasks found." });
+        return 3;
+      }
+      const { task, source: fileSource, contextBefore } = result;
+      emit({ kind: "info", message: "Next task: " + formatTaskLabel(task) });
+      const automationCommand = getAutomationWorkerCommand(workerCommand, mode);
+      const templates = loadProjectTemplatesFromPorts(
+        dependencies.workingDirectory.cwd(),
+        dependencies.templateLoader
+      );
+      const vars = {
+        ...extraTemplateVars,
+        task: task.text,
+        file: task.file,
+        context: contextBefore,
+        taskIndex: task.index,
+        taskLine: task.line,
+        source: fileSource
+      };
+      const prompt = renderTemplate(templates.task, vars);
+      const validationPrompt = shouldValidate ? renderTemplate(templates.validate, vars) : "";
+      if (printPrompt && onlyValidate) {
+        emit({ kind: "text", text: validationPrompt });
+        return 0;
+      }
+      if (dryRun && onlyValidate) {
+        emit({ kind: "info", message: "Dry run \u2014 would run verification with: " + automationCommand.join(" ") });
+        emit({ kind: "info", message: "Prompt length: " + validationPrompt.length + " chars" });
+        return 0;
+      }
+      if (requiresWorkerCommand({
+        workerCommand,
+        isInlineCli: task.isInlineCli,
+        shouldValidate,
+        onlyValidate
+      })) {
+        emit({ kind: "error", message: "No worker command specified. Use --worker <command...> or -- <command>." });
+        return 1;
+      }
+      if (!onlyValidate && !task.isInlineCli) {
+        if (printPrompt) {
+          emit({ kind: "text", text: prompt });
+          return 0;
+        }
+        if (dryRun) {
+          emit({ kind: "info", message: "Dry run \u2014 would run: " + workerCommand.join(" ") });
+          emit({ kind: "info", message: "Prompt length: " + prompt.length + " chars" });
+          return 0;
+        }
+      }
+      if (!onlyValidate && task.isInlineCli && dryRun) {
+        emit({ kind: "info", message: "Dry run \u2014 would execute inline CLI: " + task.cliCommand });
+        return 0;
+      }
+      artifactContext = dependencies.artifactStore.createContext({
+        cwd: dependencies.workingDirectory.cwd(),
+        commandName: "run",
+        workerCommand: onlyValidate ? automationCommand : workerCommand,
+        mode,
+        transport,
+        source,
+        task: toRuntimeTaskMetadata(task, fileSource),
+        keepArtifacts
+      });
+      if (onlyValidate) {
+        emit({ kind: "info", message: "Only verify mode \u2014 skipping task execution." });
+        const valid = await runValidation(
+          dependencies,
+          task,
+          fileSource,
+          contextBefore,
+          templates,
+          automationCommand,
+          transport,
+          maxRetries,
+          allowCorrection,
+          extraTemplateVars,
+          artifactContext
+        );
+        if (!valid) {
+          emit({ kind: "error", message: "Verification failed after all retries. Task not checked." });
+          return finishRun(2, "verification-failed");
+        }
+        checkTaskUsingFileSystem(task, dependencies.fileSystem);
+        emit({ kind: "success", message: "Task checked: " + task.text });
+        await afterTaskComplete(
+          dependencies,
+          task,
+          source,
+          commitAfterComplete,
+          commitMessageTemplate,
+          onCompleteCommand
+        );
+        return finishRun(0, "completed");
+      }
+      if (task.isInlineCli) {
+        const inlineCliCwd = path.dirname(path.resolve(task.file));
+        emit({ kind: "info", message: "Executing inline CLI: " + task.cliCommand + " [cwd=" + inlineCliCwd + "]" });
+        const cliResult = await dependencies.workerExecutor.executeInlineCli(task.cliCommand, inlineCliCwd, {
+          artifactContext,
+          keepArtifacts,
+          artifactExtra: { taskType: "inline-cli" }
+        });
+        if (cliResult.stdout) emit({ kind: "text", text: cliResult.stdout });
+        if (cliResult.stderr) emit({ kind: "stderr", text: cliResult.stderr });
+        if (cliResult.exitCode !== 0) {
+          emit({ kind: "error", message: "Inline CLI exited with code " + cliResult.exitCode });
+          return finishRun(1, "execution-failed");
+        }
+        if (shouldValidate) {
+          const valid = await runValidation(
+            dependencies,
+            task,
+            fileSource,
+            contextBefore,
+            templates,
+            automationCommand,
+            transport,
+            maxRetries,
+            allowCorrection,
+            extraTemplateVars,
+            artifactContext
+          );
+          if (!valid) {
+            emit({ kind: "error", message: "Verification failed. Task not checked." });
+            return finishRun(2, "verification-failed");
+          }
+        }
+        checkTaskUsingFileSystem(task, dependencies.fileSystem);
+        emit({ kind: "success", message: "Task checked: " + task.text });
+        await afterTaskComplete(
+          dependencies,
+          task,
+          source,
+          commitAfterComplete,
+          commitMessageTemplate,
+          onCompleteCommand
+        );
+        return finishRun(0, "completed");
+      }
+      emit({ kind: "info", message: "Running: " + workerCommand.join(" ") + " [mode=" + mode + ", transport=" + transport + "]" });
+      const runResult = await dependencies.workerExecutor.runWorker({
+        command: workerCommand,
+        prompt,
+        mode,
+        transport,
+        cwd: dependencies.workingDirectory.cwd(),
+        artifactContext,
+        artifactPhase: "execute"
+      });
+      if (mode === "wait") {
+        if (runResult.stdout) emit({ kind: "text", text: runResult.stdout });
+        if (runResult.stderr) emit({ kind: "stderr", text: runResult.stderr });
+      }
+      if (mode !== "detached" && runResult.exitCode !== 0 && runResult.exitCode !== null) {
+        emit({ kind: "error", message: "Worker exited with code " + runResult.exitCode + "." });
+        return finishRun(1, "execution-failed");
+      }
+      if (mode === "detached") {
+        emit({ kind: "info", message: "Detached mode \u2014 skipping immediate verification and leaving the task unchecked." });
+        return finishRun(0, "detached", true);
+      }
+      if (shouldValidate) {
+        const valid = await runValidation(
+          dependencies,
+          task,
+          fileSource,
+          contextBefore,
+          templates,
+          automationCommand,
+          transport,
+          maxRetries,
+          allowCorrection,
+          extraTemplateVars,
+          artifactContext
+        );
+        if (!valid) {
+          emit({ kind: "error", message: "Verification failed after all retries. Task not checked." });
+          return finishRun(2, "verification-failed");
+        }
+      }
+      checkTaskUsingFileSystem(task, dependencies.fileSystem);
+      emit({ kind: "success", message: "Task checked: " + task.text });
+      await afterTaskComplete(
+        dependencies,
+        task,
+        source,
+        commitAfterComplete,
+        commitMessageTemplate,
+        onCompleteCommand
+      );
+      return finishRun(0, "completed");
+    } catch (error) {
+      finalizeArtifacts("failed", keepArtifacts || mode === "detached");
+      throw error;
+    }
+  };
+}
+async function runValidation(dependencies, task, fileSource, contextBefore, templates, workerCommand, transport, maxRetries, allowCorrection, extraTemplateVars, artifactContext) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  emit({ kind: "info", message: "Running verification..." });
+  const valid = await dependencies.taskValidation.validate({
+    task,
+    source: fileSource,
+    contextBefore,
+    template: templates.validate,
+    command: workerCommand,
+    mode: "wait",
+    transport,
+    templateVars: extraTemplateVars,
+    artifactContext
+  });
+  if (valid) {
+    dependencies.validationSidecar.remove(task);
+    emit({ kind: "success", message: "Verification passed." });
+    return true;
+  }
+  if (allowCorrection) {
+    emit({ kind: "warn", message: "Verification failed. Running repair (" + maxRetries + " retries)..." });
+    const result = await dependencies.taskCorrection.correct({
+      task,
+      source: fileSource,
+      contextBefore,
+      correctTemplate: templates.correct,
+      validateTemplate: templates.validate,
+      command: workerCommand,
+      maxRetries,
+      mode: "wait",
+      transport,
+      templateVars: extraTemplateVars,
+      artifactContext
+    });
+    if (result.valid) {
+      dependencies.validationSidecar.remove(task);
+      emit({ kind: "success", message: "Repair succeeded after " + result.attempts + " attempt(s)." });
+      return true;
+    }
+  }
+  return false;
+}
+async function afterTaskComplete(dependencies, task, source, commit, commitMessageTemplate, onCompleteCommand) {
+  const cwd = dependencies.workingDirectory.cwd();
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  if (commit) {
+    try {
+      const inGitRepo = await isGitRepoWithGitClient(dependencies.gitClient, cwd);
+      if (!inGitRepo) {
+        emit({ kind: "warn", message: "--commit: not inside a git repository, skipping." });
+      } else {
+        const message = buildCommitMessage(task, cwd, commitMessageTemplate);
+        await commitCheckedTaskWithGitClient(dependencies.gitClient, task, cwd, message);
+        emit({ kind: "success", message: "Committed: " + message });
+      }
+    } catch (error) {
+      emit({ kind: "warn", message: "--commit failed: " + String(error) });
+    }
+  }
+  if (onCompleteCommand) {
+    try {
+      const result = await runOnCompleteHookWithProcessRunner(
+        dependencies.processRunner,
+        onCompleteCommand,
+        task,
+        source,
+        cwd
+      );
+      if (result.stdout) emit({ kind: "text", text: result.stdout });
+      if (result.stderr) emit({ kind: "stderr", text: result.stderr });
+      if (!result.success) {
+        emit({ kind: "warn", message: "--on-complete hook exited with code " + result.exitCode });
+      }
+    } catch (error) {
+      emit({ kind: "warn", message: "--on-complete hook failed: " + String(error) });
+    }
+  }
+}
+function getAutomationWorkerCommand(workerCommand, mode) {
+  if (mode !== "tui") {
+    return workerCommand;
+  }
+  if (!isOpenCodeWorkerCommand(workerCommand)) {
+    return workerCommand;
+  }
+  return workerCommand.length > 1 ? workerCommand : [workerCommand[0], "run"];
+}
+function finalizeRunArtifacts(artifactStore, artifactContext, preserve, status, emit) {
+  artifactStore.finalize(artifactContext, { status, preserve });
+  if (preserve) {
+    emit({ kind: "info", message: "Runtime artifacts saved at " + artifactStore.displayPath(artifactContext) + "." });
+  }
+}
+var TEMPLATE_VAR_KEY2 = /^[A-Za-z_]\w*$/;
+var DEFAULT_COMMIT_MESSAGE_TEMPLATE = 'rundown: complete "{{task}}" in {{file}}';
+function loadTemplateVarsFileFromPorts(filePath, cwd, fileSystem) {
+  const resolvedPath = path.resolve(cwd, filePath);
+  let parsed;
+  try {
+    parsed = JSON.parse(fileSystem.readText(resolvedPath));
+  } catch (error) {
+    throw new Error(`Failed to read template vars file "${filePath}": ${String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Template vars file "${filePath}" must contain a JSON object.`);
+  }
+  const vars = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!TEMPLATE_VAR_KEY2.test(key)) {
+      throw new Error(`Invalid template variable name "${key}" in "${filePath}". Use letters, numbers, and underscores only.`);
+    }
+    if (value === null || value === void 0) {
+      vars[key] = "";
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      vars[key] = String(value);
+      continue;
+    }
+    throw new Error(`Template variable "${key}" in "${filePath}" must be a string, number, boolean, or null.`);
+  }
+  return vars;
+}
+function loadProjectTemplatesFromPorts(cwd, templateLoader) {
+  const dir = path.join(cwd, ".rundown");
+  return {
+    task: templateLoader.load(path.join(dir, "execute.md")) ?? DEFAULT_TASK_TEMPLATE,
+    validate: templateLoader.load(path.join(dir, "verify.md")) ?? DEFAULT_VALIDATE_TEMPLATE,
+    correct: templateLoader.load(path.join(dir, "repair.md")) ?? DEFAULT_CORRECT_TEMPLATE,
+    plan: templateLoader.load(path.join(dir, "plan.md")) ?? DEFAULT_PLAN_TEMPLATE
+  };
+}
+function checkTaskUsingFileSystem(task, fileSystem) {
+  const source = fileSystem.readText(task.file);
+  const updated = markChecked(source, task);
+  fileSystem.writeText(task.file, updated);
+}
+async function isGitRepoWithGitClient(gitClient, cwd) {
+  try {
+    await gitClient.run(["rev-parse", "--is-inside-work-tree"], cwd);
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function commitCheckedTaskWithGitClient(gitClient, task, cwd, message) {
+  const relativePath = path.relative(cwd, task.file).replace(/\\/g, "/");
+  await gitClient.run(["add", "--", relativePath], cwd);
+  await gitClient.run(["commit", "-m", message], cwd);
+}
+function buildCommitMessage(task, cwd, messageTemplate) {
+  const relativePath = path.relative(cwd, task.file).replace(/\\/g, "/");
+  return renderTemplate(messageTemplate ?? DEFAULT_COMMIT_MESSAGE_TEMPLATE, {
+    task: task.text,
+    file: relativePath,
+    context: "",
+    taskIndex: task.index,
+    taskLine: task.line,
+    source: ""
+  });
+}
+async function runOnCompleteHookWithProcessRunner(processRunner, command, task, source, cwd) {
+  try {
+    const result = await processRunner.run({
+      command,
+      args: [],
+      cwd,
+      mode: "wait",
+      shell: true,
+      timeoutMs: 6e4,
+      env: {
+        ...process.env,
+        RUNDOWN_TASK: task.text,
+        RUNDOWN_FILE: path.resolve(task.file),
+        RUNDOWN_LINE: String(task.line),
+        RUNDOWN_INDEX: String(task.index),
+        RUNDOWN_SOURCE: source
+      }
+    });
+    return {
+      success: result.exitCode === 0,
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr
+    };
+  } catch (error) {
+    return {
+      success: false,
+      exitCode: null,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function formatTaskLabel(task) {
+  return `${task.file}:${task.line} [#${task.index}] ${task.text}`;
+}
+function toRuntimeTaskMetadata(task, source) {
+  return {
+    text: task.text,
+    file: task.file,
+    line: task.line,
+    index: task.index,
+    source
+  };
+}
+function isOpenCodeWorkerCommand(workerCommand) {
+  if (workerCommand.length === 0) {
+    return false;
+  }
+  const command = workerCommand[0].toLowerCase();
+  return command === "opencode" || command.endsWith("/opencode") || command.endsWith("\\opencode") || command.endsWith("/opencode.cmd") || command.endsWith("\\opencode.cmd") || command.endsWith("/opencode.exe") || command.endsWith("\\opencode.exe") || command.endsWith("/opencode.ps1") || command.endsWith("\\opencode.ps1");
+}
+
+// src/application/plan-task.ts
+import path2 from "path";
+
+// src/domain/planner.ts
+function parsePlannerOutput(output) {
+  const lines = output.split(/\r?\n/);
+  const taskPattern = /^\s*[-*+]\s+\[ \]\s+\S/;
+  return lines.filter((line) => taskPattern.test(line)).map((line) => line.replace(/^\s+/, ""));
+}
+function computeChildIndent(parentLine) {
+  const leadingWhitespace = parentLine.match(/^(\s*)/)?.[1] ?? "";
+  const indentUnit = "  ";
+  return leadingWhitespace + indentUnit;
+}
+function insertSubitems(source, task, subitemLines) {
+  if (subitemLines.length === 0) return source;
+  const eol = source.includes("\r\n") ? "\r\n" : "\n";
+  const lines = source.split(/\r?\n/);
+  const parentLineIndex = task.line - 1;
+  if (parentLineIndex < 0 || parentLineIndex >= lines.length) {
+    throw new Error(`Task line ${task.line} is out of range.`);
+  }
+  const parentLine = lines[parentLineIndex];
+  const indent = computeChildIndent(parentLine);
+  const indented = subitemLines.map((item) => {
+    const text = item.replace(/^[-*+]\s+/, "");
+    return `${indent}- ${text}`;
+  });
+  lines.splice(parentLineIndex + 1, 0, ...indented);
+  return lines.join(eol);
+}
+
+// src/application/plan-task.ts
+function createPlanTask(dependencies) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  return async function planTask(options) {
+    const {
+      source,
+      at,
+      mode,
+      transport,
+      sortMode,
+      dryRun,
+      printPrompt,
+      keepArtifacts,
+      varsFileOption,
+      cliTemplateVarArgs,
+      workerCommand
+    } = options;
+    const varsFilePath = resolveTemplateVarsFilePath(varsFileOption);
+    const cwd = dependencies.workingDirectory.cwd();
+    const fileTemplateVars = varsFilePath ? loadTemplateVarsFileFromPorts2(varsFilePath, cwd, dependencies.fileSystem) : {};
+    const cliTemplateVars = parseCliTemplateVars(cliTemplateVarArgs);
+    const extraTemplateVars = {
+      ...fileTemplateVars,
+      ...cliTemplateVars
+    };
+    const selection = await selectPlanTask(source, at, sortMode, dependencies, emit);
+    if (!selection.result) {
+      return selection.exitCode;
+    }
+    const { task, source: fileSource, contextBefore } = selection.result;
+    emit({
+      kind: "info",
+      message: "Planning task: " + formatTaskLabel2(task)
+    });
+    if (workerCommand.length === 0) {
+      emit({
+        kind: "error",
+        message: "No worker command specified. Use --worker <command...> or -- <command>."
+      });
+      return 1;
+    }
+    const planTemplate = loadPlanTemplateFromPorts(cwd, dependencies.templateLoader);
+    const vars = {
+      ...extraTemplateVars,
+      task: task.text,
+      file: task.file,
+      context: contextBefore,
+      taskIndex: task.index,
+      taskLine: task.line,
+      source: fileSource
+    };
+    const prompt = renderTemplate(planTemplate, vars);
+    if (printPrompt) {
+      emit({ kind: "text", text: prompt });
+      return 0;
+    }
+    if (dryRun) {
+      emit({ kind: "info", message: "Dry run \u2014 would plan: " + workerCommand.join(" ") });
+      emit({ kind: "info", message: "Prompt length: " + prompt.length + " chars" });
+      return 0;
+    }
+    const artifactContext = dependencies.artifactStore.createContext({
+      cwd,
+      commandName: "plan",
+      workerCommand,
+      mode,
+      transport,
+      source,
+      task: {
+        text: task.text,
+        file: task.file,
+        line: task.line,
+        index: task.index,
+        source: fileSource
+      },
+      keepArtifacts
+    });
+    let artifactsFinalized = false;
+    let artifactStatus = "running";
+    const finishPlan = (code, status) => {
+      artifactStatus = status;
+      finalizePlanArtifacts(dependencies.artifactStore, artifactContext, keepArtifacts, artifactStatus, emit);
+      artifactsFinalized = true;
+      return code;
+    };
+    try {
+      emit({
+        kind: "info",
+        message: "Running planner: " + workerCommand.join(" ") + " [mode=" + mode + ", transport=" + transport + "]"
+      });
+      const runResult = await dependencies.workerExecutor.runWorker({
+        command: workerCommand,
+        prompt,
+        mode,
+        transport,
+        cwd,
+        artifactContext,
+        artifactPhase: "plan"
+      });
+      if (mode === "wait" && runResult.stderr) {
+        emit({ kind: "stderr", text: runResult.stderr });
+      }
+      if (runResult.exitCode !== 0 && runResult.exitCode !== null) {
+        emit({ kind: "error", message: "Planner worker exited with code " + runResult.exitCode + "." });
+        return finishPlan(1, "execution-failed");
+      }
+      if (!runResult.stdout || runResult.stdout.trim().length === 0) {
+        emit({ kind: "warn", message: "Planner produced no output. No subtasks created." });
+        return finishPlan(0, "completed");
+      }
+      const count = applyPlannerOutputWithFileSystem(task, runResult.stdout, dependencies.fileSystem);
+      if (count === 0) {
+        emit({ kind: "warn", message: "Planner output contained no valid task items. No subtasks created." });
+        return finishPlan(0, "completed");
+      }
+      emit({
+        kind: "success",
+        message: "Inserted " + count + " subtask" + (count === 1 ? "" : "s") + " under: " + task.text
+      });
+      return finishPlan(0, "completed");
+    } finally {
+      if (!artifactsFinalized) {
+        finalizePlanArtifacts(dependencies.artifactStore, artifactContext, keepArtifacts, artifactStatus, emit);
+        artifactsFinalized = true;
+      }
+    }
+  };
+}
+async function selectPlanTask(source, at, sortMode, dependencies, emit) {
+  if (at) {
+    const parsed = parseTaskLocation(at);
+    if (parsed.kind === "invalid-format") {
+      emit({ kind: "error", message: "Invalid --at format. Expected file:line (e.g. roadmap.md:12)." });
+      return { result: null, exitCode: 1 };
+    }
+    if (parsed.kind === "invalid-line") {
+      emit({ kind: "error", message: "Invalid line number in --at: " + parsed.lineRaw });
+      return { result: null, exitCode: 1 };
+    }
+    const { filePath, lineNum } = parsed;
+    const selected2 = dependencies.taskSelector.selectTaskByLocation(filePath, lineNum);
+    if (!selected2) {
+      emit({ kind: "error", message: "No task found at " + filePath + ":" + lineNum });
+      return { result: null, exitCode: 3 };
+    }
+    return { result: selected2, exitCode: 0 };
+  }
+  const files = await dependencies.sourceResolver.resolveSources(source);
+  if (files.length === 0) {
+    emit({ kind: "warn", message: "No Markdown files found matching: " + source });
+    return { result: null, exitCode: 3 };
+  }
+  const selected = dependencies.taskSelector.selectNextTask(files, sortMode);
+  if (!selected) {
+    emit({ kind: "info", message: "No unchecked tasks found." });
+    return { result: null, exitCode: 3 };
+  }
+  return { result: selected, exitCode: 0 };
+}
+function formatTaskLabel2(task) {
+  return `${task.file}:${task.line} [#${task.index}] ${task.text}`;
+}
+function parseTaskLocation(value) {
+  const colonIdx = value.lastIndexOf(":");
+  if (colonIdx === -1) {
+    return { kind: "invalid-format" };
+  }
+  const filePath = value.slice(0, colonIdx);
+  const lineRaw = value.slice(colonIdx + 1);
+  const lineNum = Number.parseInt(lineRaw, 10);
+  if (!Number.isFinite(lineNum) || lineNum < 1) {
+    return { kind: "invalid-line", lineRaw };
+  }
+  return { kind: "ok", filePath, lineNum };
+}
+function finalizePlanArtifacts(artifactStore, artifactContext, preserve, status, emit) {
+  artifactStore.finalize(artifactContext, {
+    status,
+    preserve
+  });
+  if (preserve) {
+    emit({
+      kind: "info",
+      message: "Runtime artifacts saved at " + artifactStore.displayPath(artifactContext) + "."
+    });
+  }
+}
+var TEMPLATE_VAR_KEY3 = /^[A-Za-z_]\w*$/;
+function loadTemplateVarsFileFromPorts2(filePath, cwd, fileSystem) {
+  const resolvedPath = path2.resolve(cwd, filePath);
+  let parsed;
+  try {
+    parsed = JSON.parse(fileSystem.readText(resolvedPath));
+  } catch (error) {
+    throw new Error(`Failed to read template vars file "${filePath}": ${String(error)}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`Template vars file "${filePath}" must contain a JSON object.`);
+  }
+  const vars = {};
+  for (const [key, value] of Object.entries(parsed)) {
+    if (!TEMPLATE_VAR_KEY3.test(key)) {
+      throw new Error(`Invalid template variable name "${key}" in "${filePath}". Use letters, numbers, and underscores only.`);
+    }
+    if (value === null || value === void 0) {
+      vars[key] = "";
+      continue;
+    }
+    if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+      vars[key] = String(value);
+      continue;
+    }
+    throw new Error(`Template variable "${key}" in "${filePath}" must be a string, number, boolean, or null.`);
+  }
+  return vars;
+}
+function loadPlanTemplateFromPorts(cwd, templateLoader) {
+  return templateLoader.load(path2.join(cwd, ".rundown", "plan.md")) ?? DEFAULT_PLAN_TEMPLATE;
+}
+function applyPlannerOutputWithFileSystem(task, plannerOutput, fileSystem) {
+  const subitemLines = parsePlannerOutput(plannerOutput);
+  if (subitemLines.length === 0) {
+    return 0;
+  }
+  const source = fileSystem.readText(task.file);
+  const updated = insertSubitems(source, task, subitemLines);
+  fileSystem.writeText(task.file, updated);
+  return subitemLines.length;
+}
+
+// src/domain/parser.ts
+import { fromMarkdown } from "mdast-util-from-markdown";
+import {
+  gfmTaskListItem
+} from "micromark-extension-gfm-task-list-item";
+import {
+  gfmTaskListItemFromMarkdown
+} from "mdast-util-gfm-task-list-item";
+var CLI_PREFIX = /^cli:\s*/i;
+function parseTasks(source, file = "") {
+  const tree = fromMarkdown(source, {
+    extensions: [gfmTaskListItem()],
+    mdastExtensions: [gfmTaskListItemFromMarkdown()]
+  });
+  const tasks = [];
+  walkForTasks(tree, tasks, file, 0);
+  return tasks;
+}
+function walkForTasks(node, tasks, file, depth) {
+  if (isListItem(node) && node.checked !== null && node.checked !== void 0) {
+    const text = extractText(node);
+    const pos = node.position;
+    const isInlineCli = CLI_PREFIX.test(text);
+    const task = {
+      text,
+      checked: node.checked === true,
+      index: tasks.length,
+      line: pos?.start.line ?? 0,
+      column: pos?.start.column ?? 0,
+      offsetStart: pos?.start.offset ?? 0,
+      offsetEnd: pos?.end?.offset ?? 0,
+      file,
+      isInlineCli,
+      depth
+    };
+    if (isInlineCli) {
+      task.cliCommand = text.replace(CLI_PREFIX, "").trim();
+    }
+    tasks.push(task);
+  }
+  if ("children" in node) {
+    const nextDepth = isListItem(node) ? depth + 1 : depth;
+    for (const child of node.children) {
+      walkForTasks(child, tasks, file, nextDepth);
+    }
+  }
+}
+function isListItem(node) {
+  return node.type === "listItem";
+}
+function extractText(node) {
+  const parts = [];
+  for (const child of node.children) {
+    if (child.type === "paragraph") {
+      collectText(child, parts);
+    }
+  }
+  return parts.join("").trim();
+}
+function collectText(node, parts) {
+  if (node.type === "text" || node.type === "inlineCode") {
+    parts.push(node.value);
+  }
+  if ("children" in node) {
+    for (const child of node.children) {
+      collectText(child, parts);
+    }
+  }
+}
+
+// src/domain/task-selection.ts
+function hasUncheckedDescendants(task, allTasks) {
+  const startIdx = allTasks.indexOf(task);
+  if (startIdx === -1) return false;
+  for (let i = startIdx + 1; i < allTasks.length; i++) {
+    const candidate = allTasks[i];
+    if (candidate.depth <= task.depth) break;
+    if (!candidate.checked) return true;
+  }
+  return false;
+}
+function filterRunnable(tasks) {
+  return tasks.filter((task) => !task.checked && !hasUncheckedDescendants(task, tasks));
+}
+
+// src/domain/sorting.ts
+import path3 from "path";
+function sortFiles(files, mode = "name-sort", options = {}) {
+  switch (mode) {
+    case "none":
+      return files;
+    case "name-sort":
+      return [...files].sort((a, b) => naturalCompare(path3.basename(a), path3.basename(b)));
+    case "old-first":
+      return [...files].sort((a, b) => getBirthtime(a, options) - getBirthtime(b, options));
+    case "new-first":
+      return [...files].sort((a, b) => getBirthtime(b, options) - getBirthtime(a, options));
+    default:
+      return files;
+  }
+}
+function naturalCompare(a, b) {
+  const ax = tokenize(a);
+  const bx = tokenize(b);
+  for (let i = 0; i < Math.max(ax.length, bx.length); i++) {
+    const ai = ax[i];
+    const bi = bx[i];
+    if (ai === void 0) return -1;
+    if (bi === void 0) return 1;
+    const an = typeof ai === "number";
+    const bn = typeof bi === "number";
+    if (an && bn) {
+      if (ai !== bi) return ai - bi;
+    } else if (an) {
+      return -1;
+    } else if (bn) {
+      return 1;
+    } else {
+      const cmp = ai.localeCompare(bi, void 0, { sensitivity: "base" });
+      if (cmp !== 0) return cmp;
+    }
+  }
+  return 0;
+}
+function tokenize(s) {
+  const tokens = [];
+  const re = /(\d+)|(\D+)/g;
+  let m;
+  while ((m = re.exec(s)) !== null) {
+    if (m[1] !== void 0) {
+      tokens.push(parseInt(m[1], 10));
+    } else {
+      tokens.push(m[2]);
+    }
+  }
+  return tokens;
+}
+function getBirthtime(filePath, options) {
+  if (!options.getBirthtimeMs) return 0;
+  return options.getBirthtimeMs(filePath);
+}
+
+// src/application/list-tasks.ts
+function createListTasks(dependencies) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  return async function listTasks(options) {
+    const { source, sortMode, includeAll } = options;
+    const files = await dependencies.sourceResolver.resolveSources(source);
+    if (files.length === 0) {
+      emit({ kind: "warn", message: "No Markdown files found matching: " + source });
+      return 3;
+    }
+    const sorted = sortFiles(files, sortMode, {
+      getBirthtimeMs: (filePath) => {
+        const stats = dependencies.fileSystem.stat(filePath);
+        if (!stats) {
+          throw new Error(`ENOENT: no such file or directory, stat '${filePath}'`);
+        }
+        if (stats.birthtimeMs !== void 0 && Number.isFinite(stats.birthtimeMs)) {
+          return stats.birthtimeMs;
+        }
+        if (stats.mtimeMs !== void 0 && Number.isFinite(stats.mtimeMs)) {
+          return stats.mtimeMs;
+        }
+        throw new Error(`birthtime unavailable for '${filePath}'`);
+      }
+    });
+    let count = 0;
+    for (const file of sorted) {
+      const content = dependencies.fileSystem.readText(file);
+      const tasks = parseTasks(content, file);
+      const filtered = includeAll ? tasks : tasks.filter((task) => !task.checked);
+      for (const task of filtered) {
+        const blocked = !task.checked && hasUncheckedDescendants(task, tasks);
+        emit({ kind: "task", task, blocked });
+        count++;
+      }
+    }
+    if (count === 0) {
+      emit({ kind: "info", message: "No tasks found." });
+    }
+    return 0;
+  };
+}
+
+// src/application/next-task.ts
+function createNextTask(dependencies) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  return async function nextTask(options) {
+    const { source, sortMode } = options;
+    const files = await dependencies.sourceResolver.resolveSources(source);
+    if (files.length === 0) {
+      emit({ kind: "warn", message: "No Markdown files found matching: " + source });
+      return 3;
+    }
+    const result = dependencies.taskSelector.selectNextTask(files, sortMode);
+    if (!result) {
+      emit({ kind: "info", message: "No unchecked tasks found." });
+      return 3;
+    }
+    emit({ kind: "task", task: result.task });
+    return 0;
+  };
+}
+
+// src/application/init-project.ts
+var CONFIG_DIR = ".rundown";
+function createInitProject(dependencies) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  return async function initProject() {
+    if (!dependencies.fileSystem.exists(CONFIG_DIR)) {
+      dependencies.fileSystem.mkdir(CONFIG_DIR, { recursive: true });
+    }
+    const write = (name, content) => {
+      const filePath = `${CONFIG_DIR}/${name}`;
+      if (dependencies.fileSystem.exists(filePath)) {
+        emit({ kind: "warn", message: `${filePath} already exists, skipping.` });
+        return;
+      }
+      dependencies.fileSystem.writeText(filePath, content);
+      emit({ kind: "success", message: `Created ${filePath}` });
+    };
+    write("execute.md", DEFAULT_TASK_TEMPLATE);
+    write("verify.md", DEFAULT_VALIDATE_TEMPLATE);
+    write("repair.md", DEFAULT_CORRECT_TEMPLATE);
+    write("plan.md", DEFAULT_PLAN_TEMPLATE);
+    write("vars.json", DEFAULT_VARS_FILE_CONTENT);
+    emit({ kind: "success", message: "Initialized .rundown/ with default templates." });
+    return 0;
+  };
+}
+
+// src/application/manage-artifacts.ts
+function createManageArtifacts(dependencies) {
+  const emit = dependencies.output.emit.bind(dependencies.output);
+  return function manageArtifacts(options) {
+    const shouldClean = options.clean;
+    const shouldPrintJson = options.json;
+    const onlyFailed = options.failed;
+    const runToOpen = options.open;
+    const cwd = options.cwd ?? dependencies.workingDirectory.cwd();
+    if (shouldClean && (shouldPrintJson || runToOpen)) {
+      emit({ kind: "error", message: "--clean cannot be combined with --json or --open." });
+      return 1;
+    }
+    if (runToOpen && (shouldPrintJson || onlyFailed)) {
+      emit({ kind: "error", message: "--open cannot be combined with --json or --failed." });
+      return 1;
+    }
+    if (runToOpen) {
+      const run = runToOpen === "latest" ? dependencies.artifactStore.latest(cwd) : dependencies.artifactStore.find(runToOpen, cwd);
+      if (!run) {
+        emit({ kind: "error", message: "No saved runtime artifact run found for: " + runToOpen });
+        return 3;
+      }
+      dependencies.directoryOpener.openDirectory(run.rootDir);
+      emit({ kind: "success", message: "Opened runtime artifacts: " + run.relativePath });
+      return 0;
+    }
+    if (shouldClean) {
+      const removed = onlyFailed ? dependencies.artifactStore.removeFailed(cwd) : dependencies.artifactStore.removeSaved(cwd);
+      if (removed === 0) {
+        emit({ kind: "info", message: onlyFailed ? "No failed runtime artifacts found." : "No saved runtime artifacts found." });
+        return 0;
+      }
+      emit({
+        kind: "success",
+        message: "Removed " + removed + " " + (onlyFailed ? "failed " : "") + "runtime artifact run" + (removed === 1 ? "" : "s") + "."
+      });
+      return 0;
+    }
+    const runs = onlyFailed ? dependencies.artifactStore.listFailed(cwd) : dependencies.artifactStore.listSaved(cwd);
+    if (runs.length === 0) {
+      emit({ kind: "info", message: onlyFailed ? "No failed runtime artifacts found." : "No saved runtime artifacts found." });
+      return 0;
+    }
+    if (shouldPrintJson) {
+      emit({ kind: "text", text: JSON.stringify(runs, null, 2) });
+      return 0;
+    }
+    for (const run of runs) {
+      const worker = run.workerCommand?.join(" ") ?? run.commandName;
+      const summary = [
+        run.runId,
+        `[status=${run.status ?? "unknown"}]`,
+        `[command=${run.commandName}]`,
+        `[mode=${run.mode ?? "n/a"}]`,
+        `[transport=${run.transport ?? "n/a"}]`,
+        run.relativePath
+      ].join(" ");
+      emit({ kind: "text", text: summary });
+      if (run.task) {
+        emit({ kind: "text", text: "  task: " + run.task.text + " \u2014 " + run.task.file + ":" + run.task.line });
+      }
+      emit({ kind: "text", text: "  worker: " + worker });
+      emit({ kind: "text", text: "  started: " + run.startedAt });
+    }
+    return 0;
+  };
+}
+
+// src/infrastructure/adapters/fs-file-system.ts
+import fs from "fs";
+function createNodeFileSystem() {
+  return {
+    exists(filePath) {
+      return fs.existsSync(filePath);
+    },
+    readText(filePath) {
+      return fs.readFileSync(filePath, "utf-8");
+    },
+    writeText(filePath, content) {
+      fs.writeFileSync(filePath, content, "utf-8");
+    },
+    mkdir(dirPath, options) {
+      fs.mkdirSync(dirPath, options);
+    },
+    readdir(dirPath) {
+      const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+      return entries.map((entry) => ({
+        name: entry.name,
+        isFile: entry.isFile(),
+        isDirectory: entry.isDirectory()
+      }));
+    },
+    stat(filePath) {
+      try {
+        const stats = fs.statSync(filePath);
+        const value = {
+          isFile: stats.isFile(),
+          isDirectory: stats.isDirectory(),
+          birthtimeMs: stats.birthtimeMs,
+          mtimeMs: stats.mtimeMs
+        };
+        return value;
+      } catch {
+        return null;
+      }
+    },
+    unlink(filePath) {
+      fs.unlinkSync(filePath);
+    },
+    rm(filePath, options) {
+      fs.rmSync(filePath, options);
+    }
+  };
+}
+
+// src/infrastructure/adapters/crossspawn-process-runner.ts
+import spawn from "cross-spawn";
+function createCrossSpawnProcessRunner() {
+  return {
+    run(options) {
+      return runWithCrossSpawn(options);
+    }
+  };
+}
+function runWithCrossSpawn(options) {
+  return new Promise((resolve, reject) => {
+    const { command, args, cwd, mode, shell, env, timeoutMs } = options;
+    if (mode === "detached") {
+      const child2 = spawn(command, args, {
+        cwd,
+        shell: shell ?? false,
+        env,
+        stdio: "ignore",
+        detached: true
+      });
+      child2.on("error", reject);
+      child2.unref();
+      resolve({ exitCode: null, stdout: "", stderr: "" });
+      return;
+    }
+    if (mode === "tui") {
+      const child2 = spawn(command, args, {
+        cwd,
+        shell: shell ?? false,
+        env,
+        stdio: "inherit"
+      });
+      child2.on("close", (exitCode) => {
+        resolve({ exitCode, stdout: "", stderr: "" });
+      });
+      child2.on("error", reject);
+      return;
+    }
+    const child = spawn(command, args, {
+      cwd,
+      shell: shell ?? false,
+      env,
+      stdio: ["inherit", "pipe", "pipe"]
+    });
+    const stdout = [];
+    const stderr = [];
+    let timeoutHandle = null;
+    if (typeof timeoutMs === "number" && timeoutMs > 0) {
+      timeoutHandle = setTimeout(() => {
+        child.kill("SIGTERM");
+      }, timeoutMs);
+    }
+    child.stdout?.on("data", (chunk) => stdout.push(chunk));
+    child.stderr?.on("data", (chunk) => stderr.push(chunk));
+    child.on("error", reject);
+    child.on("close", (exitCode) => {
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      resolve({
+        exitCode,
+        stdout: Buffer.concat(stdout).toString("utf-8"),
+        stderr: Buffer.concat(stderr).toString("utf-8")
+      });
+    });
+  });
+}
+
+// src/infrastructure/adapters/execfile-git-client.ts
+import { execFile } from "child_process";
+function createExecFileGitClient() {
+  return {
+    run(args, cwd, options) {
+      return runGit(args, cwd, options?.timeoutMs);
+    }
+  };
+}
+function runGit(args, cwd, timeoutMs = 3e4) {
+  return new Promise((resolve, reject) => {
+    execFile("git", args, { cwd, timeout: timeoutMs }, (error, stdout, stderr) => {
+      if (error) {
+        const message = stderr?.trim() || stdout?.trim() || error.message;
+        reject(new Error(`git ${args[0]}: ${message}`));
+        return;
+      }
+      resolve(stdout.trim());
+    });
+  });
+}
+
+// src/infrastructure/adapters/fs-template-loader.ts
+import fs2 from "fs";
+function createFsTemplateLoader() {
+  return {
+    load(filePath) {
+      try {
+        return fs2.readFileSync(filePath, "utf-8");
+      } catch {
+        return null;
+      }
+    }
+  };
+}
+
+// src/infrastructure/adapters/fs-validation-sidecar.ts
+import fs3 from "fs";
+function createFsValidationSidecar() {
+  return {
+    filePath(task) {
+      return validationFilePath(task);
+    },
+    read(task) {
+      const filePath = validationFilePath(task);
+      try {
+        return fs3.readFileSync(filePath, "utf-8").trim();
+      } catch {
+        return null;
+      }
+    },
+    remove(task) {
+      const filePath = validationFilePath(task);
+      try {
+        fs3.unlinkSync(filePath);
+      } catch {
+      }
+    }
+  };
+}
+function validationFilePath(task) {
+  return `${task.file}.${task.index}.validation`;
+}
+
+// src/infrastructure/runtime-artifacts.ts
+import fs4 from "fs";
+import path4 from "path";
+import { randomBytes } from "crypto";
+function createRuntimeArtifactsContext(options) {
+  const cwd = options.cwd ?? process.cwd();
+  const rootBase = path4.join(cwd, ".rundown", "runs");
+  fs4.mkdirSync(rootBase, { recursive: true });
+  const runId = buildRunId();
+  const rootDir = path4.join(rootBase, runId);
+  fs4.mkdirSync(rootDir, { recursive: true });
+  const context = {
+    runId,
+    rootDir,
+    cwd,
+    keepArtifacts: options.keepArtifacts ?? false,
+    commandName: options.commandName,
+    workerCommand: options.workerCommand,
+    mode: options.mode,
+    transport: options.transport,
+    task: options.task,
+    sequence: 0
+  };
+  const metadata = {
+    runId,
+    commandName: options.commandName,
+    workerCommand: options.workerCommand,
+    mode: options.mode,
+    transport: options.transport,
+    source: options.source,
+    task: options.task,
+    keepArtifacts: context.keepArtifacts,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  writeJson(path4.join(rootDir, "run.json"), metadata);
+  return context;
+}
+function runtimeArtifactsRootDir(cwd = process.cwd()) {
+  return path4.join(cwd, ".rundown", "runs");
+}
+function listSavedRuntimeArtifacts(cwd = process.cwd()) {
+  const rootDir = runtimeArtifactsRootDir(cwd);
+  if (!fs4.existsSync(rootDir)) {
+    return [];
+  }
+  const runs = [];
+  for (const entry of fs4.readdirSync(rootDir, { withFileTypes: true })) {
+    if (!entry.isDirectory()) {
+      continue;
+    }
+    const runDir = path4.join(rootDir, entry.name);
+    const metadata = readJson(path4.join(runDir, "run.json"));
+    if (!metadata) {
+      continue;
+    }
+    runs.push({
+      runId: metadata.runId,
+      rootDir: runDir,
+      relativePath: path4.relative(cwd, runDir).split(path4.sep).join("/"),
+      commandName: metadata.commandName,
+      workerCommand: metadata.workerCommand,
+      mode: metadata.mode,
+      transport: metadata.transport,
+      source: metadata.source,
+      task: metadata.task,
+      keepArtifacts: metadata.keepArtifacts,
+      startedAt: metadata.startedAt,
+      completedAt: metadata.completedAt,
+      status: metadata.status
+    });
+  }
+  runs.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+  return runs;
+}
+function listFailedRuntimeArtifacts(cwd = process.cwd()) {
+  return listSavedRuntimeArtifacts(cwd).filter((run) => isFailedRuntimeArtifactStatus(run.status));
+}
+function latestSavedRuntimeArtifact(cwd = process.cwd()) {
+  return listSavedRuntimeArtifacts(cwd)[0] ?? null;
+}
+function findSavedRuntimeArtifact(runId, cwd = process.cwd()) {
+  const runs = listSavedRuntimeArtifacts(cwd);
+  const exact = runs.find((run) => run.runId === runId);
+  if (exact) {
+    return exact;
+  }
+  const prefixMatches = runs.filter((run) => run.runId.startsWith(runId));
+  if (prefixMatches.length === 1) {
+    return prefixMatches[0] ?? null;
+  }
+  return null;
+}
+function removeSavedRuntimeArtifacts(cwd = process.cwd()) {
+  return removeRuntimeArtifactsMatching(() => true, cwd);
+}
+function removeFailedRuntimeArtifacts(cwd = process.cwd()) {
+  return removeRuntimeArtifactsMatching((run) => isFailedRuntimeArtifactStatus(run.status), cwd);
+}
+function removeRuntimeArtifactsMatching(predicate, cwd) {
+  const rootDir = runtimeArtifactsRootDir(cwd);
+  if (!fs4.existsSync(rootDir)) {
+    return 0;
+  }
+  const runs = listSavedRuntimeArtifacts(cwd);
+  let removed = 0;
+  for (const run of runs) {
+    if (!predicate(run)) {
+      continue;
+    }
+    fs4.rmSync(run.rootDir, { recursive: true, force: true });
+    removed += 1;
+  }
+  return removed;
+}
+function isFailedRuntimeArtifactStatus(status) {
+  if (!status) {
+    return false;
+  }
+  return status.includes("failed");
+}
+function beginRuntimePhase(context, options) {
+  context.sequence += 1;
+  const sequence = context.sequence;
+  const dirName = `${String(sequence).padStart(2, "0")}-${options.phase}`;
+  const dir = path4.join(context.rootDir, dirName);
+  fs4.mkdirSync(dir, { recursive: true });
+  const promptFile = options.prompt === void 0 ? null : path4.join(dir, "prompt.md");
+  if (promptFile) {
+    fs4.writeFileSync(promptFile, options.prompt ?? "", "utf-8");
+  }
+  const metadata = {
+    runId: context.runId,
+    sequence,
+    phase: options.phase,
+    command: options.command,
+    mode: options.mode,
+    transport: options.transport,
+    task: context.task,
+    promptFile: promptFile ? "prompt.md" : null,
+    stdoutFile: null,
+    stderrFile: null,
+    outputCaptured: false,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    notes: options.notes,
+    extra: options.extra
+  };
+  const metadataFile = path4.join(dir, "metadata.json");
+  writeJson(metadataFile, metadata);
+  return {
+    context,
+    phase: options.phase,
+    sequence,
+    dir,
+    promptFile,
+    metadataFile,
+    metadata
+  };
+}
+function completeRuntimePhase(handle, options) {
+  handle.metadata.exitCode = options.exitCode;
+  handle.metadata.outputCaptured = options.outputCaptured;
+  handle.metadata.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  if (options.stdout !== void 0 && options.stdout.length > 0) {
+    fs4.writeFileSync(path4.join(handle.dir, "stdout.log"), options.stdout, "utf-8");
+    handle.metadata.stdoutFile = "stdout.log";
+  }
+  if (options.stderr !== void 0 && options.stderr.length > 0) {
+    fs4.writeFileSync(path4.join(handle.dir, "stderr.log"), options.stderr, "utf-8");
+    handle.metadata.stderrFile = "stderr.log";
+  }
+  if (options.notes !== void 0) {
+    handle.metadata.notes = options.notes;
+  }
+  if (options.extra !== void 0) {
+    handle.metadata.extra = {
+      ...handle.metadata.extra ?? {},
+      ...options.extra
+    };
+  }
+  writeJson(handle.metadataFile, handle.metadata);
+}
+function finalizeRuntimeArtifacts(context, options) {
+  const metadataFile = path4.join(context.rootDir, "run.json");
+  const metadata = readJson(metadataFile) ?? {
+    runId: context.runId,
+    commandName: context.commandName,
+    workerCommand: context.workerCommand,
+    mode: context.mode,
+    transport: context.transport,
+    task: context.task,
+    keepArtifacts: context.keepArtifacts,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  metadata.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+  metadata.status = options.status;
+  writeJson(metadataFile, metadata);
+  if (!options.preserve) {
+    fs4.rmSync(context.rootDir, { recursive: true, force: true });
+  }
+}
+function displayArtifactsPath(context) {
+  const relative = path4.relative(context.cwd, context.rootDir);
+  return relative === "" ? path4.basename(context.rootDir) : relative.split(path4.sep).join("/");
+}
+function buildRunId() {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:.]/g, "").replace("Z", "Z");
+  const suffix = randomBytes(4).toString("hex");
+  return `run-${timestamp}-${suffix}`;
+}
+function writeJson(filePath, value) {
+  fs4.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}
+`, "utf-8");
+}
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs4.readFileSync(filePath, "utf-8"));
+  } catch {
+    return null;
+  }
+}
+
+// src/infrastructure/adapters/fs-artifact-store.ts
+var toRuntimePhase = (phase) => phase;
+function createFsArtifactStore() {
+  return {
+    createContext(options) {
+      return createRuntimeArtifactsContext(options);
+    },
+    beginPhase(context, options) {
+      const runtimeOptions = {
+        ...options,
+        phase: toRuntimePhase(options.phase)
+      };
+      return beginRuntimePhase(context, runtimeOptions);
+    },
+    completePhase(handle, options) {
+      const runtimeOptions = options;
+      completeRuntimePhase(handle, runtimeOptions);
+    },
+    finalize(context, options) {
+      finalizeRuntimeArtifacts(context, {
+        status: options.status,
+        preserve: options.preserve
+      });
+    },
+    displayPath(context) {
+      return displayArtifactsPath(context);
+    },
+    rootDir(cwd) {
+      return runtimeArtifactsRootDir(cwd);
+    },
+    listSaved(cwd) {
+      return listSavedRuntimeArtifacts(cwd);
+    },
+    listFailed(cwd) {
+      return listFailedRuntimeArtifacts(cwd);
+    },
+    latest(cwd) {
+      return latestSavedRuntimeArtifact(cwd);
+    },
+    find(runId, cwd) {
+      return findSavedRuntimeArtifact(runId, cwd);
+    },
+    removeSaved(cwd) {
+      return removeSavedRuntimeArtifacts(cwd);
+    },
+    removeFailed(cwd) {
+      return removeFailedRuntimeArtifacts(cwd);
+    },
+    isFailedStatus(status) {
+      return isFailedRuntimeArtifactStatus(status);
+    }
+  };
+}
+
+// src/infrastructure/adapters/system-clock.ts
+function createSystemClock() {
+  return {
+    now() {
+      return /* @__PURE__ */ new Date();
+    },
+    nowIsoString() {
+      return (/* @__PURE__ */ new Date()).toISOString();
+    }
+  };
+}
+
+// src/infrastructure/sources.ts
+import fs5 from "fs";
+import path5 from "path";
+import fg from "fast-glob";
+async function resolveSources(source) {
+  const resolved = path5.resolve(source);
+  if (isFile(resolved)) {
+    return [resolved];
+  }
+  if (isDirectory(resolved)) {
+    const pattern = path5.join(resolved, "**/*.md").replace(/\\/g, "/");
+    return await fg(pattern, { absolute: true, onlyFiles: true });
+  }
+  const files = await fg(source.replace(/\\/g, "/"), {
+    absolute: true,
+    onlyFiles: true
+  });
+  return files.filter((f) => f.endsWith(".md"));
+}
+function isFile(p) {
+  try {
+    return fs5.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function isDirectory(p) {
+  try {
+    return fs5.statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+// src/infrastructure/adapters/source-resolver-adapter.ts
+function createSourceResolverAdapter() {
+  return {
+    resolveSources(source) {
+      return resolveSources(source);
+    }
+  };
+}
+
+// src/infrastructure/selector.ts
+import fs6 from "fs";
+
+// src/infrastructure/file-birthtime.ts
+function getFileBirthtimeMs(filePath, fileSystem) {
+  try {
+    return fileSystem.stat(filePath)?.birthtimeMs ?? 0;
+  } catch {
+    return 0;
+  }
+}
+
+// src/infrastructure/selector.ts
+var selectorFileSystem = {
+  stat(filePath) {
+    const stats = fs6.statSync(filePath);
+    return {
+      isFile: stats.isFile(),
+      isDirectory: stats.isDirectory(),
+      birthtimeMs: stats.birthtimeMs,
+      mtimeMs: stats.mtimeMs
+    };
+  }
+};
+function selectNextTask(files, sortMode = "name-sort") {
+  const sorted = sortFiles(files, sortMode, {
+    getBirthtimeMs: (filePath) => getFileBirthtimeMs(filePath, selectorFileSystem)
+  });
+  for (const file of sorted) {
+    const source = fs6.readFileSync(file, "utf-8");
+    const tasks = parseTasks(source, file);
+    const runnable = filterRunnable(tasks);
+    for (const task of runnable) {
+      const lines = source.split("\n");
+      const contextBefore = lines.slice(0, task.line - 1).join("\n");
+      return { task, source, contextBefore };
+    }
+  }
+  return null;
+}
+function selectTaskByLocation(file, line) {
+  const source = fs6.readFileSync(file, "utf-8");
+  const tasks = parseTasks(source, file);
+  const task = tasks.find((t) => t.line === line);
+  if (!task) {
+    return null;
+  }
+  const lines = source.split("\n");
+  const contextBefore = lines.slice(0, task.line - 1).join("\n");
+  return { task, source, contextBefore };
+}
+
+// src/infrastructure/adapters/task-selector-adapter.ts
+function createTaskSelectorAdapter() {
+  return {
+    selectNextTask(files, sortMode) {
+      return selectNextTask(files, sortMode);
+    },
+    selectTaskByLocation(filePath, line) {
+      return selectTaskByLocation(filePath, line);
+    }
+  };
+}
+
+// src/infrastructure/inline-cli.ts
+import { spawn as spawn2 } from "child_process";
+async function executeInlineCli(command, cwd = process.cwd(), options) {
+  let ownedArtifactContext = null;
+  let artifactContext;
+  if (options?.artifactContext) {
+    artifactContext = options.artifactContext;
+  } else {
+    ownedArtifactContext = createRuntimeArtifactsContext({
+      cwd,
+      commandName: "inline-cli",
+      workerCommand: [command],
+      mode: "wait",
+      transport: "inline-cli",
+      keepArtifacts: options?.keepArtifacts ?? false
+    });
+    artifactContext = ownedArtifactContext;
+  }
+  const phase = beginRuntimePhase(artifactContext, {
+    phase: "inline-cli",
+    command: [command],
+    mode: "wait",
+    transport: "inline-cli",
+    extra: options?.artifactExtra
+  });
+  return new Promise((resolve, reject) => {
+    const child = spawn2(command, {
+      stdio: ["inherit", "pipe", "pipe"],
+      cwd,
+      shell: true
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout?.on("data", (chunk) => stdout.push(chunk));
+    child.stderr?.on("data", (chunk) => stderr.push(chunk));
+    child.on("close", (code) => {
+      const result = {
+        exitCode: code,
+        stdout: Buffer.concat(stdout).toString("utf-8"),
+        stderr: Buffer.concat(stderr).toString("utf-8")
+      };
+      completeRuntimePhase(phase, {
+        exitCode: code,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        outputCaptured: true
+      });
+      if (ownedArtifactContext) {
+        finalizeRuntimeArtifacts(ownedArtifactContext, {
+          status: code === 0 ? "completed" : "failed",
+          preserve: options?.keepArtifacts ?? false
+        });
+      }
+      resolve(result);
+    });
+    child.on("error", (error) => {
+      completeRuntimePhase(phase, {
+        exitCode: null,
+        outputCaptured: true,
+        notes: error.message,
+        extra: { error: true }
+      });
+      if (ownedArtifactContext) {
+        finalizeRuntimeArtifacts(ownedArtifactContext, {
+          status: "failed",
+          preserve: options?.keepArtifacts ?? false
+        });
+      }
+      reject(error);
+    });
+  });
+}
+
+// src/infrastructure/runner.ts
+import os from "os";
+import path6 from "path";
+import spawn3 from "cross-spawn";
+async function runWorker(options) {
+  const mode = options.mode ?? "wait";
+  const transport = options.transport ?? "file";
+  const cwd = options.cwd ?? process.cwd();
+  let ownedArtifactContext = null;
+  let artifactContext;
+  if (options.artifactContext) {
+    artifactContext = options.artifactContext;
+  } else {
+    ownedArtifactContext = createRuntimeArtifactsContext({
+      cwd,
+      commandName: "worker",
+      workerCommand: options.command,
+      mode,
+      transport,
+      keepArtifacts: options.keepArtifacts ?? false
+    });
+    artifactContext = ownedArtifactContext;
+  }
+  const phase = beginRuntimePhase(artifactContext, {
+    phase: options.artifactPhase ?? "worker",
+    prompt: options.prompt,
+    command: options.command,
+    mode,
+    transport,
+    notes: buildCaptureNotes(mode),
+    extra: options.artifactExtra
+  });
+  const transportPromptFile = transport === "file" ? phase.promptFile : null;
+  const args = buildWorkerArgs(options.command, options.prompt, transport, transportPromptFile, cwd);
+  const [cmd, ...cmdArgs] = args;
+  if (!cmd) {
+    throw new Error("No command specified after --");
+  }
+  try {
+    const result = await executeCommand(cmd, cmdArgs, mode, cwd);
+    completeRuntimePhase(phase, {
+      exitCode: result.exitCode,
+      stdout: result.stdout,
+      stderr: result.stderr,
+      outputCaptured: mode === "wait"
+    });
+    return result;
+  } catch (error) {
+    completeRuntimePhase(phase, {
+      exitCode: null,
+      outputCaptured: mode === "wait",
+      notes: error instanceof Error ? error.message : String(error),
+      extra: { error: true }
+    });
+    throw error;
+  } finally {
+    if (ownedArtifactContext) {
+      finalizeRuntimeArtifacts(ownedArtifactContext, {
+        status: mode === "detached" ? "detached" : "completed",
+        preserve: (options.keepArtifacts ?? false) || mode === "detached"
+      });
+    }
+  }
+}
+function buildWorkerArgs(command, prompt, transport, promptFile, cwd) {
+  if (command.length === 0) {
+    return [];
+  }
+  if (isOpenCodeCommand(command[0])) {
+    return buildOpenCodeArgs(command, prompt, promptFile, cwd);
+  }
+  const args = [...command];
+  if (transport === "file") {
+    if (!promptFile) {
+      throw new Error("Prompt file transport requested but no prompt file was created.");
+    }
+    args.push(promptFile);
+  } else {
+    args.push(prompt);
+  }
+  return args;
+}
+function isOpenCodeCommand(command) {
+  const normalized = path6.basename(command).toLowerCase();
+  return normalized === "opencode" || normalized === "opencode.cmd" || normalized === "opencode.exe" || normalized === "opencode.ps1";
+}
+function buildOpenCodeArgs(command, prompt, promptFile, cwd) {
+  const [cmd, ...rest] = command;
+  if (rest[0] === "run") {
+    const args = [cmd, ...rest];
+    if (promptFile) {
+      args.push(buildOpenCodeRunBootstrapPrompt());
+      args.push("--file", promptFile);
+      return args;
+    }
+    args.push(prompt);
+    return args;
+  }
+  if (promptFile) {
+    return [cmd, ...rest, buildOpenCodeTuiPromptArg(buildOpenCodeTuiBootstrapPrompt(promptFile, cwd))];
+  }
+  return [cmd, ...rest, buildOpenCodeTuiPromptArg(prompt)];
+}
+function buildOpenCodeRunBootstrapPrompt() {
+  return "Read the attached Markdown file first. It contains the full task instructions and context for this run.";
+}
+function buildOpenCodeTuiBootstrapPrompt(tempFile, cwd) {
+  const displayPath = path6.relative(cwd, tempFile) || path6.basename(tempFile);
+  const normalizedPath = displayPath.split(path6.sep).join("/");
+  return `The full rendered rundown task prompt is staged in ${normalizedPath}. Open and read that file completely before taking any action, then continue the work in this session.`;
+}
+function buildOpenCodeTuiPromptArg(prompt) {
+  return `--prompt=${prompt}`;
+}
+function executeCommand(cmd, args, mode, cwd) {
+  return new Promise((resolve, reject) => {
+    if (mode === "tui") {
+      if (os.platform() === "win32") {
+        const child3 = spawn3(
+          "cmd",
+          ["/c", "start", "/wait", '""', cmd, ...args],
+          { stdio: "ignore", cwd, shell: false }
+        );
+        child3.on("close", (code) => {
+          resolve({ exitCode: code, stdout: "", stderr: "" });
+        });
+        child3.on("error", reject);
+        return;
+      }
+      const child2 = spawn3(cmd, args, {
+        stdio: "inherit",
+        cwd,
+        shell: false
+      });
+      child2.on("close", (code) => {
+        resolve({ exitCode: code, stdout: "", stderr: "" });
+      });
+      child2.on("error", reject);
+      return;
+    }
+    if (mode === "detached") {
+      const child2 = spawn3(cmd, args, {
+        stdio: "ignore",
+        cwd,
+        shell: false,
+        detached: true
+      });
+      child2.unref();
+      resolve({ exitCode: null, stdout: "", stderr: "" });
+      return;
+    }
+    const child = spawn3(cmd, args, {
+      stdio: ["inherit", "pipe", "pipe"],
+      cwd,
+      shell: false
+    });
+    const stdout = [];
+    const stderr = [];
+    child.stdout?.on("data", (chunk) => stdout.push(chunk));
+    child.stderr?.on("data", (chunk) => stderr.push(chunk));
+    child.on("close", (code) => {
+      resolve({
+        exitCode: code,
+        stdout: Buffer.concat(stdout).toString("utf-8"),
+        stderr: Buffer.concat(stderr).toString("utf-8")
+      });
+    });
+    child.on("error", reject);
+  });
+}
+function buildCaptureNotes(mode) {
+  if (mode === "wait") {
+    return void 0;
+  }
+  if (mode === "tui") {
+    return "Interactive TUI mode does not capture worker stdout/stderr transcripts.";
+  }
+  return "Detached mode does not capture worker stdout/stderr and leaves runtime artifacts in place.";
+}
+
+// src/infrastructure/adapters/worker-executor-adapter.ts
+function createWorkerExecutorAdapter() {
+  return {
+    async runWorker(options) {
+      return runWorker({
+        command: options.command,
+        prompt: options.prompt,
+        mode: options.mode,
+        transport: options.transport,
+        cwd: options.cwd,
+        artifactContext: options.artifactContext,
+        artifactPhase: options.artifactPhase,
+        artifactExtra: options.artifactExtra
+      });
+    },
+    async executeInlineCli(command, cwd, options) {
+      return executeInlineCli(command, cwd, {
+        artifactContext: options?.artifactContext,
+        keepArtifacts: options?.keepArtifacts,
+        artifactExtra: options?.artifactExtra
+      });
+    }
+  };
+}
+
+// src/infrastructure/validation.ts
+import fs7 from "fs";
+function validationFilePath2(task) {
+  return `${task.file}.${task.index}.validation`;
+}
+function readValidationFile(task) {
+  const p = validationFilePath2(task);
+  try {
+    return fs7.readFileSync(p, "utf-8").trim();
+  } catch {
+    return null;
+  }
+}
+function removeValidationFile(task) {
+  const p = validationFilePath2(task);
+  try {
+    fs7.unlinkSync(p);
+  } catch {
+  }
+}
+function isValidationOk(task) {
+  const content = readValidationFile(task);
+  return content !== null && content.toUpperCase() === "OK";
+}
+async function validate(options) {
+  const vars = {
+    ...options.templateVars,
+    task: options.task.text,
+    file: options.task.file,
+    context: options.contextBefore,
+    taskIndex: options.task.index,
+    taskLine: options.task.line,
+    source: options.source
+  };
+  const prompt = renderTemplate(options.template, vars);
+  removeValidationFile(options.task);
+  const runResult = await runWorker({
+    command: options.command,
+    prompt,
+    mode: options.mode ?? "wait",
+    transport: options.transport ?? "file",
+    cwd: options.cwd,
+    artifactContext: options.artifactContext,
+    artifactPhase: "verify"
+  });
+  if (runResult.exitCode !== 0) {
+    return false;
+  }
+  return isValidationOk(options.task);
+}
+
+// src/infrastructure/adapters/task-validation-adapter.ts
+function createTaskValidationAdapter() {
+  return {
+    validate(options) {
+      return validate({
+        ...options,
+        templateVars: options.templateVars,
+        artifactContext: options.artifactContext
+      });
+    }
+  };
+}
+
+// src/infrastructure/correction.ts
+async function correct(options) {
+  let attempts = 0;
+  for (let i = 0; i < options.maxRetries; i++) {
+    attempts++;
+    const validationResult = readValidationFile(options.task) ?? "Validation failed (no details).";
+    const vars = {
+      ...options.templateVars,
+      task: options.task.text,
+      file: options.task.file,
+      context: options.contextBefore,
+      taskIndex: options.task.index,
+      taskLine: options.task.line,
+      source: options.source,
+      validationResult
+    };
+    const prompt = renderTemplate(options.correctTemplate, vars);
+    await runWorker({
+      command: options.command,
+      prompt,
+      mode: options.mode ?? "wait",
+      transport: options.transport ?? "file",
+      cwd: options.cwd,
+      artifactContext: options.artifactContext,
+      artifactPhase: "repair",
+      artifactExtra: { attempt: attempts }
+    });
+    const valid = await validate({
+      task: options.task,
+      source: options.source,
+      contextBefore: options.contextBefore,
+      template: options.validateTemplate,
+      command: options.command,
+      mode: options.mode,
+      transport: options.transport,
+      cwd: options.cwd,
+      templateVars: options.templateVars,
+      artifactContext: options.artifactContext
+    });
+    if (valid) {
+      return { valid: true, attempts };
+    }
+  }
+  return { valid: false, attempts };
+}
+
+// src/infrastructure/adapters/task-correction-adapter.ts
+function createTaskCorrectionAdapter() {
+  return {
+    correct(options) {
+      return correct({
+        ...options,
+        templateVars: options.templateVars,
+        artifactContext: options.artifactContext
+      });
+    }
+  };
+}
+
+// src/infrastructure/adapters/working-directory-adapter.ts
+function createWorkingDirectoryAdapter() {
+  return {
+    cwd() {
+      return process.cwd();
+    }
+  };
+}
+
+// src/infrastructure/open-directory.ts
+import { spawn as spawn4 } from "child_process";
+function openDirectory(dirPath) {
+  if (process.platform === "win32") {
+    const child2 = spawn4("explorer", [dirPath], {
+      detached: true,
+      stdio: "ignore",
+      shell: false
+    });
+    child2.unref();
+    return;
+  }
+  if (process.platform === "darwin") {
+    const child2 = spawn4("open", [dirPath], {
+      detached: true,
+      stdio: "ignore",
+      shell: false
+    });
+    child2.unref();
+    return;
+  }
+  const child = spawn4("xdg-open", [dirPath], {
+    detached: true,
+    stdio: "ignore",
+    shell: false
+  });
+  child.unref();
+}
+
+// src/infrastructure/adapters/directory-opener-adapter.ts
+function createDirectoryOpenerAdapter() {
+  return {
+    openDirectory
+  };
+}
+
+// src/create-app.ts
+function createAppPorts(overrides = {}) {
+  return {
+    fileSystem: overrides.fileSystem ?? createNodeFileSystem(),
+    processRunner: overrides.processRunner ?? createCrossSpawnProcessRunner(),
+    gitClient: overrides.gitClient ?? createExecFileGitClient(),
+    templateLoader: overrides.templateLoader ?? createFsTemplateLoader(),
+    validationSidecar: overrides.validationSidecar ?? createFsValidationSidecar(),
+    artifactStore: overrides.artifactStore ?? createFsArtifactStore(),
+    clock: overrides.clock ?? createSystemClock(),
+    directoryOpener: overrides.directoryOpener ?? createDirectoryOpenerAdapter(),
+    sourceResolver: overrides.sourceResolver ?? createSourceResolverAdapter(),
+    taskSelector: overrides.taskSelector ?? createTaskSelectorAdapter(),
+    workerExecutor: overrides.workerExecutor ?? createWorkerExecutorAdapter(),
+    taskValidation: overrides.taskValidation ?? createTaskValidationAdapter(),
+    taskCorrection: overrides.taskCorrection ?? createTaskCorrectionAdapter(),
+    workingDirectory: overrides.workingDirectory ?? createWorkingDirectoryAdapter(),
+    output: overrides.output ?? createNoopOutputPort()
+  };
+}
+function createNoopOutputPort() {
+  return {
+    emit() {
+    }
+  };
+}
+function createDefaultUseCaseFactories() {
+  return {
+    runTask: (ports) => createRunTask({
+      sourceResolver: ports.sourceResolver,
+      taskSelector: ports.taskSelector,
+      workerExecutor: ports.workerExecutor,
+      taskValidation: ports.taskValidation,
+      taskCorrection: ports.taskCorrection,
+      workingDirectory: ports.workingDirectory,
+      fileSystem: ports.fileSystem,
+      templateLoader: ports.templateLoader,
+      validationSidecar: ports.validationSidecar,
+      artifactStore: ports.artifactStore,
+      gitClient: ports.gitClient,
+      processRunner: ports.processRunner,
+      output: ports.output
+    }),
+    planTask: (ports) => createPlanTask({
+      sourceResolver: ports.sourceResolver,
+      taskSelector: ports.taskSelector,
+      workerExecutor: ports.workerExecutor,
+      workingDirectory: ports.workingDirectory,
+      fileSystem: ports.fileSystem,
+      templateLoader: ports.templateLoader,
+      artifactStore: ports.artifactStore,
+      output: ports.output
+    }),
+    listTasks: (ports) => createListTasks({
+      fileSystem: ports.fileSystem,
+      sourceResolver: ports.sourceResolver,
+      output: ports.output
+    }),
+    nextTask: (ports) => createNextTask({
+      sourceResolver: ports.sourceResolver,
+      taskSelector: ports.taskSelector,
+      output: ports.output
+    }),
+    initProject: (ports) => createInitProject({
+      fileSystem: ports.fileSystem,
+      output: ports.output
+    }),
+    manageArtifacts: (ports) => createManageArtifacts({
+      artifactStore: ports.artifactStore,
+      directoryOpener: ports.directoryOpener,
+      workingDirectory: ports.workingDirectory,
+      output: ports.output
+    })
+  };
+}
+function createAppFromFactories(ports, factoryOverrides = {}) {
+  const factories = {
+    ...createDefaultUseCaseFactories(),
+    ...factoryOverrides
+  };
+  return {
+    runTask: factories.runTask(ports),
+    planTask: factories.planTask(ports),
+    listTasks: factories.listTasks(ports),
+    nextTask: factories.nextTask(ports),
+    initProject: factories.initProject(ports),
+    manageArtifacts: factories.manageArtifacts(ports)
+  };
+}
+function createApp(dependencies = {}) {
+  const portOverrides = dependencies.ports ?? {};
+  const useCaseFactoryOverrides = dependencies.useCaseFactories ?? {};
+  const ports = createAppPorts(portOverrides);
+  return createAppFromFactories(ports, useCaseFactoryOverrides);
+}
+export {
+  createApp
+};
+//# sourceMappingURL=index.js.map