@bastani/atomic 0.9.9 → 0.9.10-alpha.1

package/dist/builtin/workflows/builtin/adversarial-verification-prompts.ts

@@ -0,0 +1,15 @@
+export function renderWorkerPrompt(task: string): string {
+  return `<role>\nYou produce a candidate solution for independent verification.\n</role>\n\n<objective>\n${task}\n</objective>\n\n<requirements>\nComplete the task, preserve concrete evidence, and state every validation performed. Do not claim success without observable support.\n</requirements>\n\n<output_format>\nA self-contained candidate with actions taken, evidence, validation, and remaining risks.\n</output_format>`;
+}
+
+export function renderVerifierPrompt(task: string, candidatePath: string, rubricPath: string): string {
+  return `<role>\nYou are an independent adversarial verifier. Find blockers; do not rewrite the candidate.\n</role>\n\n<objective>\nVerify the candidate against the task and rubric. Task: ${task}\n</objective>\n\n<artifacts>\nRead the complete candidate at ${candidatePath} and rubric at ${rubricPath}.\n</artifacts>\n\n<requirements>\nTest important claims where practical. A pass requires concrete evidence for every rubric item. Report precise blocking findings; absence of evidence is not evidence of correctness.\n</requirements>\n\n<output_format>\nCall structured_output with verdict (pass or fail), evidence, and blocking_findings.\n</output_format>`;
+}
+
+export function renderReducerPrompt(task: string, candidatePath: string, verifierPaths: readonly string[], repairsCompleted: number, maxRepairs: number): string {
+  return `<role>\nYou reduce independent verification reports into one deterministic next action.\n</role>\n\n<objective>\nDecide whether the candidate for ${task} is accepted, rejected, or needs repair.\n</objective>\n\n<artifacts>\nCandidate: ${candidatePath}\nVerifier reports: ${verifierPaths.join(", ")}\n</artifacts>\n\n<decision_rules>\nAccept only when all material rubric requirements have pass evidence. Request repair when findings are actionable and repair budget remains (${repairsCompleted}/${maxRepairs}). Reject when evidence proves the candidate cannot satisfy the task or the repair budget is exhausted. Preserve unresolved blockers verbatim.\n</decision_rules>\n\n<output_format>\nCall structured_output with decision (accept, reject, or repair), rationale, and remaining_work.\n</output_format>`;
+}
+
+export function renderRepairPrompt(task: string, candidatePath: string, reviewPath: string): string {
+  return `<role>\nYou repair a candidate using independent blocking findings.\n</role>\n\n<objective>\nRepair the candidate for: ${task}\n</objective>\n\n<artifacts>\nRead the current candidate at ${candidatePath} and reducer report at ${reviewPath}.\n</artifacts>\n\n<requirements>\nAddress every actionable blocker, rerun relevant validation, and retain valid prior work. Do not dismiss a finding without contrary evidence.\n</requirements>\n\n<output_format>\nA complete replacement candidate with repair summary, evidence, validation, and remaining risks.\n</output_format>`;
+}

package/dist/builtin/workflows/builtin/adversarial-verification-runner.ts

