@bastani/atomic 0.9.9 → 0.9.10-alpha.1

package/dist/builtin/workflows/builtin/generate-and-filter.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../src/authoring.js";
+export type GenerateAndFilterInputs = WorkflowInputValues & { readonly prompt: string; readonly num_candidates: number; readonly shortlist_size: number; readonly use_judge: boolean; readonly max_concurrency: number };
+export type GenerateAndFilterRunInputs = WorkflowInputValues & { readonly prompt: string; readonly num_candidates?: number; readonly shortlist_size?: number; readonly use_judge?: boolean; readonly max_concurrency?: number };
+export type GenerateAndFilterOutputs = WorkflowOutputValues & {
+  readonly result: string; readonly shortlist: string[]; readonly candidate_artifact_paths: string[];
+  readonly filter_path: string; readonly judge_path: string | null; readonly final_path: string;
+  readonly artifact_dir: string; readonly manifest_path: string;
+};
+export type GenerateAndFilterDefinition = WorkflowDefinition<GenerateAndFilterInputs, GenerateAndFilterOutputs, GenerateAndFilterRunInputs>;
+declare const workflow: GenerateAndFilterDefinition;
+export default workflow;

package/dist/builtin/workflows/builtin/generate-and-filter.ts

@@ -0,0 +1,26 @@
+import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
+import { runGenerateAndFilter } from "./generate-and-filter-runner.js";
+
+export default workflow({
+  name: "generate-and-filter",
+  description: "Generate more independent candidates than needed, deduplicate and filter them by rubric, optionally judge them, and return a parent-consumable shortlist.",
+  inputs: {
+    prompt: Type.String({ description: "Prompt for candidate generation and selection." }),
+    num_candidates: Type.Integer({ minimum: 2, maximum: 20, default: 8, description: "Number of independent candidates to generate." }),
+    shortlist_size: Type.Integer({ minimum: 1, maximum: 10, default: 3, description: "Maximum number of candidates in the final shortlist." }),
+    use_judge: Type.Boolean({ default: true, description: "Whether an independent judge reviews the filtered shortlist." }),
+    max_concurrency: Type.Integer({ minimum: 1, maximum: 12, default: 4, description: "Maximum simultaneous generator stages." }),
+  },
+  outputs: {
+    result: Type.String({ description: "Final human-readable shortlist report." }),
+    shortlist: Type.Array(Type.String(), { description: "Ranked paths to selected candidate artifacts." }),
+    candidate_artifact_paths: Type.Array(Type.String(), { description: "Paths to every generated candidate artifact." }),
+    filter_path: Type.String({ description: "Path to the dedupe and filter decision." }),
+    judge_path: Type.Union([Type.String(), Type.Null()], { description: "Path to the optional judge decision, or null when disabled." }),
+    final_path: Type.String({ description: "Path to the final shortlist report." }),
+    artifact_dir: Type.String({ description: "Directory containing run artifacts." }),
+    manifest_path: Type.String({ description: "Path to the candidate artifact manifest." }),
+  },
+  run: runGenerateAndFilter,
+});

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

