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

package/dist/builtin/workflows/builtin/chunk-29wrp38a.js

@@ -0,0 +1,199 @@
+import {
+  stableArtifactRoot
+} from "./chunk-wpckd35c.js";
+import {
+  workflow
+} from "./chunk-bfkmzv9h.js";
+import {
+  withSteeringPropagationContext
+} from "./chunk-0x6e303p.js";
+
+// dist/builtin/workflows/builtin/fan-out-and-synthesize.ts
+import { Type as Type2 } from "typebox";
+
+// dist/builtin/workflows/builtin/fan-out-and-synthesize-runner.ts
+import { writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { Type } from "typebox";
+
+// dist/builtin/workflows/builtin/fan-out-and-synthesize-prompts.ts
+var 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.";
+var 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.";
+function partitionPrompt(prompt, maxBranches) {
+  return `<role>
+You partition work into independent evidence-producing branches.
+</role>
+
+<success_criteria>
+The plan has between 1 and ${maxBranches} non-overlapping partitions whose labels and objectives are self-contained.
+</success_criteria>
+
+<decision_rules>
+Split 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.
+</decision_rules>
+
+<output_format>
+Return only the structured result requested by the schema, with concise labels and self-contained objectives.
+</output_format>
+
+<objective>
+Partition this task: ${prompt}
+</objective>`;
+}
+function branchPrompt(input) {
+  return `<overall_task>
+${input.prompt}
+</overall_task>
+
+<role>
+You own one independent branch of a larger task. Your artifact lets a synthesizer audit this branch without its conversation context.
+</role>
+
+<success_criteria>
+Cite concrete files, sources, commands, or other observable evidence, distinguish findings from uncertainty, and produce a standalone artifact.
+</success_criteria>
+
+<stop_rules>
+Stop when the branch objective is supported or when unresolved uncertainty and the evidence needed to resolve it are explicit.
+</stop_rules>
+
+<output_format>
+Markdown with Scope, Findings, Evidence, Conflicts or uncertainty, and Recommendations headings. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<branch>
+Investigate only ${input.label}: ${input.objective}
+</branch>`;
+}
+function synthesisPrompt(prompt, manifestPath) {
+  return `<artifact_contract>
+Read ${manifestPath} first, then read every branch artifact listed there. Do not omit a completed branch and do not assume access to branch conversations.
+</artifact_contract>
+
+<role>
+You synthesize independent branch artifacts at a strict barrier. The final reader needs conclusions traceable to branch evidence rather than majority vote.
+</role>
+
+<success_criteria>
+Deduplicate overlapping findings, explicitly resolve or preserve conflicting claims, retain material uncertainty, and cite branch labels and artifact paths for important conclusions.
+</success_criteria>
+
+<stop_rules>
+Stop after every completed branch is accounted for and each material conflict is resolved or preserved as uncertainty.
+</stop_rules>
+
+<output_format>
+Markdown with Executive synthesis, Consolidated findings, Conflicts and resolutions, Evidence index, and Remaining uncertainty headings. ${READABLE_REPORT}
+${GROUNDED_REPORTING}
+</output_format>
+
+<objective>
+Produce the final answer for: ${prompt}
+</objective>`;
+}
+
+// dist/builtin/workflows/builtin/fan-out-and-synthesize-runner.ts
+var 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 });
+function safeName(value, index) {
+  const normalized = value.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+  return `${String(index + 1).padStart(2, "0")}-${normalized || "branch"}`;
+}
+function parsedPartitions(value, limit, prompt) {
+  if (typeof value !== "object" || value === null || !("partitions" in value) || !Array.isArray(value.partitions)) {
+    return [{ label: "whole-task", objective: prompt }];
+  }
+  const result = [];
+  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 }];
+}
+async function runFanOutAndSynthesize(ctx) {
+  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 = 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: synthesis.text,
+    partitions: partitions.map((partition) => partition.label),
+    branch_artifact_paths: branchPaths,
+    synthesis_path: synthesisPath,
+    artifact_dir: artifactDir,
+    manifest_path: manifestPath
+  };
+}
+
+// dist/builtin/workflows/builtin/fan-out-and-synthesize.ts
+var fan_out_and_synthesize_default = workflow({
+  name: "fan-out-and-synthesize",
+  description: "Partition a task, run bounded independent artifact branches, then synthesize all evidence at an explicit barrier.",
+  heartbeatIntervalMinutes: 15,
+  inputs: {
+    prompt: Type2.String({ description: "Task to partition, investigate, and synthesize." }),
+    max_branches: Type2.Integer({
+      minimum: 1,
+      maximum: 12,
+      default: 4,
+      description: "Maximum number of independent partitions produced and executed."
+    }),
+    max_concurrency: Type2.Integer({
+      minimum: 1,
+      maximum: 12,
+      default: 4,
+      description: "Maximum number of branch agents running concurrently."
+    })
+  },
+  outputs: {
+    result: Type2.String({ description: "Compact reference to the evidence-citing synthesis artifact; read `synthesis_path` for the full report." }),
+    partitions: Type2.Array(Type2.String(), { description: "Ordered labels for executed partitions." }),
+    branch_artifact_paths: Type2.Array(Type2.String(), { description: "Ordered branch artifact paths consumed by synthesis." }),
+    synthesis_path: Type2.String({ description: "Final synthesis artifact path." }),
+    artifact_dir: Type2.String({ description: "Per-run artifact directory." }),
+    manifest_path: Type2.String({ description: "Barrier manifest linking partitions to branch artifacts." })
+  },
+  run: async (ctx) => await runFanOutAndSynthesize(withSteeringPropagationContext(ctx))
+});
+
+export { fan_out_and_synthesize_default };