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

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

@@ -1,391 +0,0 @@
-import { readFile, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import { Type } from "typebox";
-import type { WorkflowRunContext, WorkflowSerializableValue, WorkflowTaskResult } from "../src/shared/types.js";
-import {
-	renderConsolidatorPrompt,
-	renderRepairPrompt,
-	renderWorkerPrompt,
-} from "./adversarial-verification-prompts.js";
-import {
-	build_scoring_prompt,
-	scoring_prompt_reads,
-	warm_first_fan_out,
-	type ScoringCandidate,
-	type SharedHead,
-} from "./verification-prompts.js";
-import { stableArtifactRoot } from "./pattern-artifact-root.js";
-import { fold_usage } from "./verification-usage.js";
-import {
-	decide_verification,
-	normalize_criteria,
-	parse_rubric,
-	VERIFICATION_SCALE,
-	type Criterion,
-	type Criteria,
-	type CriterionScore,
-	type VerificationDecision,
-} from "./verification-criteria.js";
-
-export const DEFAULT_CRITERIA = {
-	task_fit: "The candidate satisfies the literal task.",
-	evidence: "Important claims cite observable evidence, and file findings cite file:line where applicable.",
-	completeness: "Relevant validation is executed and reported with commands run and observed output, and no blocking correctness, safety, or completeness gap remains.",
-};
-
-// V2 deliberately requires every fanned-out cell to return a schema-valid score
-// after its bounded re-ask wave. A missing score is loudly Indeterminate rather
-// than silently narrowing the mean, and quorum is not caller-configurable.
-const QUORUM_FRACTION = 1;
-
-const criterionScoreSchema = Type.Object({
-	criterion_id: Type.String(),
-	score: VERIFICATION_SCALE.schema,
-	evidence: Type.Array(Type.String()),
-	findings: Type.Array(Type.Object({
-		finding: Type.String(),
-		severity: Type.Union([Type.Literal("veto"), Type.Literal("blocking"), Type.Literal("note")]),
-	}, { additionalProperties: false })),
-}, { additionalProperties: false });
-const consolidatorSchema = Type.Object({
-	repair_guidance: Type.String(),
-	remaining_work: Type.Array(Type.String()),
-}, { additionalProperties: false });
-
-type CriterionScoreReport = {
-	readonly criterion_id: string;
-	readonly score: number;
-	readonly evidence: readonly string[];
-	readonly findings: readonly {
-		readonly finding: string;
-		readonly severity: "veto" | "blocking" | "note";
-	}[];
-};
-type ConsolidatedReport = {
-	readonly repair_guidance: string;
-	readonly remaining_work: readonly string[];
-};
-type Inputs = {
-	readonly task: string;
-	readonly verifier_count: number;
-	readonly max_repairs: number;
-	readonly criteria?: string | Record<string, string>;
-	readonly accept_mean?: number;
-	readonly reask_limit?: number;
-};
-export type AdversarialVerificationResult = {
-	readonly approved: boolean;
-	readonly mean_score: number;
-	readonly score_table_path: string;
-	readonly repairs_completed: number;
-	readonly candidate_path: string;
-	readonly review_report_path: string;
-	readonly remaining_work: string[];
-};
-
-type VerificationCell = {
-	readonly criterion: Criterion;
-	readonly verifierIndex: number;
-	readonly name: string;
-	readonly artifactPath: string;
-};
-type ValidResult = {
-	readonly cell: VerificationCell;
-	readonly report: CriterionScoreReport;
-	readonly artifactPath: string;
-};
-type InvalidArtifact = {
-	readonly invalid: true;
-	readonly stage: string;
-};
-
-function isRecord(value: WorkflowSerializableValue): value is Record<string, WorkflowSerializableValue> {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-
-function hasOnlyKeys(value: Record<string, WorkflowSerializableValue>, keys: readonly string[]): boolean {
-	const actual = Object.keys(value);
-	return actual.length === keys.length && keys.every((key) => key in value);
-}
-
-function isStringArray(value: WorkflowSerializableValue | undefined): value is string[] {
-	return Array.isArray(value) && value.every((entry) => typeof entry === "string");
-}
-
-function isStringRecord(value: WorkflowSerializableValue): value is Record<string, string> {
-	return isRecord(value) && Object.values(value).every((entry) => typeof entry === "string");
-}
-
-function isCriterionFinding(value: WorkflowSerializableValue): boolean {
-	return isRecord(value)
-		&& hasOnlyKeys(value, ["finding", "severity"])
-		&& typeof value.finding === "string"
-		&& (value.severity === "veto" || value.severity === "blocking" || value.severity === "note");
-}
-
-function isCriterionScore(value: WorkflowSerializableValue | undefined, criterionId: string): value is CriterionScoreReport {
-	return value !== undefined
-		&& isRecord(value)
-		&& hasOnlyKeys(value, ["criterion_id", "score", "evidence", "findings"])
-		&& value.criterion_id === criterionId
-		&& typeof value.score === "number"
-		&& Number.isInteger(value.score)
-		&& value.score >= VERIFICATION_SCALE.min
-		&& value.score <= VERIFICATION_SCALE.max
-		&& isStringArray(value.evidence)
-		&& Array.isArray(value.findings)
-		&& value.findings.every(isCriterionFinding);
-}
-
-function isConsolidatedReport(value: WorkflowSerializableValue | undefined): value is ConsolidatedReport {
-	return value !== undefined
-		&& isRecord(value)
-		&& hasOnlyKeys(value, ["repair_guidance", "remaining_work"])
-		&& typeof value.repair_guidance === "string"
-		&& isStringArray(value.remaining_work);
-}
-
-function structured<T extends WorkflowSerializableValue>(
-	value: WorkflowSerializableValue | undefined,
-	guard: (candidate: WorkflowSerializableValue | undefined) => candidate is T,
-): T | undefined {
-	return guard(value) ? value : undefined;
-}
-
-function resolveCriteria(value: WorkflowSerializableValue | undefined): Criteria {
-	if (value === undefined) {
-		return { groundTruthNote: "", criteria: normalize_criteria(DEFAULT_CRITERIA) };
-	}
-	if (typeof value === "string") return parse_rubric(value);
-	if (isStringRecord(value)) return { groundTruthNote: "", criteria: normalize_criteria(value) };
-	throw new TypeError("criteria must be a criteria.md string or a record of criterion descriptions");
-}
-
-function renderCriteriaMarkdown(criteria: Criteria): string {
-	const lines = ["# Verification criteria"];
-	if (criteria.groundTruthNote.length > 0) lines.push("## Ground Truth Note", criteria.groundTruthNote);
-	lines.push("## Criteria");
-	for (const item of criteria.criteria) {
-		lines.push(`### ${item.name} {#${item.id}}`, item.description);
-	}
-	return `${lines.join("\n\n")}\n`;
-}
-
-function meanScore(scores: readonly CriterionScoreReport[]): number {
-	if (scores.length === 0) return 0;
-	return scores.reduce((total, score) => total + score.score, 0) / scores.length;
-}
-
-function toCriterionScore(report: CriterionScoreReport): CriterionScore {
-	return {
-		criterionId: report.criterion_id,
-		score: report.score,
-		evidence: report.evidence,
-		findings: report.findings,
-	};
-}
-
-function findingText(decision: Extract<VerificationDecision, { kind: "repair" }>): string[] {
-	return decision.findings.map((finding) => finding.finding);
-}
-
-function quorumEvidence(missing: number, invalidCount: number, expectedCount: number, reaskLimit: number): string {
-	return `Quorum failure: ${missing} of ${expectedCount} criterion scores remain missing after ${reaskLimit} re-ask wave(s); ${invalidCount} report attempts were invalid or missing.`;
-}
-
-function stageName(cell: VerificationCell, reaskWave: number): string {
-	return reaskWave === 0 ? cell.name : `${cell.name}-reask-${reaskWave}`;
-}
-
-function verifierOutputFormat(criterionId: string): string {
-	return `Call structured_output with criterion_id (set to ${criterionId}), score (1–20), evidence (string array), and findings containing finding and severity (veto, blocking, or note).`;
-}
-
-function scoreStep(
-	cell: VerificationCell,
-	reaskWave: number,
-	head: SharedHead,
-	criteriaPath: string,
-) {
-	const promptHead: SharedHead = {
-		...head,
-		outputFormat: verifierOutputFormat(cell.criterion.id),
-	};
-	return {
-		name: stageName(cell, reaskWave),
-		prompt: build_scoring_prompt(promptHead, cell.criterion),
-		context: "fresh" as const,
-		reads: [criteriaPath, ...scoring_prompt_reads(promptHead)],
-		schema: criterionScoreSchema,
-	};
-}
-
-async function writeInvalid(path: string, stage: string): Promise<void> {
-	const marker: InvalidArtifact = { invalid: true, stage };
-	await writeFile(path, `${JSON.stringify(marker, null, 2)}\n`);
-}
-
-export async function runAdversarialVerification(ctx: WorkflowRunContext<Inputs>): Promise<AdversarialVerificationResult> {
-	const root = await stableArtifactRoot(ctx, "adversarial-verification");
-	const criteriaPath = join(root, "criteria.md");
-	const candidatePath = join(root, "candidate.md");
-	const resolvedCriteria = resolveCriteria(ctx.inputs.criteria);
-	await writeFile(criteriaPath, renderCriteriaMarkdown(resolvedCriteria));
-	await ctx.task("worker", { prompt: renderWorkerPrompt(ctx.inputs.task), context: "fresh", output: candidatePath, outputMode: "file-only" });
-
-	const verifierCount = ctx.inputs.verifier_count ?? 3;
-	const maxRepairs = ctx.inputs.max_repairs ?? 2;
-	const acceptMean = ctx.inputs.accept_mean ?? 14;
-	const reaskLimit = Math.max(0, Math.floor(ctx.inputs.reask_limit ?? 1));
-	const expectedCount = resolvedCriteria.criteria.length * verifierCount;
-	let repairsCompleted = 0;
-	let consecutiveIndeterminate = 0;
-	let finalDecision: VerificationDecision;
-	let finalMean = 0;
-	let scoreTablePath: string;
-	let reviewReportPath: string;
-	let remainingWork: string[] = [];
-
-	for (let round = 0; ; round += 1) {
-		const candidateBody = await readFile(candidatePath, "utf8");
-		const scoringHead: SharedHead = {
-			task: ctx.inputs.task,
-			groundTruthNote: resolvedCriteria.groundTruthNote,
-			candidates: [{ path: candidatePath, body: candidateBody } satisfies ScoringCandidate],
-			scaleAnchors: VERIFICATION_SCALE.anchors,
-		};
-		const cells: VerificationCell[] = [];
-		for (const criterion of resolvedCriteria.criteria) {
-			for (let index = 0; index < verifierCount; index += 1) {
-				const name = `verifier-${round}-${criterion.id}-${index + 1}`;
-				cells.push({
-					criterion,
-					verifierIndex: index + 1,
-					name,
-					artifactPath: join(root, `verification-${round}-${criterion.id}-${index + 1}.json`),
-				});
-			}
-		}
-
-		const runWave = async (
-			pending: readonly VerificationCell[],
-			reaskWave: number,
-		): Promise<{ readonly valid: readonly ValidResult[]; readonly invalid: readonly VerificationCell[]; readonly results: readonly WorkflowTaskResult[] }> => {
-			if (pending.length === 0) return { valid: [], invalid: [], results: [] };
-			const reports = await warm_first_fan_out(
-				ctx,
-				pending.map((cell) => scoreStep(cell, reaskWave, scoringHead, criteriaPath)),
-				() => scoringHead,
-				{ concurrency: Math.min(pending.length, 4), failFast: false },
-			);
-			const byName = new Map<string, (typeof reports)[number]>();
-			for (const report of reports) {
-				const name = report.name ?? report.stageName;
-				if (name !== undefined) byName.set(name, report);
-			}
-			const valid: ValidResult[] = [];
-			const invalid: VerificationCell[] = [];
-			for (const cell of pending) {
-				const report = byName.get(stageName(cell, reaskWave));
-				const artifactPath = reaskWave === 0
-					? cell.artifactPath
-					: cell.artifactPath.replace(/\.json$/, `-reask-${reaskWave}.json`);
-				if (isCriterionScore(report?.structured, cell.criterion.id)) {
-					await writeFile(artifactPath, `${JSON.stringify(report.structured, null, 2)}\n`);
-					valid.push({ cell, report: report.structured, artifactPath });
-				} else {
-					await writeInvalid(artifactPath, stageName(cell, reaskWave));
-					invalid.push(cell);
-				}
-			}
-			return { valid, invalid, results: reports };
-		};
-
-		const roundResults: WorkflowTaskResult[] = [];
-		let pending = [...cells];
-		const validResults: ValidResult[] = [];
-		let invalidCount = 0;
-		for (let reaskWave = 0; reaskWave <= reaskLimit; reaskWave += 1) {
-			const wave = await runWave(pending, reaskWave);
-			roundResults.push(...wave.results);
-			validResults.push(...wave.valid);
-			invalidCount += wave.invalid.length;
-			pending = [...wave.invalid];
-			if (pending.length === 0) break;
-		}
-
-		const validReportsByCell = new Map(validResults.map((item) => [item.cell.name, item.report]));
-		const scoreReports = cells.flatMap((cell) => {
-			const report = validReportsByCell.get(cell.name);
-			return report === undefined ? [] : [report];
-		});
-		const scores = scoreReports.map(toCriterionScore);
-		const roundResult = { scores, invalidCount, expectedCount };
-		const decision = decide_verification(roundResult, { acceptMean, quorumFraction: QUORUM_FRACTION });
-		finalDecision = decision;
-		finalMean = meanScore(scoreReports);
-		scoreTablePath = join(root, `verification-summary-${round}.json`);
-		reviewReportPath = join(root, `review-${round}.json`);
-		const summary = {
-			scores: scoreReports,
-			mean: finalMean,
-			invalidCount,
-			decision,
-			usage: fold_usage(roundResults),
-		};
-
-		if (decision.kind === "accept") {
-			remainingWork = [];
-			await writeFile(scoreTablePath, `${JSON.stringify(summary, null, 2)}\n`);
-			await writeFile(reviewReportPath, `${JSON.stringify({ decision, remaining_work: [] }, null, 2)}\n`);
-			break;
-		}
-
-		if (decision.kind === "indeterminate") {
-			consecutiveIndeterminate += 1;
-			remainingWork = [quorumEvidence(decision.missing, invalidCount, expectedCount, reaskLimit)];
-			await writeFile(scoreTablePath, `${JSON.stringify(summary, null, 2)}\n`);
-			await writeFile(reviewReportPath, `${JSON.stringify({ decision, evidence: remainingWork, remaining_work: remainingWork }, null, 2)}\n`);
-			if (consecutiveIndeterminate >= 2) break;
-			continue;
-		}
-
-		consecutiveIndeterminate = 0;
-		const confirmedFindings = findingText(decision);
-		const scorePaths = validResults.map((item) => item.artifactPath);
-		const consolidated = await ctx.task(`consolidate-findings-${round}`, {
-			prompt: renderConsolidatorPrompt(ctx.inputs.task, candidatePath, scorePaths, repairsCompleted, maxRepairs),
-			context: "fresh",
-			reads: [candidatePath, criteriaPath, ...scorePaths],
-			schema: consolidatorSchema,
-		});
-		const fallbackRemaining = confirmedFindings.length > 0
-			? confirmedFindings
-			: [`Mean score ${decision.mean} is below the acceptance threshold ${acceptMean}.`];
-		const consolidatedReport: ConsolidatedReport = structured(consolidated.structured, isConsolidatedReport)
-			?? { repair_guidance: "Confirmed verifier findings require repair.", remaining_work: fallbackRemaining };
-		remainingWork = fallbackRemaining;
-		await writeFile(scoreTablePath, `${JSON.stringify(summary, null, 2)}\n`);
-		await writeFile(reviewReportPath, `${JSON.stringify({ ...consolidatedReport, remaining_work: remainingWork }, null, 2)}\n`);
-
-		if (repairsCompleted >= maxRepairs) 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",
-		});
-	}
-
-	return {
-		approved: finalDecision.kind === "accept",
-		mean_score: finalMean,
-		score_table_path: scoreTablePath,
-		repairs_completed: repairsCompleted,
-		candidate_path: candidatePath,
-		review_report_path: reviewReportPath,
-		remaining_work: finalDecision.kind === "accept" ? [] : remainingWork,
-	};
-}

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