@@ -0,0 +1,72 @@
+import { reviewDecisionSchema } from "./goal-schemas.js";
+
+// Model chains are curated from Atomic's agentic-coding benchmark; see
+// ralph-models.ts for frontier data and drop rationale.
+export const workerModelConfig = {
+    model: "openai-codex/gpt-5.6-sol:medium",
+    fallbackModels: [
+      "github-copilot/gpt-5.6-sol:medium",
+      "openai/gpt-5.6-sol:medium",
+      "openai-codex/gpt-5.5:medium",
+      "github-copilot/gpt-5.5:medium",
+      "openai/gpt-5.5:medium",
+      "anthropic/claude-fable-5:low",
+      "github-copilot/claude-opus-4.8 (1m):medium",
+      "anthropic/claude-opus-4-8:medium",
+      "cursor/gpt-5.6-sol:medium",
+      "cursor/gpt-5.5:medium",
+      "cursor/claude-fable-5:low",
+      "cursor/claude-opus-4-8-thinking:medium",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
+      "zai/glm-5.2:high",
+      "zai-coding-cn/glm-5.2:high",
+      "cursor/glm-5.2",
+      "openrouter/openai/gpt-5.6-sol:medium",
+      "openrouter/openai/gpt-5.5:medium",
+      "openrouter/anthropic/claude-fable-5:low",
+      "openrouter/anthropic/claude-opus-4-8:medium",
+      "openrouter/x-ai/grok-4.5",
+      "openrouter/z-ai/glm-5.2:xhigh"
+    ],
+    excludedTools: ["ask_user_question"],
+};
+
+// Keep this model list identical to Ralph reviewer-a while preserving an
+// independent Goal configuration and Goal's richer decision schema.
+// Reviewer-a leads its fallbacks with Kimi K3 so reviewer A and B decorrelate.
+export const reviewerModelConfig = {
+    model: "anthropic/claude-fable-5:high",
+    fallbackModels: [
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
+      "openai-codex/gpt-5.6-sol:xhigh",
+      "github-copilot/gpt-5.6-sol:xhigh",
+      "openai/gpt-5.6-sol:xhigh",
+      "openai-codex/gpt-5.5:xhigh",
+      "github-copilot/gpt-5.5:xhigh",
+      "openai/gpt-5.5:xhigh",
+      "github-copilot/claude-opus-4.8 (1m):high",
+      "anthropic/claude-opus-4-8:high",
+      "cursor/claude-fable-5:high",
+      "cursor/gpt-5.6-sol:xhigh",
+      "cursor/gpt-5.5:high",
+      "cursor/claude-opus-4-8-thinking:high",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
+      "zai/glm-5.2:xhigh",
+      "zai-coding-cn/glm-5.2:xhigh",
+      "cursor/glm-5.2",
+      "openrouter/anthropic/claude-fable-5:high",
+      "openrouter/moonshotai/kimi-k3:max",
+      "openrouter/openai/gpt-5.6-sol:xhigh",
+      "openrouter/sakana/fugu-ultra:high",
+      "openrouter/openai/gpt-5.5:xhigh",
+      "openrouter/anthropic/claude-opus-4-8:high",
+      "openrouter/x-ai/grok-4.5",
+      "openrouter/z-ai/glm-5.2:xhigh"
+    ],
+    excludedTools: ["ask_user_question"],
+    schema: reviewDecisionSchema,
+};

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

@@ -1,6 +1,6 @@
 import { join } from "node:path";
 import type { WorkflowParallelOptions, WorkflowTaskOptions, WorkflowTaskResult, WorkflowTaskStep } from "../src/shared/types.js";
