@bastani/atomic 0.9.16-alpha.7 → 0.9.16-alpha.8

package/dist/builtin/workflows/builtin/goal-types.ts

@@ -1,164 +0,0 @@
-import type { ReviewConvergenceSummary } from "./review-convergence.js";
-import type { ReverifyAuditEntry } from "./goal-reverify.js";
-import type { ConvergenceEntry } from "./goal-convergence.js";
-
-export const DEFAULT_MAX_TURNS = 10;
-// Goal Runner runs three independent reviewer personas; two approvals form a majority.
-export const DEFAULT_REVIEW_QUORUM = 2;
-export const DEFAULT_BLOCKER_THRESHOLD = 3;
-export const LEDGER_FILENAME = "goal-ledger.json";
-
-export type GoalStatus = "active" | "complete" | "blocked" | "needs_human";
-export type ReviewGateDecisionValue = "complete" | "continue" | "blocked";
-
-export type WorkReceipt = {
-  readonly turn: number;
-  readonly stage: string;
-  readonly artifact_path: string;
-  readonly summary: string;
-};
-
-export type ObjectiveAlignment =
-  | "required_by_objective"
-  | "consistent_with_objective"
-  | "beyond_objective"
-  | "contradicts_objective";
-
-export type RequirementTraceability = {
-  readonly requirement: string;
-  readonly status: "proven" | "contradicted" | "missing" | "unverified";
-  readonly evidence: string;
-};
-
-export type ReviewFinding = {
-  readonly title: string;
-  readonly body: string;
-  readonly confidence_score: number;
-  readonly objective_alignment: ObjectiveAlignment;
-  readonly priority?: number | null;
-  readonly code_location: {
-    readonly absolute_file_path: string;
-    readonly line_range: {
-      readonly start: number;
-      readonly end: number;
-    };
-  };
-};
-
-export type ReviewerError = {
-  readonly kind:
-    | "validation_unavailable"
-    | "dependency_unavailable"
-    | "tool_failure"
-    | "reviewer_failure";
-  readonly message: string;
-  readonly attempted_recovery: string;
-};
-
-export type ReviewDecision = {
-  readonly findings: readonly ReviewFinding[];
-  readonly criterion_scores?: readonly { readonly criterion_id: string; readonly score: number }[];
-  readonly overall_correctness: "patch is correct" | "patch is incorrect";
-  readonly overall_explanation: string;
-  readonly overall_confidence_score: number;
-  readonly goal_oracle_satisfied: boolean;
-  readonly requirements_traceability: readonly RequirementTraceability[];
-  readonly receipt_assessment: string;
-  readonly verification_remaining: string;
-  readonly stop_review_loop: boolean;
-  readonly reviewer_error?: ReviewerError | null;
-};
-
-export type ReviewRecord = ReviewDecision & {
-  readonly decision: ReviewGateDecisionValue;
-  readonly evidence: readonly string[];
-  readonly gaps: readonly string[];
-  readonly blocker: string | null;
-  readonly confidence_score: number;
-  readonly explanation: string;
-  readonly turn: number;
-  readonly reviewer: string;
-  readonly artifact_path: string;
-  readonly parsed: boolean;
-  readonly approved: boolean;
-  readonly parse_diagnostics: readonly string[];
-  readonly convergence_decision: ReviewConvergenceSummary;
-};
-
-export type BlockerObservation = {
-  readonly turn: number;
-  readonly blocker: string;
-  readonly reviewers: readonly string[];
-};
-
-export type ReducerDecision = ReviewConvergenceSummary & {
-  readonly turn: number;
-  readonly decision: "complete" | "continue" | "blocked" | "needs_human";
-  readonly reason: string;
-  readonly complete_votes: number;
-  readonly review_quorum: number;
-  readonly blocker?: string;
-};
-
-export type GoalLifecycleEvent = {
-  readonly turn: number;
-  readonly event:
-    | "created"
-    | "work_turn_started"
-    | "receipt_recorded"
-    | "reviews_recorded"
-    | "status_decided";
-  readonly status: GoalStatus;
-  readonly at: string;
-  readonly summary: string;
-};
-
-export type GoalLedger = {
-  readonly goal_id: string;
-  readonly objective: string;
-  readonly acceptance_criteria: string;
-  status: GoalStatus;
-  turns: number;
-  readonly created_at: string;
-  updated_at: string;
-  receipts: WorkReceipt[];
-  reviews: ReviewRecord[];
-  blockers: BlockerObservation[];
-  decisions: ReducerDecision[];
-  lifecycle: GoalLifecycleEvent[];
-  /** V9 audit records; the original findings remain in `reviews`. */
-  reverification?: ReverifyAuditEntry<ReviewFinding>[];
-  convergence?: ConvergenceEntry[];
-};
-
-export type ReducerOutcome = {
-  readonly status: GoalStatus;
-  readonly decision: ReducerDecision;
-  readonly blockerObservation?: BlockerObservation;
-};
-
-export type GoalWorkflowInputs = {
-  readonly objective: string;
-  readonly acceptance_criteria?: string;
-  readonly max_turns: number;
-  readonly base_branch: string;
-  readonly git_worktree_dir: string;
-  readonly create_pr: boolean;
-};
-
-export type GoalWorkflowOutputs = {
-  readonly result?: string;
-  readonly status?: GoalStatus;
-  readonly approved?: boolean;
-  readonly goal_id?: string;
-  readonly objective?: string;
-  readonly acceptance_criteria?: string;
-  readonly ledger_path?: string;
-  readonly turns_completed?: number;
-  readonly iterations_completed?: number;
-  readonly receipts?: WorkReceipt[];
-  readonly remaining_work?: string;
-  readonly review_report?: string;
-  readonly review_report_path?: string;
-  readonly pr_report?: string;
-};

