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

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

@@ -1,96 +0,0 @@
-import { 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"}`;
-}
-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 {
-    // `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; `synthesis_path` is returned for callers that want the contents.
-    result: 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.ts

@@ -1,37 +0,0 @@
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.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.",
-  // 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 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: "Compact reference to the evidence-citing synthesis artifact; read `synthesis_path` for the full 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(withSteeringPropagationContext(ctx)),
-});

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

@@ -1,41 +0,0 @@
-import type { ScoringCandidate, SharedHead } from "./verification-prompts.js";
-import { build_scoring_prompt, scoring_prompt_reads } from "./verification-prompts.js";
-
-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 interface RenderedJudgePrompt {
-	readonly prompt: string;
-	readonly reads: readonly string[];
-}
-
-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<success_criteria>\nOne distinct, concrete candidate states its value, constraints, risks, and how it can be evaluated.\n</success_criteria>\n\n<stop_rules>\nStop after one self-contained, evaluable candidate; do not add alternatives.\n</stop_rules>\n\n<output_format>\nA candidate artifact with title, proposal, criteria-based rationale, risks, and evaluation evidence. ${READABLE_REPORT}\n${GROUNDED_REPORTING}\n</output_format>\n\n<objective>\n${task}\n</objective>`;
-}
-
-export function renderFilterPrompt(task: string, candidatePaths: readonly string[], shortlistSize: number): string {
-  return `<artifacts>\nRead every candidate: ${candidatePaths.join(", ")}\n</artifacts>\n\n<role>\nYou deduplicate and filter independently generated candidates.\n</role>\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<success_criteria>\nAt most ${shortlistSize} strongest distinct candidates remain, ranked by the rubric, and every discarded candidate has a concrete reason.\n</success_criteria>\n\n<stop_rules>\nStop after every candidate is shortlisted once or recorded as discarded.\n</stop_rules>\n\n<output_format>\nCall structured_output with shortlist (candidate artifact paths in ranked order) and discarded entries containing path and a concise, criteria-based reason.\n</output_format>\n\n<objective>\nSelect at most ${shortlistSize} strongest candidates for: ${task}\n</objective>`;
-}
-
-export function renderJudgePrompt(
-	task: string,
-	filterPath: string,
-	shortlistSize: number,
-	candidates: readonly ScoringCandidate[] = [],
-): RenderedJudgePrompt {
-	const head: SharedHead = {
-		task: `Rank at most ${shortlistSize} distinct candidate paths for: ${task}.`,
-		groundTruthNote: `Read the filter report at ${filterPath} and every candidate path it references before judging.`,
-		candidates,
-		outputFormat: "Call structured_output with shortlist (candidate paths in ranked order) and rationale (a concise, criteria-based explanation).",
-	};
-	const prompt = build_scoring_prompt(head, {
-		id: "filtered_shortlist",
-		name: "Filtered shortlist",
-		description: "Check task fit, feasibility, evidence, distinctiveness, and material risk; do not restore a duplicate merely because it is phrased differently.",
-	});
-	return { prompt, reads: [filterPath, ...scoring_prompt_reads(head)] };
-}
-export function renderFinalShortlistPrompt(task: string, decisionPath: string): string {
-  return `<artifact>\nRead the authoritative selection at ${decisionPath}; follow its order and do not add candidates.\n</artifact>\n\n<role>\nYou present a concise, actionable final shortlist so the reader can choose the next evaluation without reading the selection session.\n</role>\n\n<success_criteria>\nEvery selected candidate appears once in authoritative order with its differentiator, evidence, tradeoffs, and recommended next evaluation.\n</success_criteria>\n\n<stop_rules>\nStop after presenting every selected candidate once; do not add or reorder candidates.\n</stop_rules>\n\n<output_format>\nRanked markdown shortlist with candidate path, differentiator, evidence, tradeoffs, and recommended next evaluation. ${READABLE_REPORT}\n${GROUNDED_REPORTING}\n</output_format>\n\n<objective>\nSummarize the selected candidates for: ${task}\n</objective>`;
-}

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

@@ -1,90 +0,0 @@
-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,
-  });
-  const filteredDecision = filterDecision(filtered.structured);
-  // The filter report is inter-stage data: the judge and final-shortlist
-  // stages read schema-shaped JSON from this path, so the runner persists the
-  // structured decision itself rather than routing it through the artifact.
-  await writeFile(filterPath, `${JSON.stringify(filteredDecision ?? { shortlist: [], discarded: [] }, null, 2)}\n`);
-  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(filteredDecision?.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 judgeCandidates = await Promise.all(
-			shortlist.map(async (path) => ({ path, body: await readFile(path, "utf8") })),
-		);
-		const judgePrompt = renderJudgePrompt(ctx.inputs.prompt, filterPath, shortlistLimit, judgeCandidates);
-		const judged = await ctx.task("judge", {
-			prompt: judgePrompt.prompt, context: "fresh",
-			reads: judgePrompt.reads, schema: judgeSchema,
-		});
-		const judgedDecision = judgeDecision(judged.structured);
-		// Same inter-stage contract as the filter report above.
-		await writeFile(judgePath, `${JSON.stringify(judgedDecision ?? { shortlist: [], rationale: "Judge stage produced no valid structured decision." }, null, 2)}\n`);
-		const judgedShortlist = selectCandidates(judgedDecision?.shortlist ?? []);
-		shortlist = judgedShortlist.length > 0 ? judgedShortlist : shortlist;
-		decisionPath = judgePath;
-	}
-  const finalPath = join(root, "shortlist.md");
-  const finalShortlist = await ctx.task("final-shortlist", {
-    prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath), context: "fresh",
-    reads: [decisionPath, ...shortlist], output: finalPath, 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; `final_path` is returned for callers that want the contents.
-  return { result: finalShortlist.text, 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.ts

@@ -1,31 +0,0 @@
-import { Type } from "typebox";
-import { workflow } from "../src/authoring/workflow.js";
-import { withSteeringPropagationContext } from "./steering-context.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.",
-  // 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: "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: "Compact reference to the final shortlist report artifact; read `final_path` for the full 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: async (ctx) => await runGenerateAndFilter(withSteeringPropagationContext(ctx)),
-});

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

@@ -1,64 +0,0 @@
-import { writeFile } from "node:fs/promises";
-import { join } from "node:path";
-import type { ReviewDecision, ReviewRecord } from "./goal-types.js";
-import {
-  consolidateFindingsBatch,
-  type ConsolidatedFinding,
-  type ReviewConvergenceSummary,
-} from "./review-convergence.js";
-import type { ReverifyAuditEntry, ReverifiableFinding } from "./goal-reverify.js";
-
-export function artifactSafeName(value: string): string {
-  const safe = value
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, "-")
-    .replace(/^-+|-+$/g, "");
-  return safe.length > 0 ? safe : "artifact";
-}
-
-function withoutTurn<T extends { readonly turn: number }>(value: T): Omit<T, "turn"> {
-  const copy = { ...value } as Omit<T, "turn"> & { turn?: number };
-  delete copy.turn;
-  return copy;
-}
-
-export async function writeReviewArtifact(
-  artifactDir: string,
-  reviewer: string,
-  decision: ReviewDecision,
-  rawText: string,
-  convergenceDecision: ReviewConvergenceSummary,
-): Promise<string> {
-  const artifactPath = join(
-    artifactDir,
-    `review-${artifactSafeName(reviewer)}.json`,
-  );
-  await writeFile(
-    artifactPath,
-    `${JSON.stringify({ reviewer, decision, convergence_decision: convergenceDecision, raw_text: rawText }, null, 2)}\n`,
-    { encoding: "utf8" },
-  );
-  return artifactPath;
-}
-
-export async function writeReviewRoundArtifact(
-  artifactDir: string,
-  reviews: readonly ReviewRecord[],
-  consolidatedFindings: readonly ConsolidatedFinding<ReverifiableFinding>[] = consolidateFindingsBatch(
-    reviews.map((review) => ({
-      reviewer: review.reviewer,
-      findings: review.findings,
-    })),
-  ),
-  reverification: readonly ReverifyAuditEntry<ReverifiableFinding>[] = [],
-): Promise<string> {
-  const artifactPath = join(artifactDir, "review-round-latest.json");
-  const visibleReviews = reviews.map(withoutTurn);
-  await writeFile(
-    artifactPath,
-    `${JSON.stringify({ reviews: visibleReviews, consolidated_findings: consolidatedFindings, reverification }, null, 2)}\n`,
-    { encoding: "utf8" },
-  );
-  return artifactPath;
-}
-

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

@@ -1,87 +0,0 @@
-/**
- * Convergence evidence is observational only: it never approves, never
- * terminates, never touches `stop_review_loop`, and feeds only
- * `needs_human`-class escalation text.
- */
-import type { UsageTotals } from "./verification-usage.js";
-import {
-	classify_trend,
-	DEFAULT_FALL_DELTA,
-	DEFAULT_RISE_DELTA,
-	type TrendResult,
-} from "./progress-scoring.js";
-import { VERIFICATION_SCALE } from "./verification-criteria.js";
-
-/**
- * `fractionProven` remains in its natural [0, 1] units. V7's hysteresis
- * thresholds span a proportional part of `VERIFICATION_SCALE`, so applying
- * that same proportion to the unit interval keeps the two series comparable
- * without hard-coding a fraction-specific magic number.
- */
-export const FRACTION_TREND_RISE_DELTA =
-	DEFAULT_RISE_DELTA / (VERIFICATION_SCALE.max - VERIFICATION_SCALE.min);
-export const FRACTION_TREND_FALL_DELTA =
-	DEFAULT_FALL_DELTA / (VERIFICATION_SCALE.max - VERIFICATION_SCALE.min);
-
-export type ConvergenceEntry = {
-	readonly unresolvedBlockingCount: number;
-	readonly meanFindingConfidence: number | null;
-	readonly fractionProven: number;
-	readonly demotions: number;
-	readonly usage: UsageTotals;
-};
-
-/** Purely shape one already-folded review round into a ledger entry. */
-export function record_convergence(round: {
-	readonly unresolvedBlockingCount: number;
-	readonly meanFindingConfidence: number | null;
-	readonly fractionProven: number;
-	readonly demotions: number;
-	readonly usage: UsageTotals;
-}): ConvergenceEntry {
-	return {
-		unresolvedBlockingCount: round.unresolvedBlockingCount,
-		meanFindingConfidence: round.meanFindingConfidence,
-		fractionProven: round.fractionProven,
-		demotions: round.demotions,
-		usage: round.usage,
-	};
-}
-
-export function classify_convergence(entries: readonly ConvergenceEntry[]): {
-	blocking: TrendResult;
-	proven: TrendResult;
-} {
-	return {
-		blocking: classify_trend(entries.map((entry) => entry.unresolvedBlockingCount)),
-		proven: classify_trend(entries.map((entry) => entry.fractionProven), {
-			riseDelta: FRACTION_TREND_RISE_DELTA,
-			fallDelta: FRACTION_TREND_FALL_DELTA,
-		}),
-	};
-}
-
-/**
- * A FALLING `unresolvedBlockingCount` (classified "regressing" on the raw
- * series) and a RISING `fractionProven` are the converging directions. A
- * rising blocking count is never suppressed because it is the worsening
- * direction on the axis the objective names first.
- */
-export function convergence_escalation_evidence(
-	entries: readonly ConvergenceEntry[],
-): readonly string[] {
-	if (entries.length === 0) return [];
-	const { blocking, proven } = classify_convergence(entries);
-	if (blocking.trend === "regressing" || (proven.trend === "rising" && blocking.trend !== "rising")) return [];
-
-	const latest = entries[entries.length - 1]?.meanFindingConfidence;
-	return [
-		`${entries.length} round${entries.length === 1 ? "" : "s"} recorded; no observed convergence: the blocking-count trend is ${blocking.trend}.`,
-		`Blocking-count trend: ${blocking.trend}; raw series: ${JSON.stringify(blocking.evidence.series)}.`,
-		`Fraction-proven trend: ${proven.trend}; raw series: ${JSON.stringify(proven.evidence.series)}.`,
-		latest === null
-			? "Latest mean finding confidence: no findings were filed."
-			: `Latest mean finding confidence: ${latest}.`,
-		"This is escalation EVIDENCE only; it never approves or terminates anything.",
-	];
-}

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

@@ -1,139 +0,0 @@
-import { randomUUID } from "node:crypto";
-import { readFile, rename, rm, writeFile } from "node:fs/promises";
-import { dirname, join } from "node:path";
-import { LEDGER_FILENAME, type GoalLedger, type GoalLifecycleEvent } from "./goal-types.js";
-
-const LEDGER_STATE_FILENAME = "goal-ledger-state.json";
-
-type ModelVisibleGoalLedger = Omit<
-  GoalLedger,
-  "turns" | "receipts" | "reviews" | "blockers" | "decisions" | "lifecycle"
-> & {
-  readonly receipts: ReadonlyArray<Omit<GoalLedger["receipts"][number], "turn">>;
-  readonly reviews: ReadonlyArray<Omit<GoalLedger["reviews"][number], "turn">>;
-  readonly blockers: ReadonlyArray<Omit<GoalLedger["blockers"][number], "turn">>;
-  readonly decisions: ReadonlyArray<Omit<GoalLedger["decisions"][number], "turn">>;
-  readonly lifecycle: ReadonlyArray<Omit<GoalLedger["lifecycle"][number], "turn">>;
-};
-
-function withoutTurn<T extends { readonly turn: number }>(value: T): Omit<T, "turn"> {
-  const copy = { ...value } as Omit<T, "turn"> & { turn?: number };
-  delete copy.turn;
-  return copy;
-}
-
-function modelVisibleLedger(ledger: GoalLedger): ModelVisibleGoalLedger {
-  return {
-    goal_id: ledger.goal_id,
-    objective: ledger.objective,
-    acceptance_criteria: ledger.acceptance_criteria,
-    status: ledger.status,
-    created_at: ledger.created_at,
-    updated_at: ledger.updated_at,
-    receipts: ledger.receipts.map(withoutTurn),
-    reviews: ledger.reviews.map(withoutTurn),
-    blockers: ledger.blockers.map(withoutTurn),
-    decisions: ledger.decisions.map(withoutTurn),
-    lifecycle: ledger.lifecycle.map(withoutTurn),
-    reverification: ledger.reverification ?? [],
-    convergence: ledger.convergence ?? [],
-  };
-}
-
-function goalLedgerStatePath(ledgerPath: string): string {
-  return join(dirname(ledgerPath), LEDGER_STATE_FILENAME);
-}
-
-export function appendLifecycleEvent(
-  ledger: GoalLedger,
-  event: GoalLifecycleEvent["event"],
-  summary: string,
-  turn = ledger.turns,
-): void {
-  ledger.lifecycle.push({
-    turn,
-    event,
-    status: ledger.status,
-    at: new Date().toISOString(),
-    summary,
-  });
-}
-
-/**
- * Restore only lossless authoritative state. A model-visible legacy ledger has
- * no turn fields, so treating it as fresh is safer than fabricating reducer state.
- *
- * A sidecar that cannot be parsed is treated as absent for the same reason: the
- * authoritative file is published by atomic rename below, so unparsable content
- * means a torn write from before that guarantee (or a foreign file). Starting
- * fresh loses recorded turns; throwing here would instead make the whole
- * continuation unable to start.
- */
-async function readExistingGoalLedger(ledgerPath: string): Promise<GoalLedger | undefined> {
-  let contents: string;
-  try {
-    contents = await readFile(goalLedgerStatePath(ledgerPath), "utf8");
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "ENOENT") return undefined;
-    throw error;
-  }
-  try {
-    return JSON.parse(contents) as GoalLedger;
-  } catch {
-    return undefined;
-  }
-}
-export async function createGoalLedger(
-  objective: string,
-  acceptanceCriteria: string,
-  artifactDir: string,
-): Promise<{ ledger: GoalLedger; ledgerPath: string; artifactDir: string }> {
-  const ledgerPath = join(artifactDir, LEDGER_FILENAME);
-  const existing = await readExistingGoalLedger(ledgerPath);
-  if (existing !== undefined) return { ledger: existing, ledgerPath, artifactDir };
-
-  const goalId = randomUUID();
-  const now = new Date().toISOString();
-  const ledger: GoalLedger = {
-    goal_id: goalId,
-    objective,
-    acceptance_criteria: acceptanceCriteria,
-    status: "active",
-    turns: 0,
-    created_at: now,
-    updated_at: now,
-    receipts: [],
-    reviews: [],
-    blockers: [],
-    decisions: [],
-    lifecycle: [],
-    reverification: [],
-    convergence: [],
-  };
-  appendLifecycleEvent(ledger, "created", "Goal created.", 0);
-  await writeGoalLedger(ledgerPath, ledger);
-  return { ledger, ledgerPath, artifactDir };
-}
-
-export async function writeGoalLedger(
-  ledgerPath: string,
-  ledger: GoalLedger,
-): Promise<void> {
-  ledger.updated_at = new Date().toISOString();
-  const visibleContents = `${JSON.stringify(modelVisibleLedger(ledger), null, 2)}\n`;
-  const stateContents = `${JSON.stringify(ledger, null, 2)}\n`;
-  const statePath = goalLedgerStatePath(ledgerPath);
-  // The sidecar is the authoritative resume state, so it is published by a
-  // complete same-directory write followed by an atomic rename. Overwriting it
-  // in place leaves a partial file readable when a write is interrupted, and
-  // the next continuation would then start from nothing.
-  const pendingStatePath = `${statePath}.${randomUUID()}.tmp`;
-  await writeFile(pendingStatePath, stateContents, { encoding: "utf8" });
-  try {
-    await rename(pendingStatePath, statePath);
-  } catch (error) {
-    await rm(pendingStatePath, { force: true });
-    throw error;
-  }
-  await writeFile(ledgerPath, visibleContents, { encoding: "utf8" });
-}

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

@@ -1,72 +0,0 @@
-import { reviewDecisionSchema } from "./goal-schemas.js";
-
-// Keep this model list identical to Ralph's orchestrator while preserving a
-// locally contained Goal configuration.
-export const orchestratorModelConfig = {
-    model: "anthropic/claude-opus-5:high",
-    fallbackModels: [
-      "github-copilot/claude-opus-5:high",
-      "openai-codex/gpt-5.6-sol:xhigh",
-      "github-copilot/gpt-5.6-sol:xhigh",
-      "openai/gpt-5.6-sol:xhigh",
-      "anthropic/claude-fable-5:high",
-      "github-copilot/claude-fable-5:high",
-      "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",
-      "anthropic/claude-opus-4-8:high",
-      "github-copilot/claude-opus-4.8:high",
-      "xai/grok-4.6:xhigh",
-      "github-copilot/grok-4.6:xhigh",
-      "zai/glm-5.3:high",
-      "zai-coding-cn/glm-5.3:high",
-      "openrouter/anthropic/claude-opus-5:high",
-      "openrouter/openai/gpt-5.6-sol:xhigh",
-      "openrouter/anthropic/claude-fable-5:high",
-      "openrouter/moonshotai/kimi-k3:max",
-      "openrouter/sakana/fugu-ultra:high",
-      "openrouter/openai/gpt-5.5:xhigh",
-      "openrouter/anthropic/claude-opus-4-8:high",
-      "openrouter/x-ai/grok-4.6",
-    ],
-    excludedTools: ["ask_user_question"],
-};
-
-// Keep Goal's reviewer configuration independent so GPT-5.6 precedes Kimi K3
-// within both the leading direct-provider group and the OpenRouter group.
-export const reviewerModelConfig = {
-    model: "anthropic/claude-opus-5:high",
-    fallbackModels: [
-      "github-copilot/claude-opus-5:high",
-      "anthropic/claude-fable-5:high",
-      "github-copilot/claude-fable-5:high",
-      "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",
-      "anthropic/claude-opus-4-8:high",
-      "github-copilot/claude-opus-4.8:high",
-      "xai/grok-4.6:xhigh",
-      "github-copilot/grok-4.6:xhigh",
-      "zai/glm-5.3:high",
-      "zai-coding-cn/glm-5.3:high",
-      "openrouter/anthropic/claude-opus-5:high",
-      "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",
-      "openrouter/x-ai/grok-4.6",
-    ],
-    excludedTools: ["ask_user_question"],
-    schema: reviewDecisionSchema,
-};