@@ -0,0 +1,93 @@
+import { 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 { renderReducerPrompt, renderRepairPrompt, renderVerifierPrompt, renderWorkerPrompt } from "./adversarial-verification-prompts.js";
+import { stableArtifactRoot } from "./pattern-artifact-root.js";
+
+const verifierSchema = Type.Object({
+  verdict: Type.Union([Type.Literal("pass"), Type.Literal("fail")]),
+  evidence: Type.Array(Type.String()),
+  blocking_findings: Type.Array(Type.String()),
+}, { additionalProperties: false });
+const reducerSchema = Type.Object({
+  decision: Type.Union([Type.Literal("accept"), Type.Literal("reject"), Type.Literal("repair")]),
+  rationale: Type.String(),
+  remaining_work: Type.Array(Type.String()),
+}, { additionalProperties: false });
+
+type VerifierDecision = Static<typeof verifierSchema>;
+type ReducerDecision = Static<typeof reducerSchema>;
+type Inputs = { readonly task: string; readonly verifier_count: number; readonly max_repairs: number } & Record<string, WorkflowSerializableValue>;
+export type AdversarialVerificationResult = {
+  readonly result: string;
+  readonly approved: boolean;
+  readonly repairs_completed: number;
+  readonly candidate_path: string;
+  readonly review_report_path: string;
+  readonly verifier_artifact_paths: string[];
+  readonly artifact_dir: string;
+  readonly remaining_work: string[];
+};
+
+function structured<T extends WorkflowSerializableValue>(value: WorkflowSerializableValue | undefined, guard: (candidate: WorkflowSerializableValue) => candidate is T): T | undefined {
+  return value !== undefined && guard(value) ? value : undefined;
+}
+function isRecord(value: WorkflowSerializableValue): value is Record<string, WorkflowSerializableValue> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isVerifier(value: WorkflowSerializableValue): value is VerifierDecision {
+  return isRecord(value) && (value.verdict === "pass" || value.verdict === "fail") && Array.isArray(value.evidence) && value.evidence.every((item) => typeof item === "string") && Array.isArray(value.blocking_findings) && value.blocking_findings.every((item) => typeof item === "string");
+}
+function isReducer(value: WorkflowSerializableValue): value is ReducerDecision {
+  return isRecord(value) && (value.decision === "accept" || value.decision === "reject" || value.decision === "repair") && typeof value.rationale === "string" && Array.isArray(value.remaining_work) && value.remaining_work.every((item) => typeof item === "string");
+}
+
+export async function runAdversarialVerification(ctx: WorkflowRunContext<Inputs>): Promise<AdversarialVerificationResult> {
+  const root = await stableArtifactRoot(ctx, "adversarial-verification");
+  const rubricPath = join(root, "rubric.md");
+  const candidatePath = join(root, "candidate.md");
+  await writeFile(rubricPath, ["# Verification rubric", "- The candidate satisfies the literal task.", "- Important claims cite observable evidence.", "- Relevant validation is executed and reported.", "- No blocking correctness, safety, or completeness gap remains."].join("\n"));
+  await ctx.task("worker", { prompt: renderWorkerPrompt(ctx.inputs.task), context: "fresh", output: candidatePath, outputMode: "file-only" });
+
+  let repairsCompleted = 0;
+  let reviewReportPath!: string;
+  let verifierArtifactPaths: string[] = [];
+  let decision: ReducerDecision = { decision: "reject", rationale: "No valid reducer decision was produced.", remaining_work: ["Reducer did not return a valid structured decision."] };
+  for (;;) {
+    verifierArtifactPaths = Array.from({ length: ctx.inputs.verifier_count }, (_, index) => join(root, `verification-${repairsCompleted}-${index + 1}.json`));
+    const reports = await ctx.parallel(verifierArtifactPaths.map((path, index) => ({
+      name: `verifier-${repairsCompleted}-${index + 1}`,
+      prompt: renderVerifierPrompt(ctx.inputs.task, candidatePath, rubricPath),
+      context: "fresh" as const,
+      reads: [candidatePath, rubricPath],
+      schema: verifierSchema,
+      output: path,
+      outputMode: "file-only" as const,
+    })), { concurrency: Math.min(ctx.inputs.verifier_count, 4), failFast: false });
+    const validReports = reports.map((report) => structured(report.structured, isVerifier)).filter((report): report is VerifierDecision => report !== undefined);
+    const allVerifiersPassed = validReports.length === ctx.inputs.verifier_count && validReports.every((report) => report.verdict === "pass");
+    await writeFile(join(root, `verification-summary-${repairsCompleted}.json`), JSON.stringify(validReports, null, 2));
+    reviewReportPath = join(root, `review-${repairsCompleted}.json`);
+    const reduced = await ctx.task(`reducer-${repairsCompleted}`, {
+      prompt: renderReducerPrompt(ctx.inputs.task, candidatePath, verifierArtifactPaths, repairsCompleted, ctx.inputs.max_repairs),
+      context: "fresh", reads: [candidatePath, rubricPath, ...verifierArtifactPaths], schema: reducerSchema,
+      output: reviewReportPath, outputMode: "file-only",
+    });
+    decision = structured(reduced.structured, isReducer) ?? decision;
+    if (decision.decision === "accept" && !allVerifiersPassed) {
+      const remaining = validReports.flatMap((report) => report.blocking_findings);
+      decision = repairsCompleted < ctx.inputs.max_repairs
+        ? { decision: "repair", rationale: "Independent verification did not unanimously pass.", remaining_work: remaining }
+        : { decision: "reject", rationale: "Independent verification did not pass before the repair bound was exhausted.", remaining_work: remaining };
+    }
+    if (decision.decision === "repair" && repairsCompleted >= ctx.inputs.max_repairs) {
+      decision = { ...decision, decision: "reject", rationale: `${decision.rationale} Repair bound exhausted.` };
+    }
+    if (decision.decision !== "repair") break;
+    repairsCompleted += 1;
+    await ctx.task(`repair-${repairsCompleted}`, { prompt: renderRepairPrompt(ctx.inputs.task, candidatePath, reviewReportPath), context: "fresh", reads: [candidatePath, reviewReportPath], output: candidatePath, outputMode: "file-only" });
+  }
+  const approved = decision.decision === "accept";
+  return { result: decision.rationale, approved, repairs_completed: repairsCompleted, candidate_path: candidatePath, review_report_path: reviewReportPath, verifier_artifact_paths: verifierArtifactPaths, artifact_dir: root, remaining_work: approved ? [] : decision.remaining_work };
+}

package/dist/builtin/workflows/builtin/adversarial-verification.d.ts

@@ -0,0 +1,11 @@
+import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../src/authoring.js";
+export type AdversarialVerificationInputs = WorkflowInputValues & { readonly task: string; readonly verifier_count: number; readonly max_repairs: number };
+export type AdversarialVerificationRunInputs = WorkflowInputValues & { readonly task: string; readonly verifier_count?: number; readonly max_repairs?: number };
+export type AdversarialVerificationOutputs = WorkflowOutputValues & {
+  readonly result: string; readonly approved: boolean; readonly repairs_completed: number;
+  readonly candidate_path: string; readonly review_report_path: string;
+  readonly verifier_artifact_paths: string[]; readonly artifact_dir: string; readonly remaining_work: string[];
+};
+export type AdversarialVerificationDefinition = WorkflowDefinition<AdversarialVerificationInputs, AdversarialVerificationOutputs, AdversarialVerificationRunInputs>;
+declare const workflow: AdversarialVerificationDefinition;
+export default workflow;

package/dist/builtin/workflows/builtin/adversarial-verification.ts

@@ -0,0 +1,24 @@
+import { Type } from "typebox";
+import { workflow } from "../src/authoring/workflow.js";
+import { runAdversarialVerification } from "./adversarial-verification-runner.js";
+
+export default workflow({
+  name: "adversarial-verification",
+  description: "Produce a candidate, challenge it with fresh-context rubric-based verifiers, and reduce their evidence through a bounded repair loop.",
+  inputs: {
+    task: Type.String({ description: "Task whose candidate result must be independently verified." }),
+    verifier_count: Type.Integer({ minimum: 1, maximum: 5, default: 3, description: "Number of independent verifiers per review round." }),
+    max_repairs: Type.Integer({ minimum: 0, maximum: 5, default: 2, description: "Maximum candidate repair rounds before rejection." }),
+  },
+  outputs: {
+    result: Type.String({ description: "Final reducer rationale." }),
+    approved: Type.Boolean({ description: "Whether verification accepted the candidate." }),
+    repairs_completed: Type.Integer({ description: "Number of repair rounds performed." }),
+    candidate_path: Type.String({ description: "Path to the final candidate artifact." }),
+    review_report_path: Type.String({ description: "Path to the final reducer report." }),
+    verifier_artifact_paths: Type.Array(Type.String(), { description: "Paths to final-round verifier reports." }),
+    artifact_dir: Type.String({ description: "Directory containing run artifacts." }),
+    remaining_work: Type.Array(Type.String(), { description: "Unresolved blocking findings when not approved." }),
+  },
+  run: runAdversarialVerification,
+});

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

@@ -0,0 +1,11 @@
+export function classifierPrompt(prompt: string, categories: readonly string[]): string {
+  return `<role>\nYou route a task to exactly one declared action category.\n</role>\n\n<objective>\nClassify this task: ${prompt}\n</objective>\n\n<categories>\n${categories.map((category) => `- ${category}`).join("\n")}\n</categories>\n\n<requirements>\nChoose a category verbatim from the list. Base confidence on concrete wording in the task. Use low confidence when the task is ambiguous or spans categories. Provide a concise evidence-based rationale. Return only the structured result requested by the schema.\n</requirements>`;
+}
+
+export function actionPrompt(input: {
+  readonly prompt: string;
+  readonly category: string;
+  readonly classificationPath: string;
+}): string {
+  return `<role>\nYou are the isolated action agent for category "${input.category}".\n</role>\n\n<objective>\n${input.prompt}\n</objective>\n\n<evidence>\nRead the classification artifact at ${input.classificationPath}. Use only relevant evidence available to this stage; do not assume access to classifier conversation context.\n</evidence>\n\n<success_criteria>\nComplete the requested action for this category, distinguish verified facts from assumptions, and report concrete evidence, validation, and remaining risks.\n</success_criteria>\n\n<output_format>\nMarkdown with Outcome, Evidence, Validation, and Remaining risks headings.\n</output_format>`;
+}

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

@@ -0,0 +1,110 @@
+import { readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+import type { WorkflowRunContext, WorkflowSerializableValue } from "../src/shared/types.js";
+import { actionPrompt, classifierPrompt } from "./classify-and-act-prompts.js";
+import { stableArtifactRoot } from "./pattern-artifact-root.js";
+
+export const classificationSchema = Type.Object({
+  category: Type.String({ description: "One category copied verbatim from the supplied list." }),
+  confidence: Type.Number({ minimum: 0, maximum: 1 }),
+  rationale: Type.String(),
+}, { additionalProperties: false });
+
+type Inputs = {
+  readonly prompt: string;
+  readonly categories: readonly string[];
+  readonly confidence_threshold: number;
+} & Record<string, WorkflowSerializableValue>;
+
+export type ClassifyAndActResult = {
+  readonly result: string;
+  readonly category: string;
+  readonly confidence: number;
+  readonly action: string;
+  readonly classification_path: string;
+  readonly action_path: string;
+  readonly artifact_dir: string;
+};
+
+function safeName(value: string): string {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return normalized || "fallback";
+}
+function actionTools(category: string): readonly string[] {
+  const normalized = category.toLowerCase();
+  if (normalized.includes("implement") || normalized.includes("fix") || normalized.includes("code")) {
+    return ["read", "edit", "write", "bash"];
+  }
+  if (normalized.includes("research")) return ["read", "web_search", "fetch_content"];
+  return ["read"];
+}
+
+
+async function artifactText(path: string, fallback: string): Promise<string> {
+  try { return await readFile(path, "utf8"); } catch { return fallback; }
+}
+
+/**
+ * Resolve a low-confidence or unlisted classification. Interactive runs ask the
+ * user; headless/non-interactive runs (where ctx.ui rejects) deterministically
+ * fall back to the exact proposed category when it is listed, else the first
+ * configured category, so the workflow still produces its declared outputs.
+ */
+async function resolveFallbackCategory(
+  ctx: WorkflowRunContext<Inputs>,
+  exactCategory: string | undefined,
+): Promise<{ category: string; fallbackMode: "interactive_select" | "deterministic" }> {
+  try {
+    const category = await ctx.ui.select("Classification is uncertain. Choose the action category.", ctx.inputs.categories);
+    return { category, fallbackMode: "interactive_select" };
+  } catch {
+    return { category: exactCategory ?? ctx.inputs.categories[0]!, fallbackMode: "deterministic" };
+  }
+}
+
+export async function runClassifyAndAct(ctx: WorkflowRunContext<Inputs>): Promise<ClassifyAndActResult> {
+  const artifactDir = await stableArtifactRoot(ctx, "classify-and-act");
+  const classified = await ctx.task("classifier", {
+    prompt: classifierPrompt(ctx.inputs.prompt, ctx.inputs.categories),
+    schema: classificationSchema,
+    context: "fresh",
+    tools: [],
+  });
+  const value = classified.structured;
+  const proposedCategory = typeof value === "object" && value !== null && "category" in value
+    ? String(value.category) : "";
+  const confidenceValue = typeof value === "object" && value !== null && "confidence" in value
+    ? value.confidence : 0;
+  const confidence = typeof confidenceValue === "number" && Number.isFinite(confidenceValue)
+    ? Math.max(0, Math.min(1, confidenceValue)) : 0;
+  const rationale = typeof value === "object" && value !== null && "rationale" in value
+    ? String(value.rationale) : "Classifier did not provide a usable structured rationale.";
+  const exactCategory = ctx.inputs.categories.find((category) => category === proposedCategory);
+  const needsFallback = exactCategory === undefined || confidence < ctx.inputs.confidence_threshold;
+  const fallback = needsFallback ? await resolveFallbackCategory(ctx, exactCategory) : undefined;
+  const category = fallback?.category ?? exactCategory!;
+
+  const classificationPath = join(artifactDir, "classification.json");
+  await writeFile(classificationPath, JSON.stringify({
+    proposed_category: proposedCategory,
+    selected_category: category,
+    confidence,
+    threshold: ctx.inputs.confidence_threshold,
+    rationale,
+    fallback_used: needsFallback,
+    fallback_mode: fallback?.fallbackMode ?? "none",
+  }, null, 2));
+
+  const actionPath = join(artifactDir, `action-${safeName(category)}.md`);
+  const action = await ctx.task(`action-${safeName(category)}`, {
+    tools: actionTools(category),
+    prompt: actionPrompt({ prompt: ctx.inputs.prompt, category, classificationPath }),
+    context: "fresh",
+    reads: [classificationPath],
+    output: actionPath,
+    outputMode: "file-only",
+  });
+  const result = await artifactText(actionPath, action.text);
+  return { result, category, confidence, action: action.stageName, classification_path: classificationPath, action_path: actionPath, artifact_dir: artifactDir };
+}

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

@@ -0,0 +1,24 @@
+import type { WorkflowDefinition, WorkflowInputValues, WorkflowOutputValues } from "../src/authoring.js";
+
+export type ClassifyAndActWorkflowInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly categories: string[];
+  readonly confidence_threshold: number;
+};
+export type ClassifyAndActWorkflowRunInputs = WorkflowInputValues & {
+  readonly prompt: string;
+  readonly categories?: string[];
+  readonly confidence_threshold?: number;
+};
+export type ClassifyAndActWorkflowOutputs = WorkflowOutputValues & {
+  readonly result: string;
+  readonly category: string;
+  readonly confidence: number;
+  readonly action: string;
+  readonly classification_path: string;
+  readonly action_path: string;
+  readonly artifact_dir: string;
+};
+export type ClassifyAndActWorkflowDefinition = WorkflowDefinition<ClassifyAndActWorkflowInputs, ClassifyAndActWorkflowOutputs, ClassifyAndActWorkflowRunInputs>;
+declare const definition: ClassifyAndActWorkflowDefinition;
+export default definition;

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 };
+}