package/dist/builtin/workflows/builtin/goal.ts

@@ -1,78 +0,0 @@
-/**
- * Builtin workflow: goal
- *
- * Goal Runner workflow: persist an objective ledger, run bounded orchestrator
- * turns, gate completion through independent reviewers, and let plain TypeScript
- * reduce the final state.
- */
-
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.js";
-import { runGoalWorkflow } from "./goal-runner.js";
-import { DEFAULT_MAX_TURNS } from "./goal-types.js";
-
-export default workflow({
-  name: "goal",
-  description: "Goal Runner workflow with bounded sub-agent orchestration turns, immutable acceptance criteria, ledger artifacts, parallel reviewers, and reducer-gated completion. When launching follow-up goal runs from review findings, pass the ORIGINAL task text as acceptance_criteria so deltas cannot drift from the literal contract. If the task includes submitting a pull request (or MR/review), remove that final action from the objective text and set create_pr=true instead when preparing the workflow inputs.",
-  // The 15-minute default, stated rather than inherited: this is a per-workflow
-  // product decision, so a future change to the global default must not silently
-  // re-cadence a long autonomous run.
-  heartbeatIntervalMinutes: 15,
-  inputs: {
-    objective: Type.String({ description: "The objective or delta for this Goal Runner workflow run. Do not include PR/MR submission instructions here; strip them from the task text and request them via create_pr=true instead." }),
-    acceptance_criteria: Type.Optional(Type.String({ description: "Original immutable task contract this run must remain consistent with. Defaults to objective. Orchestrators launching follow-up runs from reviewer findings should pass the ORIGINAL task text here." })),
-    max_turns: Type.Number({
-      default: DEFAULT_MAX_TURNS,
-      description: "Maximum orchestrator/review turns before Goal Runner stops as needs_human.",
-    }),
-    base_branch: Type.String({
-      default: "origin/main",
-      description: "Optional branch reviewers compare the current code delta against (default origin/main).",
-    }),
-    git_worktree_dir: Type.String({
-      default: "",
-      description:
-        "Optional Git worktree path. Leave at the default unless the user explicitly requested worktree isolation — stages never create git worktrees on their own. Must start inside a Git repo; absolute paths are used as-is, relative paths resolve from the repo root, existing Git worktrees from the invoking repository are reused/shared as-is, and missing paths are created from base_branch.",
-    }),
-    create_pr: Type.Boolean({
-      default: false,
-      description:
-        "Whether to run the final pull-request creation stage after reviewer/reducer approval. Defaults to false; prompt text alone does not opt in. If the task asks to submit a PR/MR/review, remove that from the objective text and set this to true — only the final stage then attempts provider-appropriate PR/MR/review creation after Goal completes."
-    }),
-  },
-  outputs: {
-    result: Type.Optional(Type.String({ description: "Final report with objective, status, receipts, turns, and remaining work." })),
-    status: Type.Optional(Type.Union(
-      [Type.Literal("complete"), Type.Literal("blocked"), Type.Literal("needs_human"), Type.Literal("active")],
-      { description: "Final reducer status: complete, blocked, needs_human, or active if externally interrupted." },
-    )),
-    approved: Type.Optional(Type.Boolean({ description: "Whether the reducer reached complete." })),
-    goal_id: Type.Optional(Type.String({ description: "Per-run goal identifier stored in the ledger." })),
-    objective: Type.Optional(Type.String({ description: "Raw goal objective used by the run." })),
-    acceptance_criteria: Type.Optional(Type.String({ description: "Immutable acceptance criteria used by the run." })),
-    ledger_path: Type.Optional(Type.String({ description: "Durable run-scoped path to goal-ledger.json with receipts, reviewer decisions, blockers, and lifecycle events." })),
-    turns_completed: Type.Optional(Type.Number({ description: "Orchestrator/review turns completed." })),
-    iterations_completed: Type.Optional(Type.Number({ description: "Orchestrator/review turns completed, retained for status summaries." })),
-    receipts: Type.Optional(Type.Array(Type.Object({
-      turn: Type.Number(),
-      stage: Type.String(),
-      artifact_path: Type.String(),
-      summary: Type.String(),
-    }), { description: "Ledger receipt summaries and orchestrator artifact paths." })),
-    remaining_work: Type.Optional(Type.String({ description: "Remaining gaps or blockers when incomplete, or none." })),
-    review_report: Type.Optional(Type.String({ description: "Compact report pointing to the latest reviewer decision artifacts used by the reducer." })),
-    review_report_path: Type.Optional(Type.String({ description: "JSON artifact path for the latest reviewer decision round." })),
-    pr_report: Type.Optional(Type.String({ description: "Pull-request report emitted only when create_pr=true, Goal reaches complete, and the final pull-request stage runs." })),
-  },
-  worktreeFromInputs: {
-    gitWorktreeDir: "git_worktree_dir",
-    baseBranch: "base_branch",
-  },
-  run: async (ctx) => {
-    const workflowCtx = withSteeringPropagationContext(ctx);
-    const workflowStartCwd = workflowCtx.cwd ?? process.cwd();
-    const createPr = workflowCtx.inputs.create_pr === true;
-    return await runGoalWorkflow(workflowCtx, { createPr, workflowStartCwd });
-  },
-});

