@bastani/atomic 0.9.9 → 0.9.10

package/dist/builtin/workflows/builtin/classify-and-act.ts

@@ -0,0 +1,35 @@
+import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
+import { runClassifyAndAct } from "./classify-and-act-runner.js";
+
+export const DEFAULT_ACTION_CATEGORIES = ["analysis", "implementation", "research"] as const;
+
+export default workflow({
+  name: "classify-and-act",
+  description: "Classify a task with structured confidence, route deterministically to an isolated category action, and ask for human selection when confidence is low.",
+  inputs: {
+    prompt: Type.String({ description: "Task to classify and execute." }),
+    categories: Type.Array(Type.String({ minLength: 1 }), {
+      minItems: 1,
+      maxItems: 8,
+      default: [...DEFAULT_ACTION_CATEGORIES],
+      description: "Ordered action categories available to the classifier and fallback chooser.",
+    }),
+    confidence_threshold: Type.Number({
+      minimum: 0.5,
+      maximum: 0.99,
+      default: 0.75,
+      description: "Minimum structured confidence required to route without human selection.",
+    }),
+  },
+  outputs: {
+    result: Type.String({ description: "Category-specific action report." }),
+    category: Type.String({ description: "Selected category, including any human fallback selection." }),
+    confidence: Type.Number({ minimum: 0, maximum: 1, description: "Classifier confidence before fallback." }),
+    action: Type.String({ description: "Executed category-specific action stage name." }),
+    classification_path: Type.String({ description: "Structured classification artifact path." }),
+    action_path: Type.String({ description: "Category action report artifact path." }),
+    artifact_dir: Type.String({ description: "Per-run artifact directory." }),
+  },
+  run: async (ctx) => await runClassifyAndAct(ctx),
+});

package/dist/builtin/workflows/builtin/deep-research-codebase-utils.ts