@@ -1,34 +0,0 @@
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.js";
-import { DEFAULT_CRITERIA, runAdversarialVerification } from "./adversarial-verification-runner.js";
-
-export default workflow({
-  name: "adversarial-verification",
-  description: "Produce a candidate, score independent per-criterion verifier reports, and apply a deterministic mean-and-veto gate with bounded repairs.",
-  // The 15-minute default, stated rather than inherited: this is a per-workflow
-  // product decision, so a future change to the global default must not silently
-  // re-cadence a long autonomous run.
-  heartbeatIntervalMinutes: 15,
-  inputs: {
-    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 for each criterion per round." }),
-    max_repairs: Type.Integer({ minimum: 0, maximum: 5, default: 2, description: "Maximum candidate repair rounds before rejection." }),
-    criteria: Type.Union([
-      Type.String(),
-      Type.Record(Type.String(), Type.String()),
-    ], { default: DEFAULT_CRITERIA, description: "Criteria record of name-to-description entries, or criteria.md markdown." }),
-    accept_mean: Type.Number({ default: 14, description: "Mean score required for acceptance on the 1–20 verification scale." }),
-    reask_limit: Type.Integer({ minimum: 0, default: 1, description: "Maximum bounded re-ask waves for invalid criterion reports." }),
-  },
-  outputs: {
-    approved: Type.Boolean({ description: "Whether the deterministic mean-and-veto gate accepted the candidate." }),
-    mean_score: Type.Number({ description: "Mean score of the final round's schema-valid criterion reports." }),
-    score_table_path: Type.String({ description: "Path to the final round per-criterion score summary." }),
-    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 consolidated findings or quorum report." }),
-    remaining_work: Type.Array(Type.String(), { description: "Unresolved findings or quorum evidence when not approved." }),
-  },
-  run: async (ctx) => await runAdversarialVerification(withSteeringPropagationContext(ctx)),
-});

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