package/dist/builtin/workflows/builtin/index.ts

@@ -1,16 +0,0 @@
-/**
- * Builtin workflows manifest.
- * Re-exported for consumers that want to enumerate or register builtins
- * programmatically.  Atomic discovers these via the `pi.builtin`
- * package metadata pointing at this directory.
- */
-
-export { default as adversarialVerification } from "./adversarial-verification.js";
-export { default as classifyAndAct } from "./classify-and-act.js";
-export { default as fanOutAndSynthesize } from "./fan-out-and-synthesize.js";
-export { default as generateAndFilter } from "./generate-and-filter.js";
-export { default as goal } from "./goal.js";
-export { default as openClaudeDesign } from "./open-claude-design.js";
-export { default as loopUntilDone } from "./loop-until-done.js";
-export { default as ralph } from "./ralph.js";
-export { default as tournament } from "./tournament.js";

package/dist/builtin/workflows/builtin/loop-until-done-prompts.ts

@@ -1,87 +0,0 @@
-type PromptSection = readonly [tag: string, content: string];
-
-const GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
-const READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
-
-function taggedPrompt(sections: readonly PromptSection[]): string {
-  return sections
-    .map(([tag, content]) => `<${tag}>\n${content.trim()}\n</${tag}>`)
-    .join("\n\n");
-}
-
-export function renderIterationPrompt(options: {
-  readonly task: string;
-  readonly iteration: number;
-  readonly maxIterations: number;
-  readonly ledgerPath: string;
-}): string {
-  return taggedPrompt([
-    ["progress_ledger", `Read ${options.ledgerPath} first. It is the durable source of truth for attempted work, findings, failures, validation evidence, and remaining work.`],
-    ["role", "You are the active worker in a bounded evidence-driven completion loop."],
-    ["iteration", `${options.iteration} of ${options.maxIterations}`],
-    ["success_criteria", "This iteration makes measurable progress or supplies decisive evidence that the explicit objective is complete."],
-    ["requirements", [
-      "Select the highest-value unfinished item supported by the ledger and current state.",
-      "Perform concrete work; do not merely restate the objective or ledger.",
-      "Avoid repeating failed approaches unless new evidence justifies the retry.",
-      "Run the strongest practical validation for the work completed in this iteration.",
-      "Report exactly what changed, evidence gathered, failures encountered, and what remains.",
-      GROUNDED_REPORTING,
-    ].join("\n")],
-    ["stop_rules", "End this iteration after delivering measurable progress, or after evidence shows the objective is complete."],
-    ["output_format", `Markdown with Work performed, Changes, Validation evidence, New findings, Failures, and Remaining work. ${READABLE_REPORT}`],
-    ["objective", options.task],
-  ]);
-}
-
-export function renderEvaluationPrompt(options: {
-  readonly task: string;
-  readonly iteration: number;
-  readonly ledgerPath: string;
-  readonly iterationPath: string;
-}): string {
-  return taggedPrompt([
-    ["artifacts", [
-      `Durable progress ledger: ${options.ledgerPath}`,
-      `Current iteration artifact: ${options.iterationPath}`,
-      "Read both files before deciding.",
-    ].join("\n")],
-    ["role", "You are an independent completion evaluator. Judge evidence, not the worker's confidence."],
-    ["stop_condition", [
-      "Set done=true only when the objective is fully satisfied and current validation evidence proves it.",
-      "Set done=false when any required behavior, validation, cleanup, or evidence remains missing or uncertain.",
-      "Do not invent requirements beyond the objective.",
-    ].join("\n")],
-    ["evidence_rules", [
-      "List concrete validation evidence supporting the decision, including commands and observed output; cite file:line where applicable.",
-      "Record new findings and failures distinctly.",
-      "When incomplete, state actionable remaining work for the next iteration.",
-      GROUNDED_REPORTING,
-    ].join("\n")],
-    ["success_criteria", `The iteration ${options.iteration} decision is reproducible from cited artifact evidence.`],
-    ["output_format", `Return only the required structured decision with done, summary, new_findings, failures, validation_evidence, and remaining_work. ${READABLE_REPORT}`],
-    ["objective", options.task],
-  ]);
-}
-
-export function renderCompletionPrompt(options: {
-  readonly task: string;
-  readonly ledgerPath: string;
-  readonly iterationPath: string;
-}): string {
-  return taggedPrompt([
-    ["artifacts", `Read the complete ledger at ${options.ledgerPath} and final iteration artifact at ${options.iterationPath}.`],
-    ["role", "You are the final completion reporter."],
-    ["requirements", [
-      "Summarize the delivered outcome without adding unsupported claims.",
-      "Cite the validation evidence that satisfied the stop condition.",
-      "List artifact paths needed to audit the work.",
-      "Report residual risks even when no work remains.",
-      GROUNDED_REPORTING,
-    ].join("\n")],
-    ["success_criteria", "The final report is evidence-backed and independently auditable from the ledger."],
-    ["stop_rules", "Stop after accounting for the outcome, supporting evidence, audit artifacts, residual risks, and any remaining work."],
-    ["output_format", `Markdown with Outcome, Evidence, Artifacts, Residual risks, and Remaining work (None). ${READABLE_REPORT}`],
-    ["objective", options.task],
-  ]);
-}