@@ -40,6 +40,9 @@ export const PLANNER_MODEL_CONFIG = {
     "openai-codex/gpt-5.6-sol:xhigh",
     "github-copilot/gpt-5.6-sol:xhigh",
     "openai/gpt-5.6-sol:xhigh",
+    "kimi-coding/k3:max",
+    "moonshotai/kimi-k3:max",
+    "moonshotai-cn/kimi-k3:max",
     "openai-codex/gpt-5.5:xhigh",
     "github-copilot/gpt-5.5:xhigh",
     "openai/gpt-5.5:xhigh",
@@ -49,12 +52,14 @@ export const PLANNER_MODEL_CONFIG = {
     "cursor/gpt-5.6-sol:xhigh",
     "cursor/gpt-5.5:high",
     "cursor/claude-opus-4-8-thinking:high",
-    "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/openai/gpt-5.6-sol:xhigh",
+    "openrouter/moonshotai/kimi-k3:max",
     "openrouter/sakana/fugu-ultra:high",
     "openrouter/openai/gpt-5.5:xhigh",
     "openrouter/anthropic/claude-opus-4-8:high",
@@ -81,7 +86,8 @@ export const EXPLORER_MODEL_CONFIG = {
     "cursor/gpt-5.6-terra:high",
     "cursor/gpt-5.5:low",
     "cursor/claude-opus-4-8-thinking:low",
-    "cursor/grok-4.5",
+    "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",

package/dist/builtin/workflows/builtin/fan-out-and-synthesize-prompts.ts

@@ -0,0 +1,11 @@
+export function partitionPrompt(prompt: string, maxBranches: number): string {
+  return `<role>\nYou partition work into independent evidence-producing branches.\n</role>\n\n<objective>\nPartition this task: ${prompt}\n</objective>\n\n<requirements>\nReturn between 1 and ${maxBranches} non-overlapping partitions. Split by files, sources, claims, candidates, or work items that can be evaluated independently. Give each partition a concise label and a self-contained objective. Avoid duplicate scope and identify boundaries explicitly. Return only the structured result requested by the schema.\n</requirements>`;
+}
+
+export function branchPrompt(input: { readonly prompt: string; readonly label: string; readonly objective: string }): string {
+  return `<role>\nYou own one independent branch of a larger task.\n</role>\n\n<overall_task>\n${input.prompt}\n</overall_task>\n\n<branch>\n${input.label}: ${input.objective}\n</branch>\n\n<success_criteria>\nInvestigate only this branch, cite concrete files/sources/commands or other observable evidence, distinguish findings from uncertainty, and produce a standalone artifact that a synthesizer can audit.\n</success_criteria>\n\n<output_format>\nMarkdown with Scope, Findings, Evidence, Conflicts or uncertainty, and Recommendations headings.\n</output_format>`;
+}
+
+export function synthesisPrompt(prompt: string, manifestPath: string): string {
+  return `<role>\nYou synthesize independent branch artifacts at a strict barrier.\n</role>\n\n<objective>\nProduce the final answer for: ${prompt}\n</objective>\n\n<artifact_contract>\nRead ${manifestPath} first, then read every branch artifact listed there. Do not omit a completed branch and do not assume access to branch conversations.\n</artifact_contract>\n\n<success_criteria>\nDeduplicate overlapping findings, explicitly resolve or preserve conflicting claims, retain material uncertainty, and cite branch labels and artifact paths for important conclusions. The answer must be traceable to evidence rather than majority vote.\n</success_criteria>\n\n<output_format>\nMarkdown with Executive synthesis, Consolidated findings, Conflicts and resolutions, Evidence index, and Remaining uncertainty headings.\n</output_format>`;
+}

package/dist/builtin/workflows/builtin/fan-out-and-synthesize-runner.ts

@@ -0,0 +1,96 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+import type { WorkflowRunContext, WorkflowSerializableValue, WorkflowTaskStep } from "../src/shared/types.js";
+import { branchPrompt, partitionPrompt, synthesisPrompt } from "./fan-out-and-synthesize-prompts.js";
+import { stableArtifactRoot } from "./pattern-artifact-root.js";
+
+const partitionSchema = Type.Object({
+  partitions: Type.Array(Type.Object({
+    label: Type.String({ minLength: 1 }),
+    objective: Type.String({ minLength: 1 }),
+  }, { additionalProperties: false }), { minItems: 1, maxItems: 12 }),
+}, { additionalProperties: false });
+
+type Inputs = {
+  readonly prompt: string;
+  readonly max_branches: number;
+  readonly max_concurrency: number;
+} & Record<string, WorkflowSerializableValue>;
+type Partition = { readonly label: string; readonly objective: string };
+export type FanOutAndSynthesizeResult = {
+  readonly result: string;
+  readonly partitions: string[];
+  readonly branch_artifact_paths: string[];
+  readonly synthesis_path: string;
+  readonly artifact_dir: string;
+  readonly manifest_path: string;
+};
+
+function safeName(value: string, index: number): string {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `${String(index + 1).padStart(2, "0")}-${normalized || "branch"}`;
+}
+async function artifactText(path: string, fallback: string): Promise<string> {
+  try { return await readFile(path, "utf8"); } catch { return fallback; }
+}
+function parsedPartitions(value: WorkflowSerializableValue | undefined, limit: number, prompt: string): Partition[] {
+  if (typeof value !== "object" || value === null || !("partitions" in value) || !Array.isArray(value.partitions)) {
+    return [{ label: "whole-task", objective: prompt }];
+  }
+  const result: Partition[] = [];
+  for (const candidate of value.partitions) {
+    if (typeof candidate !== "object" || candidate === null || !("label" in candidate) || !("objective" in candidate)) continue;
+    const label = String(candidate.label).trim();
+    const objective = String(candidate.objective).trim();
+    if (label !== "" && objective !== "") result.push({ label, objective });
+    if (result.length >= limit) break;
+  }
+  return result.length > 0 ? result : [{ label: "whole-task", objective: prompt }];
+}
+
+export async function runFanOutAndSynthesize(ctx: WorkflowRunContext<Inputs>): Promise<FanOutAndSynthesizeResult> {
+  const artifactDir = await stableArtifactRoot(ctx, "fan-out-and-synthesize");
+  const plan = await ctx.task("partition", {
+    prompt: partitionPrompt(ctx.inputs.prompt, ctx.inputs.max_branches),
+    schema: partitionSchema,
+    context: "fresh",
+  });
+  const partitions = parsedPartitions(plan.structured, ctx.inputs.max_branches, ctx.inputs.prompt);
+  const partitionPath = join(artifactDir, "partition-plan.json");
+  await writeFile(partitionPath, JSON.stringify({ task: ctx.inputs.prompt, partitions }, null, 2));
+
+  const branchPaths = partitions.map((partition, index) => join(artifactDir, `branch-${safeName(partition.label, index)}.md`));
+  const steps: WorkflowTaskStep[] = partitions.map((partition, index) => ({
+    name: `branch-${safeName(partition.label, index)}`,
+    prompt: branchPrompt({ prompt: ctx.inputs.prompt, ...partition }),
+    context: "fresh",
+    reads: [partitionPath],
+    output: branchPaths[index]!,
+    outputMode: "file-only",
+  }));
+  await ctx.parallel(steps, { concurrency: Math.min(ctx.inputs.max_concurrency, partitions.length), failFast: false });
+
+  const manifestPath = join(artifactDir, "manifest.json");
+  await writeFile(manifestPath, JSON.stringify({
+    task: ctx.inputs.prompt,
+    partition_plan: partitionPath,
+    branches: partitions.map((partition, index) => ({ ...partition, artifact_path: branchPaths[index] })),
+  }, null, 2));
+  const synthesisPath = join(artifactDir, "synthesis.md");
+  const synthesis = await ctx.task("synthesize", {
+    prompt: synthesisPrompt(ctx.inputs.prompt, manifestPath),
+    context: "fresh",
+    reads: [manifestPath, ...branchPaths],
+    output: synthesisPath,
+    outputMode: "file-only",
+  });
+  return {
+    result: await artifactText(synthesisPath, synthesis.text),
+    partitions: partitions.map((partition) => partition.label),
+    branch_artifact_paths: branchPaths,
+    synthesis_path: synthesisPath,
+    artifact_dir: artifactDir,
+    manifest_path: manifestPath,
+  };
+}

package/dist/builtin/workflows/builtin/fan-out-and-synthesize.d.ts

@@ -0,0 +1,23 @@
+import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../src/authoring.js";
+
+export type FanOutAndSynthesizeWorkflowInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly max_branches: number;
+  readonly max_concurrency: number;
+};
+export type FanOutAndSynthesizeWorkflowRunInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly max_branches?: number;
+  readonly max_concurrency?: number;
+};
+export type FanOutAndSynthesizeWorkflowOutputs = WorkflowOutputValues & {
+  readonly result: string;
+  readonly partitions: string[];
+  readonly branch_artifact_paths: string[];
+  readonly synthesis_path: string;
+  readonly artifact_dir: string;
+  readonly manifest_path: string;
+};
+export type FanOutAndSynthesizeWorkflowDefinition = WorkflowDefinition<FanOutAndSynthesizeWorkflowInputs, FanOutAndSynthesizeWorkflowOutputs, FanOutAndSynthesizeWorkflowRunInputs>;
+declare const definition: FanOutAndSynthesizeWorkflowDefinition;
+export default definition;

package/dist/builtin/workflows/builtin/fan-out-and-synthesize.ts

@@ -0,0 +1,32 @@
+import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
+import { runFanOutAndSynthesize } from "./fan-out-and-synthesize-runner.js";
+
+export default workflow({
+  name: "fan-out-and-synthesize",
+  description: "Partition a task, run bounded independent artifact branches, then synthesize all evidence at an explicit barrier.",
+  inputs: {
+    prompt: Type.String({ description: "Task to partition, investigate, and synthesize." }),
+    max_branches: Type.Integer({
+      minimum: 1,
+      maximum: 12,
+      default: 4,
+      description: "Maximum number of independent partitions produced and executed.",
+    }),
+    max_concurrency: Type.Integer({
+      minimum: 1,
+      maximum: 12,
+      default: 4,
+      description: "Maximum number of branch agents running concurrently.",
+    }),
+  },
+  outputs: {
+    result: Type.String({ description: "Evidence-citing synthesized report." }),
+    partitions: Type.Array(Type.String(), { description: "Ordered labels for executed partitions." }),
+    branch_artifact_paths: Type.Array(Type.String(), { description: "Ordered branch artifact paths consumed by synthesis." }),
+    synthesis_path: Type.String({ description: "Final synthesis artifact path." }),
+    artifact_dir: Type.String({ description: "Per-run artifact directory." }),
+    manifest_path: Type.String({ description: "Barrier manifest linking partitions to branch artifacts." }),
+  },
+  run: async (ctx) => await runFanOutAndSynthesize(ctx),
+});

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

@@ -0,0 +1,15 @@
+export function renderGeneratorPrompt(task: string, ordinal: number): string {
+  return `<role>\nYou independently generate candidate ${ordinal}; do not imitate or assume other candidates.\n</role>\n\n<objective>\n${task}\n</objective>\n\n<requirements>\nProduce one distinct, concrete candidate. Explain its value, constraints, risks, and how it can be evaluated.\n</requirements>\n\n<output_format>\nA self-contained candidate artifact with title, proposal, rationale, risks, and evaluation evidence.\n</output_format>`;
+}
+
+export function renderFilterPrompt(task: string, candidatePaths: readonly string[], shortlistSize: number): string {
+  return `<role>\nYou deduplicate and filter independently generated candidates.\n</role>\n\n<objective>\nSelect at most ${shortlistSize} strongest candidates for: ${task}\n</objective>\n\n<artifacts>\nRead every candidate: ${candidatePaths.join(", ")}\n</artifacts>\n\n<rubric>\nFirst collapse substantively equivalent candidates. Then score fit to the task, feasibility, evidence, distinctiveness, and risk. Near-duplicates must not gain weight by repetition. Record every discarded candidate and a concrete reason.\n</rubric>\n\n<output_format>\nCall structured_output with shortlist (candidate artifact paths in ranked order) and discarded entries containing path and reason.\n</output_format>`;
+}
+
+export function renderJudgePrompt(task: string, filterPath: string, shortlistSize: number): string {
+  return `<role>\nYou independently judge the filtered shortlist against the explicit rubric.\n</role>\n\n<objective>\nReturn at most ${shortlistSize} ranked candidate paths that best satisfy: ${task}\n</objective>\n\n<artifacts>\nRead the filter report at ${filterPath} and every candidate path it references.\n</artifacts>\n\n<rubric>\nCheck task fit, feasibility, evidence, distinctiveness, and material risk. Do not restore a duplicate merely because it is phrased differently.\n</rubric>\n\n<output_format>\nCall structured_output with shortlist and rationale.\n</output_format>`;
+}
+
+export function renderFinalShortlistPrompt(task: string, decisionPath: string): string {
+  return `<role>\nYou present a concise, actionable final shortlist.\n</role>\n\n<objective>\nSummarize the selected candidates for: ${task}\n</objective>\n\n<artifact>\nRead the authoritative selection at ${decisionPath}; follow its order and do not add candidates.\n</artifact>\n\n<output_format>\nRanked markdown shortlist with candidate path, differentiator, evidence, tradeoffs, and recommended next evaluation.\n</output_format>`;
+}

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

@@ -0,0 +1,75 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type, type Static } from "typebox";
+import type { WorkflowRunContext, WorkflowSerializableValue } from "../src/shared/types.js";
+import { renderFilterPrompt, renderFinalShortlistPrompt, renderGeneratorPrompt, renderJudgePrompt } from "./generate-and-filter-prompts.js";
+import { stableArtifactRoot } from "./pattern-artifact-root.js";
+
+const filterSchema = Type.Object({
+  shortlist: Type.Array(Type.String()),
+  discarded: Type.Array(Type.Object({ path: Type.String(), reason: Type.String() }, { additionalProperties: false })),
+}, { additionalProperties: false });
+const judgeSchema = Type.Object({ shortlist: Type.Array(Type.String()), rationale: Type.String() }, { additionalProperties: false });
+type FilterDecision = Static<typeof filterSchema>;
+type JudgeDecision = Static<typeof judgeSchema>;
+type Inputs = { readonly prompt: string; readonly num_candidates: number; readonly shortlist_size: number; readonly use_judge: boolean; readonly max_concurrency: number } & Record<string, WorkflowSerializableValue>;
+export type GenerateAndFilterResult = {
+  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;
+};
+function isRecord(value: WorkflowSerializableValue): value is Record<string, WorkflowSerializableValue> { return typeof value === "object" && value !== null && !Array.isArray(value); }
+function strings(value: WorkflowSerializableValue | undefined): value is string[] { return Array.isArray(value) && value.every((entry) => typeof entry === "string"); }
+function filterDecision(value: WorkflowSerializableValue | undefined): FilterDecision | undefined {
+  if (value === undefined || !isRecord(value) || !strings(value.shortlist) || !Array.isArray(value.discarded)) return undefined;
+  const valid = value.discarded.every((entry) => isRecord(entry) && typeof entry.path === "string" && typeof entry.reason === "string");
+  return valid ? value as FilterDecision : undefined;
+}
+function judgeDecision(value: WorkflowSerializableValue | undefined): JudgeDecision | undefined {
+  return value !== undefined && isRecord(value) && strings(value.shortlist) && typeof value.rationale === "string" ? value as JudgeDecision : undefined;
+}
+
+export async function runGenerateAndFilter(ctx: WorkflowRunContext<Inputs>): Promise<GenerateAndFilterResult> {
+  const root = await stableArtifactRoot(ctx, "generate-and-filter");
+  const candidatePaths = Array.from({ length: ctx.inputs.num_candidates }, (_, index) => join(root, `candidate-${index + 1}.md`));
+  const shortlistLimit = Math.min(ctx.inputs.shortlist_size, ctx.inputs.num_candidates);
+  await ctx.parallel(candidatePaths.map((path, index) => ({
+    name: `generate-${index + 1}`, prompt: renderGeneratorPrompt(ctx.inputs.prompt, index + 1), context: "fresh" as const,
+    output: path, outputMode: "file-only" as const,
+  })), { concurrency: ctx.inputs.max_concurrency, failFast: false });
+  const manifestPath = join(root, "manifest.json");
+  await writeFile(manifestPath, JSON.stringify({ task: ctx.inputs.prompt, candidate_artifact_paths: candidatePaths }, null, 2));
+
+  const filterPath = join(root, "filter.json");
+  const filtered = await ctx.task("dedupe-and-filter", {
+    prompt: renderFilterPrompt(ctx.inputs.prompt, candidatePaths, shortlistLimit), context: "fresh",
+    reads: [manifestPath, ...candidatePaths], schema: filterSchema, output: filterPath, outputMode: "file-only",
+  });
+  const selectCandidates = (paths: readonly string[]): string[] => [...new Set(paths.filter((path) => candidatePaths.includes(path)))].slice(0, shortlistLimit);
+  const fallbackShortlist = candidatePaths.slice(0, shortlistLimit);
+  const filteredShortlist = selectCandidates(filterDecision(filtered.structured)?.shortlist ?? []);
+  let shortlist = filteredShortlist.length > 0 ? filteredShortlist : fallbackShortlist;
+  let judgePath: string | null = null;
+  let decisionPath = filterPath;
+  if (ctx.inputs.use_judge) {
+    judgePath = join(root, "judge.json");
+    const judged = await ctx.task("judge", {
+      prompt: renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit), context: "fresh",
+      reads: [filterPath, ...shortlist], schema: judgeSchema, output: judgePath, outputMode: "file-only",
+    });
+    const judgedShortlist = selectCandidates(judgeDecision(judged.structured)?.shortlist ?? []);
+    shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
+    decisionPath = judgePath;
+  }
+  const finalPath = join(root, "shortlist.md");
+  await ctx.task("final-shortlist", {
+    prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath), context: "fresh",
+    reads: [decisionPath, ...shortlist], output: finalPath, outputMode: "file-only",
+  });
+  return { result: await readFile(finalPath, "utf8"), shortlist, candidate_artifact_paths: candidatePaths, filter_path: filterPath, judge_path: judgePath, final_path: finalPath, artifact_dir: root, manifest_path: manifestPath };
+}

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";