@@ -1,14 +0,0 @@
-const GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
-const READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
-
-export function classifierPrompt(prompt: string, categories: readonly string[]): string {
-  return `<categories>\n${categories.map((category) => `- ${category}`).join("\n")}\n</categories>\n\n<role>\nYou route a task to exactly one declared action category.\n</role>\n\n<success_criteria>\nThe selected category is copied verbatim and supported by the task's concrete wording.\n</success_criteria>\n\n<decision_rules>\nChoose exactly one listed category. Use low confidence when the task is ambiguous or spans categories. Stop after making that single classification.\n</decision_rules>\n\n<output_format>\nReturn only the structured result requested by the schema: category, confidence, and a concise evidence-based rationale in complete sentences.\n</output_format>\n\n<objective>\nClassify this task: ${prompt}\n</objective>`;
-}
-
-export function actionPrompt(input: {
-  readonly prompt: string;
-  readonly category: string;
-  readonly classificationPath: string;
-}): string {
-  return `<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<role>\nYou are the isolated action agent for category "${input.category}".\n</role>\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<stop_rules>\nStop when the category-specific action is complete or a remaining blocker is stated with its missing evidence.\n</stop_rules>\n\n<output_format>\nMarkdown with Outcome, Evidence, Validation, and Remaining risks headings. ${READABLE_REPORT}\n${GROUNDED_REPORTING}\n</output_format>\n\n<objective>\n${input.prompt}\n</objective>`;
-}

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