package/dist/builtin/workflows/builtin/loop-until-done-runner.ts

@@ -1,282 +0,0 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { Type } from "typebox";
-import type {
-  WorkflowRunContext,
-  WorkflowSerializableObject,
-  WorkflowSerializableValue,
-  WorkflowTaskResult,
-} from "../src/shared/types.js";
-import { classify_trend, score_progress, type Trend } from "./progress-scoring.js";
-import {
-  renderCompletionPrompt,
-  renderEvaluationPrompt,
-  renderIterationPrompt,
-} from "./loop-until-done-prompts.js";
-import { stableArtifactRoot } from "./pattern-artifact-root.js";
-
-const PROGRESS_DISCLAIMER = "Progress scores are a monitoring signal; VOC separation +0.079; never authoritative.";
-
-const evaluationSchema = Type.Object({
-  done: Type.Boolean(),
-  summary: Type.String(),
-  new_findings: Type.Array(Type.String()),
-  failures: Type.Array(Type.String()),
-  validation_evidence: Type.Array(Type.String()),
-  remaining_work: Type.String(),
-}, { additionalProperties: false });
-
-type LoopInputs = {
-  readonly prompt: string;
-  readonly max_iterations: number;
-  readonly progress_scoring?: boolean;
-  readonly progress_repeats?: number;
-} & Record<string, WorkflowSerializableValue>;
-
-type Evaluation = {
-  readonly done: boolean;
-  readonly summary: string;
-  readonly newFindings: readonly string[];
-  readonly failures: readonly string[];
-  readonly validationEvidence: readonly string[];
-  readonly remainingWork: string;
-};
-type LedgerProgress = {
-  readonly score: number;
-  readonly perRepeat: (number | null)[][];
-  readonly trend: Trend;
-  readonly window: number;
-};
-type LedgerEntry = {
-  readonly iteration: number;
-  readonly artifact_path: string;
-  readonly evaluation_artifact_path: string;
-  readonly summary: string;
-  readonly findings: readonly string[];
-  readonly failures: readonly string[];
-  readonly validation_evidence: readonly string[];
-  readonly done: boolean;
-  readonly remaining_work: string;
-  readonly progress?: LedgerProgress;
-};
-
-function progressCurve(entries: readonly LedgerEntry[]): number[] {
-  return entries.flatMap((entry) => (entry.progress === undefined ? [] : [entry.progress.score]));
-}
-
-function progressReport(entries: readonly LedgerEntry[]): { curve: number[]; trend: Trend } {
-  const curve = progressCurve(entries);
-  return { curve, trend: classify_trend(curve).trend };
-}
-
-function formatProgressReport(report: { curve: readonly number[]; trend: Trend }): string {
-  return [
-    `Progress curve: ${JSON.stringify(report.curve)}`,
-    `Final trend: ${report.trend}`,
-    PROGRESS_DISCLAIMER,
-  ].join("\n");
-}
-
-function repeatCount(input: LoopInputs): number {
-  const repeats = input.progress_repeats;
-  return typeof repeats === "number" && Number.isInteger(repeats) && repeats > 0 ? repeats : 1;
-}
-
-async function scoreIteration(
-  ctx: WorkflowRunContext<LoopInputs>,
-  task: string,
-  entries: readonly LedgerEntry[],
-  repeats: number,
-): Promise<LedgerProgress | undefined> {
-  try {
-    const curve = await score_progress(ctx, {
-      problem: task,
-      steps: entries.map((entry) => entry.summary),
-      checkpoints: [entries.length],
-      repeats,
-    });
-    const score = curve.scores[0];
-    if (score === null || score === undefined) return undefined;
-    const trend = classify_trend([...progressCurve(entries), score]);
-    return {
-      score,
-      perRepeat: curve.perRepeat,
-      trend: trend.trend,
-      window: trend.evidence.window,
-    };
-  } catch {
-    return undefined;
-  }
-}
-function serializableObject(
-  value: WorkflowSerializableValue | undefined,
-): WorkflowSerializableObject | undefined {
-  if (value === null || Array.isArray(value) || typeof value !== "object") return undefined;
-  return value as WorkflowSerializableObject;
-}
-
-function stringArray(value: WorkflowSerializableValue | undefined): readonly string[] | undefined {
-  return Array.isArray(value) && value.every((item) => typeof item === "string")
-    ? value
-    : undefined;
-}
-
-function evaluationFrom(result: WorkflowTaskResult): Evaluation {
-  const value = serializableObject(result.structured);
-  if (value === undefined) {
-    throw new Error(`loop-until-done: evaluator ${result.stageName} did not return a structured decision`);
-  }
-  const done = value.done;
-  const summary = value.summary;
-  const newFindings = stringArray(value.new_findings);
-  const failures = stringArray(value.failures);
-  const validationEvidence = stringArray(value.validation_evidence);
-  const remainingWork = value.remaining_work;
-  if (typeof done !== "boolean" || typeof summary !== "string" ||
-      newFindings === undefined || failures === undefined || validationEvidence === undefined ||
-      typeof remainingWork !== "string") {
-    throw new Error(`loop-until-done: evaluator ${result.stageName} returned an invalid decision`);
-  }
-  return { done, summary, newFindings, failures, validationEvidence, remainingWork };
-}
-
-async function writeLedger(
-  path: string,
-  task: string,
-  maxIterations: number,
-  status: string,
-  entries: readonly LedgerEntry[],
-): Promise<void> {
-  const report = progressReport(entries);
-  await writeFile(path, `${JSON.stringify({
-    task,
-    max_iterations: maxIterations,
-    status,
-    iterations_completed: entries.length,
-    entries,
-    progress_curve: report.curve,
-    final_trend: report.trend,
-    progress_disclaimer: PROGRESS_DISCLAIMER,
-  }, null, 2)}\n`);
-}
-
-export async function runLoopUntilDone(ctx: WorkflowRunContext<LoopInputs>) {
-  const artifactDir = await stableArtifactRoot(ctx, "loop-until-done");
-  const iterationsDir = join(artifactDir, "iterations");
-  const evaluationsDir = join(artifactDir, "evaluations");
-  await mkdir(iterationsDir, { recursive: true });
-  await mkdir(evaluationsDir, { recursive: true });
-  const ledgerPath = join(artifactDir, "progress-ledger.json");
-  const entries: LedgerEntry[] = [];
-  const iterationArtifactPaths: string[] = [];
-  const evaluationArtifactPaths: string[] = [];
-  await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "active", entries);
-
-  for (let iteration = 1; iteration <= ctx.inputs.max_iterations; iteration += 1) {
-    const iterationPath = join(iterationsDir, `iteration-${iteration}.md`);
-    const evaluationPath = join(evaluationsDir, `evaluation-${iteration}.json`);
-    iterationArtifactPaths.push(iterationPath);
-    evaluationArtifactPaths.push(evaluationPath);
-    await ctx.task(`iteration-${iteration}`, {
-      prompt: renderIterationPrompt({
-        task: ctx.inputs.prompt,
-        iteration,
-        maxIterations: ctx.inputs.max_iterations,
-        ledgerPath,
-      }),
-      context: "fresh",
-      reads: [ledgerPath, ...(iteration > 1 ? [iterationArtifactPaths[iteration - 2]!] : [])],
-      output: iterationPath,
-      outputMode: "file-only",
-    });
-    const evaluator = await ctx.task(`evaluate-${iteration}`, {
-      prompt: renderEvaluationPrompt({
-        task: ctx.inputs.prompt,
-        iteration,
-        ledgerPath,
-        iterationPath,
-      }),
-      context: "fresh",
-      reads: [ledgerPath, iterationPath],
-      schema: evaluationSchema,
-    });
-    const decision = evaluationFrom(evaluator);
-    // Evaluation reports are declared workflow outputs consumed as data: the
-    // runner persists the structured decision itself so evaluation-N.json
-    // stays schema-shaped JSON rather than stage prose.
-    await writeFile(evaluationPath, `${JSON.stringify(evaluator.structured, null, 2)}\n`);
-    const entry: LedgerEntry = {
-      iteration,
-      artifact_path: iterationPath,
-      evaluation_artifact_path: evaluationPath,
-      summary: decision.summary,
-      findings: decision.newFindings,
-      failures: decision.failures,
-      validation_evidence: decision.validationEvidence,
-      done: decision.done,
-      remaining_work: decision.remainingWork,
-    };
-    entries.push(entry);
-    if (ctx.inputs.progress_scoring !== false) {
-      const progress = await scoreIteration(ctx, ctx.inputs.prompt, entries, repeatCount(ctx.inputs));
-      if (progress !== undefined) entries[entries.length - 1] = { ...entry, progress };
-    }
-    await writeLedger(
-      ledgerPath,
-      ctx.inputs.prompt,
-      ctx.inputs.max_iterations,
-      decision.done ? "complete" : "active",
-      entries,
-    );
-    if (decision.done) {
-      const report = progressReport(entries);
-      const resultPath = join(artifactDir, "result.md");
-      const final = await ctx.task("completion-summary", {
-        prompt: renderCompletionPrompt({ task: ctx.inputs.prompt, ledgerPath, iterationPath }),
-        context: "fresh",
-        reads: [ledgerPath, iterationPath],
-        output: resultPath,
-        // Keep the completion report out of the caller's context window;
-        // `result_path` below carries it for callers that want the contents.
-        outputMode: "file-only",
-      });
-      const result = `${final.text ? `${final.text.trimEnd()}\n\n` : ""}${formatProgressReport(report)}\n`;
-      return {
-        result,
-        status: "complete" as const,
-        iterations_completed: iteration,
-        ledger_path: ledgerPath,
-        iteration_artifact_paths: iterationArtifactPaths,
-        evaluation_artifact_paths: evaluationArtifactPaths,
-        result_path: resultPath,
-        remaining_work: "",
-        artifact_dir: artifactDir,
-        progress_curve: report.curve,
-        final_trend: report.trend,
-        progress_disclaimer: PROGRESS_DISCLAIMER,
-      };
-    }
-  }
-
-  const last = entries.at(-1)!;
-  const report = progressReport(entries);
-  await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "failed", entries);
-  const result = [
-    `Iteration limit exhausted after ${ctx.inputs.max_iterations} iterations. Inspect ${ledgerPath}.`,
-    formatProgressReport(report),
-  ].join("\n\n");
-  return {
-    result,
-    status: "failed" as const,
-    iterations_completed: ctx.inputs.max_iterations,
-    ledger_path: ledgerPath,
-    iteration_artifact_paths: iterationArtifactPaths,
-    evaluation_artifact_paths: evaluationArtifactPaths,
-    result_path: ledgerPath,
-    remaining_work: last.remaining_work,
-    artifact_dir: artifactDir,
-    progress_curve: report.curve,
-    final_trend: report.trend,
-    progress_disclaimer: PROGRESS_DISCLAIMER,
-  };
-}