-import { reviewDecisionSchema } from "./goal-schemas.js";
+import { reviewerModelConfig, workerModelConfig } from "./goal-models.js";
 import {
   DEFAULT_BLOCKER_THRESHOLD,
   DEFAULT_MAX_TURNS,
@@ -114,69 +114,6 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
     const comparisonBaseBranch = normalizeBranchInput(inputs.base_branch, "origin/main");
     const { ledger, ledgerPath, artifactDir } = await createGoalLedger(objective, acceptanceCriteria);
 
-    // Chains curated from Atomic's agentic-coding benchmark; see ralph-models.ts for frontier data and drop rationale.
-    const workerModelConfig = {
-      model: "openai-codex/gpt-5.6-sol:medium",
-      fallbackModels: [
-        "github-copilot/gpt-5.6-sol:medium",
-        "openai/gpt-5.6-sol:medium",
-        "openai-codex/gpt-5.5:medium",
-        "github-copilot/gpt-5.5:medium",
-        "openai/gpt-5.5:medium",
-        "anthropic/claude-fable-5:low",
-        "github-copilot/claude-opus-4.8 (1m):medium",
-        "anthropic/claude-opus-4-8:medium",
-        "cursor/gpt-5.6-sol:medium",
-        "cursor/gpt-5.5:medium",
-        "cursor/claude-fable-5:low",
-        "cursor/claude-opus-4-8-thinking:medium",
-        "cursor/grok-4.5",
-        "zai/glm-5.2:high",
-        "zai-coding-cn/glm-5.2:high",
-        "cursor/glm-5.2",
-        "openrouter/openai/gpt-5.6-sol:medium",
-        "openrouter/openai/gpt-5.5:medium",
-        "openrouter/anthropic/claude-fable-5:low",
-        "openrouter/anthropic/claude-opus-4-8:medium",
-        "openrouter/x-ai/grok-4.5",
-        "openrouter/z-ai/glm-5.2:xhigh"
-      ],
-      excludedTools: ["ask_user_question"],
-    };
-
-    // Keep this model list identical to Ralph reviewer-a while preserving an
-    // independent Goal configuration and Goal's richer decision schema.
-    const reviewerModelConfig = {
-      model: "anthropic/claude-fable-5:high",
-      fallbackModels: [
-        "openai-codex/gpt-5.6-sol:xhigh",
-        "github-copilot/gpt-5.6-sol:xhigh",
-        "openai/gpt-5.6-sol:xhigh",
-        "openai-codex/gpt-5.5:xhigh",
-        "github-copilot/gpt-5.5:xhigh",
-        "openai/gpt-5.5:xhigh",
-        "github-copilot/claude-opus-4.8 (1m):high",
-        "anthropic/claude-opus-4-8:high",
-        "cursor/claude-fable-5:high",
-        "cursor/gpt-5.6-sol:xhigh",
-        "cursor/gpt-5.5:high",
-        "cursor/claude-opus-4-8-thinking:high",
-        "cursor/grok-4.5",
-        "zai/glm-5.2:xhigh",
-        "zai-coding-cn/glm-5.2:xhigh",
-        "cursor/glm-5.2",
-        "openrouter/anthropic/claude-fable-5:high",
-        "openrouter/openai/gpt-5.6-sol:xhigh",
-        "openrouter/sakana/fugu-ultra:high",
-        "openrouter/openai/gpt-5.5:xhigh",
-        "openrouter/anthropic/claude-opus-4-8:high",
-        "openrouter/x-ai/grok-4.5",
-        "openrouter/z-ai/glm-5.2:xhigh"
-      ],
-      excludedTools: ["ask_user_question"],
-      schema: reviewDecisionSchema,
-    };
-
     let latestReviews: ReviewRecord[] = [];
     let latestReviewArtifactPaths: string[] = [];
     let latestReviewReportPath: string | undefined;
@@ -304,6 +241,7 @@ export async function runGoalWorkflow(ctx: GoalRunnerContext, options: GoalWorkf
         reviewResults = await ctx.parallel(reviewerSteps, {
           task: objective,
           failFast: true,
+          group: `goal-reviewers-turn-${turn}`,
         });
       } catch (err) {
         reviewerBatchFailed = true;

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

@@ -142,6 +142,50 @@ export type OpenClaudeDesignWorkflowDefinition = WorkflowDefinition<
   OpenClaudeDesignWorkflowRunInputs
 >;
 
+export {
+  default as adversarialVerification,
+  type AdversarialVerificationDefinition,
+  type AdversarialVerificationInputs,
+  type AdversarialVerificationOutputs,
+  type AdversarialVerificationRunInputs,
+} from "./adversarial-verification.js";
+export {
+  default as classifyAndAct,
+  type ClassifyAndActWorkflowDefinition,
+  type ClassifyAndActWorkflowInputs,
+  type ClassifyAndActWorkflowOutputs,
+  type ClassifyAndActWorkflowRunInputs,
+} from "./classify-and-act.js";
+export {
+  default as fanOutAndSynthesize,
+  type FanOutAndSynthesizeWorkflowDefinition,
+  type FanOutAndSynthesizeWorkflowInputs,
+  type FanOutAndSynthesizeWorkflowOutputs,
+  type FanOutAndSynthesizeWorkflowRunInputs,
+} from "./fan-out-and-synthesize.js";
+export {
+  default as generateAndFilter,
+  type GenerateAndFilterDefinition,
+  type GenerateAndFilterInputs,
+  type GenerateAndFilterOutputs,
+  type GenerateAndFilterRunInputs,
+} from "./generate-and-filter.js";
+export {
+  default as loopUntilDone,
+  type LoopUntilDoneWorkflowDefinition,
+  type LoopUntilDoneWorkflowInputs,
+  type LoopUntilDoneWorkflowOutputs,
+  type LoopUntilDoneWorkflowRunInputs,
+  type LoopUntilDoneWorkflowStatus,
+} from "./loop-until-done.js";
+export {
+  default as tournament,
+  type TournamentWorkflowDefinition,
+  type TournamentWorkflowInputs,
+  type TournamentWorkflowOutputs,
+  type TournamentWorkflowRunInputs,
+} from "./tournament.js";
+
 export declare const deepResearchCodebase: DeepResearchCodebaseWorkflowDefinition;
 export declare const goal: GoalWorkflowDefinition;
 export declare const ralph: RalphWorkflowDefinition;

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

@@ -5,7 +5,13 @@
  * 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 deepResearchCodebase } from "./deep-research-codebase.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 ralph } from "./ralph.js";
 export { default as openClaudeDesign } from "./open-claude-design.js";
+export { default as loopUntilDone } from "./loop-until-done.js";
+export { default as tournament } from "./tournament.js";

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

@@ -0,0 +1,79 @@
+type PromptSection = readonly [tag: string, content: string];
+
+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([
+    ["role", "You are the active worker in a bounded evidence-driven completion loop."],
+    ["objective", options.task],
+    ["iteration", `${options.iteration} of ${options.maxIterations}`],
+    ["progress_ledger", `Read ${options.ledgerPath} first. It is the durable source of truth for attempted work, findings, failures, validation evidence, and remaining work.`],
+    ["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.",
+    ].join("\n")],
+    ["success_criteria", "This iteration makes measurable progress or supplies decisive evidence that the explicit objective is complete."],
+    ["output_format", "Markdown with Work performed, Changes, Validation evidence, New findings, Failures, and Remaining work."],
+  ]);
+}
+
+export function renderEvaluationPrompt(options: {
+  readonly task: string;
+  readonly iteration: number;
+  readonly ledgerPath: string;
+  readonly iterationPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are an independent completion evaluator. Judge evidence, not the worker's confidence."],
+    ["objective", options.task],
+    ["artifacts", [
+      `Durable progress ledger: ${options.ledgerPath}`,
+      `Current iteration artifact: ${options.iterationPath}`,
+      "Read both files before deciding.",
+    ].join("\n")],
+    ["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.",
+      "Record new findings and failures distinctly.",
+      "When incomplete, state actionable remaining work for the next iteration.",
+      "Return the required structured decision.",
+    ].join("\n")],
+    ["success_criteria", `The iteration ${options.iteration} decision is reproducible from cited artifact evidence.`],
+  ]);
+}
+
+export function renderCompletionPrompt(options: {
+  readonly task: string;
+  readonly ledgerPath: string;
+  readonly iterationPath: string;
+}): string {
+  return taggedPrompt([
+    ["role", "You are the final completion reporter."],
+    ["objective", options.task],
+    ["artifacts", `Read the complete ledger at ${options.ledgerPath} and final iteration artifact at ${options.iterationPath}.`],
+    ["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.",
+    ].join("\n")],
+    ["success_criteria", "The final report is concise, evidence-backed, and independently auditable from the ledger."],
+    ["output_format", "Markdown with Outcome, Evidence, Artifacts, Residual risks, and Remaining work (None)."],
+  ]);
+}

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