@@ -1,108 +0,0 @@
-import { 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"];
-}
-
-/**
- * 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",
-  });
-  // `file-only` already returns a compact artifact reference. Reading the file
-  // back here would defeat that and push the whole report into the caller's
-  // context; `action_path` is returned for callers that want the contents.
-  const result = 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.ts

@@ -1,40 +0,0 @@
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.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.",
-  // The 15-minute default, stated rather than inherited: this is a per-workflow
-  // product decision, so a future change to the global default must not silently
-  // re-cadence a long autonomous run.
-  heartbeatIntervalMinutes: 15,
-  inputs: {
-    prompt: Type.String({ description: "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: "Compact reference to the category-specific action report artifact; read `action_path` for the full 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(withSteeringPropagationContext(ctx)),
-});

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

@@ -1,14 +0,0 @@
-const GROUNDED_REPORTING = "Before reporting progress, audit each claim against a tool result from this session. Report only work you can point to evidence for; say so explicitly when something is unverified.";
-const READABLE_REPORT = "Lead with the outcome. Keep facts, decisions, caveats, and next steps; drop background and repetition. Use complete, readable sentences rather than compressed fragments.";
-
-export function partitionPrompt(prompt: string, maxBranches: number): string {
-  return `<role>\nYou partition work into independent evidence-producing branches.\n</role>\n\n<success_criteria>\nThe plan has between 1 and ${maxBranches} non-overlapping partitions whose labels and objectives are self-contained.\n</success_criteria>\n\n<decision_rules>\nSplit by files, sources, claims, candidates, or work items that can be evaluated independently. Avoid duplicate scope and identify boundaries explicitly. Stop when every required part of the task belongs to one partition.\n</decision_rules>\n\n<output_format>\nReturn only the structured result requested by the schema, with concise labels and self-contained objectives.\n</output_format>\n\n<objective>\nPartition this task: ${prompt}\n</objective>`;
-}
-
-export function branchPrompt(input: { readonly prompt: string; readonly label: string; readonly objective: string }): string {
-  return `<overall_task>\n${input.prompt}\n</overall_task>\n\n<role>\nYou own one independent branch of a larger task. Your artifact lets a synthesizer audit this branch without its conversation context.\n</role>\n\n<success_criteria>\nCite concrete files, sources, commands, or other observable evidence, distinguish findings from uncertainty, and produce a standalone artifact.\n</success_criteria>\n\n<stop_rules>\nStop when the branch objective is supported or when unresolved uncertainty and the evidence needed to resolve it are explicit.\n</stop_rules>\n\n<output_format>\nMarkdown with Scope, Findings, Evidence, Conflicts or uncertainty, and Recommendations headings. ${READABLE_REPORT}\n${GROUNDED_REPORTING}\n</output_format>\n\n<branch>\nInvestigate only ${input.label}: ${input.objective}\n</branch>`;
-}
-
-export function synthesisPrompt(prompt: string, manifestPath: string): string {
-  return `<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<role>\nYou synthesize independent branch artifacts at a strict barrier. The final reader needs conclusions traceable to branch evidence rather than majority vote.\n</role>\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.\n</success_criteria>\n\n<stop_rules>\nStop after every completed branch is accounted for and each material conflict is resolved or preserved as uncertainty.\n</stop_rules>\n\n<output_format>\nMarkdown with Executive synthesis, Consolidated findings, Conflicts and resolutions, Evidence index, and Remaining uncertainty headings. ${READABLE_REPORT}\n${GROUNDED_REPORTING}\n</output_format>\n\n<objective>\nProduce the final answer for: ${prompt}\n</objective>`;
-}