package/dist/builtin/workflows/builtin/loop-until-done.ts

@@ -1,51 +0,0 @@
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.js";
-import { runLoopUntilDone } from "./loop-until-done-runner.js";
-
-export default workflow({
-  name: "loop-until-done",
-  description: "Repeat evidence-producing work and independent completion evaluation against a durable ledger until done or an inspectable iteration-limit failure.",
-  // The 15-minute default, stated rather than inherited: this is a per-workflow
-  // product decision, so a future change to the global default must not silently
-  // re-cadence a long autonomous run.
-  heartbeatIntervalMinutes: 15,
-  inputs: {
-    prompt: Type.String({ description: "Objective whose explicit completion condition controls the bounded loop." }),
-    max_iterations: Type.Integer({
-      minimum: 1,
-      maximum: 20,
-      default: 5,
-      description: "Maximum work/evaluation iterations before returning an inspectable failed status (1-20).",
-    }),
-    progress_scoring: Type.Boolean({
-      default: true,
-      description: "Enable advisory progress scoring after each completed iteration.",
-    }),
-    progress_repeats: Type.Integer({
-      minimum: 1,
-      default: 1,
-      description: "Number of advisory progress-scoring repeats per iteration.",
-    }),
-  },
-  outputs: {
-    result: Type.String({ description: "Compact reference to the evidence-backed completion report, or the deterministic exhaustion report; read `result_path` for the full report." }),
-    status: Type.Union([Type.Literal("complete"), Type.Literal("failed")], {
-      description: "Complete when evidence satisfies the stop condition; failed when max_iterations is exhausted.",
-    }),
-    iterations_completed: Type.Integer({ description: "Number of completed work/evaluation iterations." }),
-    ledger_path: Type.String({ description: "Path to the durable JSON progress ledger." }),
-    iteration_artifact_paths: Type.Array(Type.String(), { description: "Ordered paths to per-iteration work artifacts." }),
-    evaluation_artifact_paths: Type.Array(Type.String(), { description: "Ordered paths to structured evaluation artifacts." }),
-    result_path: Type.String({ description: "Path to the final report, or the ledger on exhausted failure." }),
-    remaining_work: Type.String({ description: "Actionable remaining work; empty only after proven completion." }),
-    artifact_dir: Type.String({ description: "Run-specific directory containing loop artifacts." }),
-    progress_curve: Type.Array(Type.Number(), { description: "Advisory progress scores in iteration order." }),
-    final_trend: Type.Union(
-      [Type.Literal("rising"), Type.Literal("flat"), Type.Literal("regressing")],
-      { description: "Final advisory trend classification; never a stop decision." },
-    ),
-    progress_disclaimer: Type.String({ description: "Calibration disclaimer for the advisory progress signal." }),
-  },
-  run: async (ctx) => await runLoopUntilDone(withSteeringPropagationContext(ctx)),
-});