@@ -0,0 +1,189 @@
+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 {
+  renderCompletionPrompt,
+  renderEvaluationPrompt,
+  renderIterationPrompt,
+} from "./loop-until-done-prompts.js";
+import { stableArtifactRoot } from "./pattern-artifact-root.js";
+
+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;
+} & 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 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;
+};
+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> {
+  await writeFile(path, `${JSON.stringify({
+    task,
+    max_iterations: maxIterations,
+    status,
+    iterations_completed: entries.length,
+    entries,
+  }, 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,
+      output: evaluationPath,
+      outputMode: "file-only",
+    });
+    const decision = evaluationFrom(evaluator);
+    entries.push({
+      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,
+    });
+    await writeLedger(
+      ledgerPath,
+      ctx.inputs.prompt,
+      ctx.inputs.max_iterations,
+      decision.done ? "complete" : "active",
+      entries,
+    );
+    if (decision.done) {
+      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,
+      });
+      return {
+        result: final.text,
+        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,
+      };
+    }
+  }
+
+  const last = entries.at(-1)!;
+  await writeLedger(ledgerPath, ctx.inputs.prompt, ctx.inputs.max_iterations, "failed", entries);
+  return {
+    result: `Iteration limit exhausted after ${ctx.inputs.max_iterations} iterations. Inspect ${ledgerPath}.`,
+    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,
+  };
+}

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

@@ -0,0 +1,34 @@
+import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../src/authoring.js";
+
+export type LoopUntilDoneWorkflowStatus = "complete" | "failed";
+
+export type LoopUntilDoneWorkflowInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly max_iterations: number;
+};
+
+export type LoopUntilDoneWorkflowRunInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly max_iterations?: number;
+};
+
+export type LoopUntilDoneWorkflowOutputs = WorkflowOutputValues & {
+  readonly result: string;
+  readonly status: LoopUntilDoneWorkflowStatus;
+  readonly iterations_completed: number;
+  readonly ledger_path: string;
+  readonly iteration_artifact_paths: string[];
+  readonly evaluation_artifact_paths: string[];
+  readonly result_path: string;
+  readonly remaining_work: string;
+  readonly artifact_dir: string;
+};
+
+export type LoopUntilDoneWorkflowDefinition = WorkflowDefinition<
+  LoopUntilDoneWorkflowInputs,
+  LoopUntilDoneWorkflowOutputs,
+  LoopUntilDoneWorkflowRunInputs
+>;
+
+declare const workflow: LoopUntilDoneWorkflowDefinition;
+export default workflow;

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

@@ -0,0 +1,31 @@
+import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.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.",
+  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).",
+    }),
+  },
+  outputs: {
+    result: Type.String({ description: "Evidence-backed completion report or deterministic exhaustion 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." }),
+  },
+  run: async (ctx) => await runLoopUntilDone(ctx),
+});

package/dist/builtin/workflows/builtin/open-claude-design-runner.ts

@@ -84,16 +84,21 @@ export async function runOpenClaudeDesignWorkflow(ctx: OpenClaudeDesignContext):
       "anthropic/claude-opus-4-8:high",
       "cursor/claude-fable-5:high",
       "cursor/claude-opus-4-8-thinking:high",
+      "kimi-coding/k3:max",
+      "moonshotai/kimi-k3:max",
+      "moonshotai-cn/kimi-k3:max",
       "openai-codex/gpt-5.6-sol:xhigh",
       "github-copilot/gpt-5.6-sol:xhigh",
       "openai/gpt-5.6-sol:xhigh",
       "cursor/gpt-5.6-sol:xhigh",
-      "cursor/grok-4.5",
+      "xai/grok-4.5:high",
+      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
       "cursor/glm-5.2",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/anthropic/claude-opus-4-8:high",
+      "openrouter/moonshotai/kimi-k3:max",
       "openrouter/openai/gpt-5.6-sol:xhigh",
       "openrouter/sakana/fugu-ultra:high",
       "openrouter/x-ai/grok-4.5",

package/dist/builtin/workflows/builtin/pattern-artifact-root.ts

@@ -0,0 +1,28 @@
+import { randomUUID } from "node:crypto";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import type { WorkflowRunContext } from "../src/shared/types.js";
+
+/**
+ * Durable per-run artifact root under `<cwd>/.atomic/workflows/runs`.
+ *
+ * The random directory name is generated exactly once through `ctx.tool`, so
+ * a durable resume replays the original path instead of computing a fresh
+ * per-process root. Replayed stages therefore keep reading artifacts written
+ * before the interruption. The `mkdir` stays outside the durable checkpoint
+ * and is idempotent, so both fresh runs and resumes converge on an existing
+ * directory.
+ */
+export async function stableArtifactRoot(
+  ctx: Pick<WorkflowRunContext, "cwd" | "tool">,
+  workflowName: string,
+): Promise<string> {
+  const cwd = ctx.cwd ?? process.cwd();
+  const artifactDir = await ctx.tool(
+    "artifact-root",
+    { workflow: workflowName },
+    async () => join(cwd, ".atomic", "workflows", "runs", `${workflowName}-${randomUUID()}`),
+  );
+  await mkdir(artifactDir, { recursive: true });
+  return artifactDir;
+}