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

package/dist/builtin/workflows/builtin/{shared-prompts.ts → chunk-0x6e303p.js}

@@ -1,121 +1,96 @@
-// Builtin prompts use the same public `keepContext` helper workflow authors do, so the
-// protection semantics cannot drift between builtin and user-authored workflows.
-import { keepContext } from "../src/authoring/keep-context.js";
-
-export { keepContext };
+// dist/builtin/workflows/src/authoring/keep-context.ts
+var KEEP_CONTEXT_OPEN_TAG = "<keepContext>";
+var KEEP_CONTEXT_CLOSE_TAG = "</keepContext>";
+function keepContext(text) {
+  const trimmed = text.trim();
+  if (trimmed.startsWith(KEEP_CONTEXT_OPEN_TAG) && trimmed.endsWith(KEEP_CONTEXT_CLOSE_TAG))
+    return trimmed;
+  return `${KEEP_CONTEXT_OPEN_TAG}
+${trimmed}
+${KEEP_CONTEXT_CLOSE_TAG}`;
+}
 
-/**
- * Steering propagation is a whole-repository pattern, not a per-workflow
- * option: every builtin stage prompt carries STEERING_PROPAGATION_CONTRACT
- * through `withSteeringPropagation`, and `test/unit/builtin-workflow-steering-propagation.test.ts`
- * fails when a stage prompt omits it.
- *
- * A run's contract can change mid-flight, but only the user may change it. A
- * steered amendment that stays inside one stage's session is invisible to every
- * later stage, so the implementer builds to the amended contract while reviewers
- * still score the launch contract and mark the added work as unrequested scope.
- * Each stage therefore restates the amendments it received in its own handoff.
- */
-export const STEERING_PROPAGATION_CONTRACT = [
+// dist/builtin/workflows/builtin/shared-prompts.ts
+var PENDING_STAGE_DELIVERY_GUIDANCE_LINES = [
+  "Send material updates through Intercom to every affected workflow stage, including stages that have not started.",
+  "Atomic queues messages for known pending stages addressed as `<runId>:<stageKey>` and delivers them when their sessions initialize."
+];
+var PENDING_STAGE_DELIVERY_GUIDANCE = PENDING_STAGE_DELIVERY_GUIDANCE_LINES.join(`
+`);
+var STEERING_PROPAGATION_CONTRACT = [
   "Steering propagation contract:",
   "- Mid-run user messages (steering, follow-ups, resume text) are authoritative and may amend this run's objective or acceptance criteria. Adopt an amendment as required behavior from the moment you receive it.",
   "- An amendment that stays in your session is lost. Restate every objective-relevant steering message in your final report or handoff artifact, verbatim when short, under an explicit `Contract amendments received` heading.",
   "- Keep user-authored amendments visibly separate from your own observations, so later stages can tell a required clause from an agent proposal.",
   "- Treat amendments inherited from an upstream stage as contract clauses. Cover them in acceptance and traceability work; never classify inherited user amendments as beyond_objective, unrequested scope, or speculative expansion.",
   "- If an amendment is ambiguous, or conflicts with the launch contract or another amendment, resolve it before implementing: ask through `intercom` when a supervisor or originating stage is reachable, otherwise state the conflict in your report and implement the narrowest reading consistent with the launch contract.",
-  "- Propagate nothing else this way. Guidance about how to work, tool preferences, and your own improvement ideas are not amendments; those follow the scope discipline contract.",
-].join("\n");
-
-/**
- * Add the steering propagation contract to a stage prompt. Builtin runners wrap
- * every `ctx.task` / `ctx.parallel` / `ctx.chain` prompt with this so the pattern
- * cannot be forgotten when a stage is added.
- *
- * Stage prompts in this package deliberately end with their `<instruction>`
- * section, which carries the strongest positional weight. The contract is
- * inserted immediately before that closing section rather than after it, so a
- * stage's final words remain its instruction.
- *
- * The contract is `keepContext`-protected because only the user may amend a run's contract,
- * and an amendment reaches later stages solely through this restatement duty. Compacted away,
- * the run silently reverts to the launch contract while the implementer builds to the amended
- * one — the exact split this pattern exists to prevent.
- */
-export function withSteeringPropagation(prompt: string): string {
-  if (prompt.includes("<steering_propagation>")) return prompt;
-  const tagged = `<steering_propagation>\n${keepContext(STEERING_PROPAGATION_CONTRACT)}\n</steering_propagation>`;
-  const instructionAt = prompt.lastIndexOf("\n\n<instruction>");
-  if (instructionAt === -1) return `${prompt}\n\n${tagged}`;
-  return `${prompt.slice(0, instructionAt)}\n\n${tagged}${prompt.slice(instructionAt)}`;
+  ...PENDING_STAGE_DELIVERY_GUIDANCE_LINES.map((line) => `- ${line}`),
+  "- Propagate nothing else this way. Guidance about how to work, tool preferences, and your own improvement ideas are not amendments; those follow the scope discipline contract."
+].join(`
+`);
+function withSteeringPropagation(prompt) {
+  if (prompt.includes("<steering_propagation>"))
+    return prompt;
+  const tagged = `<steering_propagation>
+${keepContext(STEERING_PROPAGATION_CONTRACT)}
+</steering_propagation>`;
+  const instructionAt = prompt.lastIndexOf(`
+
+<instruction>`);
+  if (instructionAt === -1)
+    return `${prompt}
+
+${tagged}`;
+  return `${prompt.slice(0, instructionAt)}
+
+${tagged}${prompt.slice(instructionAt)}`;
 }
-
-export const REVIEWER_CALIBRATION_RULES = [
+var REVIEWER_CALIBRATION_RULES = [
   "Trust observed output over the agent's narration.",
-  'Agent declarations of success ("done", "all tests pass") are ZERO evidence on their own.',
-].join("\n");
-
-export const WORKER_PREFLIGHT_CONTRACT = [
+  'Agent declarations of success ("done", "all tests pass") are ZERO evidence on their own.'
+].join(`
+`);
+var WORKER_PREFLIGHT_CONTRACT = [
   "Before implementation delegation, infer the checkout's language, framework, build system, and setup requirements from repository evidence rather than ecosystem assumptions.",
   "Inspect source layout, setup docs, manifests, lockfiles, toolchain and codegen files, CI/workflow configuration, scripts, and generated-artifact conventions for missing dependencies, generated files, toolchains, submodules, or other initialization artifacts.",
   "When setup is missing, run or delegate the documented setup before implementation; missing initialization is setup work, not a user handoff or implementation failure.",
-  "If requirements are unclear, delegate focused discovery rather than guessing. If evidence-based discovery and setup attempts remain blocked, report the commands tried and exact evidence needed to continue.",
-].join("\n");
-
-export const E2E_VERIFICATION_GUIDANCE = [
+  "If requirements are unclear, delegate focused discovery rather than guessing. If evidence-based discovery and setup attempts remain blocked, report the commands tried and exact evidence needed to continue."
+].join(`
+`);
+var E2E_VERIFICATION_GUIDANCE = [
   "Verify correctness end-to-end whenever practical for user-visible behavior; an executable scenario is stronger proof than code inspection, unit tests, or stage summaries alone.",
-  "For web or frontend flows, including frontend changes whose correctness depends on backend/API behavior, use the playwright-cli skill or delegate with `skill: \"playwright-cli\"`; capture snapshot, screenshot, DOM, or network evidence suited to the objective.",
-  "For TUI/terminal flows, use the tmux skill or delegate with `skill: \"tmux\"` to exercise the scenario and capture pane output.",
+  'For web or frontend flows, including frontend changes whose correctness depends on backend/API behavior, use the playwright-cli skill or delegate with `skill: "playwright-cli"`; capture snapshot, screenshot, DOM, or network evidence suited to the objective.',
+  'For TUI/terminal flows, use the tmux skill or delegate with `skill: "tmux"` to exercise the scenario and capture pane output.',
   "Assume credentials, auth, and environment access for playwright-cli/tmux E2E exist until a concrete attempt proves otherwise. Before calling E2E impractical, check existing sessions, config, env vars, and CLI auth, then attempt the launch or flow.",
-  "If E2E remains impractical, record the commands attempted, observed failure output, smallest missing prerequisite, and narrower validation run; an unattempted assumption is never valid grounds to skip.",
-].join("\n");
-
-/**
- * Code-quality verification is the lint/format/metrics/smells counterpart to
- * E2E_VERIFICATION_GUIDANCE, and is included at the same call sites so goal and
- * ralph stages — implementation, orchestrator, and reviewer alike — receive it.
- */
-export const CODE_QUALITY_VERIFICATION_GUIDANCE = [
-  "For code-quality verification — linting, auto-formatting, complexity and duplication metrics, and code smells — use the qlty skill or delegate with `skill: \"qlty\"`; it drives one CLI across the repository's languages instead of ad-hoc per-tool linter invocations.",
+  "If E2E remains impractical, record the commands attempted, observed failure output, smallest missing prerequisite, and narrower validation run; an unattempted assumption is never valid grounds to skip."
+].join(`
+`);
+var CODE_QUALITY_VERIFICATION_GUIDANCE = [
+  'For code-quality verification — linting, auto-formatting, complexity and duplication metrics, and code smells — use the qlty skill or delegate with `skill: "qlty"`; it drives one CLI across the repository\'s languages instead of ad-hoc per-tool linter invocations.',
   "Weight this higher when the objective asks for verifiers or high code quality: enable the qlty plugins that fit this codebase, then run the check/format/metrics/smells loop and act on what it reports.",
-  "Repository-defined checks in AGENTS.md/CLAUDE.md, package scripts, and CI stay authoritative; qlty supplements them rather than replacing them, and its findings count as evidence only with the command and observed output recorded.",
-].join("\n");
-
-/**
- * Repositories carry behavioral norms written docs never state — commit
- * signing, message style, changelog discipline, review etiquette — and they
- * are inferable from history. Included at the same goal/ralph call sites as
- * the E2E and code-quality guidance so implementers match inferred
- * conventions and reviewers check delivered work against them.
- */
-export const REPO_INTENT_MINING_GUIDANCE = [
+  "Repository-defined checks in AGENTS.md/CLAUDE.md, package scripts, and CI stay authoritative; qlty supplements them rather than replacing them, and its findings count as evidence only with the command and observed output recorded."
+].join(`
+`);
+var REPO_INTENT_MINING_GUIDANCE = [
   "Infer maintainer and requesting-user intent from repository behavior, not only written docs: mine git history (`git log`, `git log --show-signature`), merged PRs, issues and their comments, review comments, commit subjects and trailers, and CI/branch-protection config for unwritten conventions.",
   "Read for commit-signing habits, commit-message style and issue linking, changelog discipline, PR size and stacking norms, review etiquette, formatting and lint norms, and branch naming. Prefer the dominant, recent, intentional pattern over accidental drift; when signals conflict, the requesting user's own commits, PRs, and comments weigh highest — different users of one repository keep different preferences.",
   "Match inferred conventions in delivered work (for example, sign commits when the surrounding history is signed rather than skipping signing because no doc required it); in review, report deviations as convention findings backed by the mined evidence.",
-  "Behavioral evidence fills gaps where the contract is silent; it never overrides the literal objective, acceptance criteria, or explicit AGENTS.md/CLAUDE.md guidance, and it does not license new contract requirements.",
-].join("\n");
-
-export function renderE2eQaVideoReviewGuidance(
-  knownVideoPath?: string,
-): string {
-  const target = knownVideoPath === undefined || knownVideoPath.length === 0
-    ? "Look for QA E2E video references in the goal ledger, implementation receipt, implementation notes, orchestrator report, or other review context artifacts."
-    : `Known QA E2E video path for this run: ${knownVideoPath}`;
+  "Behavioral evidence fills gaps where the contract is silent; it never overrides the literal objective, acceptance criteria, or explicit AGENTS.md/CLAUDE.md guidance, and it does not license new contract requirements."
+].join(`
+`);
+function renderE2eQaVideoReviewGuidance(knownVideoPath) {
+  const target = knownVideoPath === undefined || knownVideoPath.length === 0 ? "Look for QA E2E video references in the goal ledger, implementation receipt, implementation notes, orchestrator report, or other review context artifacts." : `Known QA E2E video path for this run: ${knownVideoPath}`;
   return [
     target,
     "Inspect the actual video before approving any claimed QA E2E evidence; a path, filename, transcript summary, or stage claim is not proof.",
     "Use available video/file tooling such as `fetch_content` on the local video path with an objective-focused prompt, or inspect representative frames and metadata when full analysis is unavailable.",
     "Confirm the video reflects the current repository/application state, exercises the objective-relevant user path through its expected result, and does not hide errors, stale UI, broken loading states, or skipped steps.",
     "For UI-applicable or full-stack changes, missing, stale, unreadable, or inconclusive video is missing E2E evidence unless the receipt or notes explain why video does not apply and provide adequate alternate end-to-end proof.",
-    "Treat E2E skipped for assumed-missing credentials, auth, or environment access as missing evidence unless the implementation agent checked that state, attempted the launch or flow, and reported exact commands plus observed failure output.",
-  ].join("\n");
+    "Treat E2E skipped for assumed-missing credentials, auth, or environment access as missing evidence unless the implementation agent checked that state, attempted the launch or flow, and reported exact commands plus observed failure output."
+  ].join(`
+`);
 }
-
-/**
- * `keepContext`-protected: this is the run's immutable contract and its central prohibition
- * ("You may never widen the contract yourself"). A prohibition deleted from context reads as
- * permission, so losing it turns scope creep into apparently sanctioned work.
- */
-export const LITERAL_OBJECTIVE_CONTRACT = keepContext([
+var LITERAL_OBJECTIVE_CONTRACT = keepContext([
   "Literal objective contract:",
   "- The objective and acceptance criteria are the sole literal source of required behavior; the run objective must not contradict them.",
   "- Only the user may change the contract. A mid-run user message — steering, a follow-up, or resume text — is authoritative: adopt it as required behavior from that point on, and carry it forward under the steering propagation contract. You may never widen the contract yourself; an improvement you thought of is deferred work, not a new criterion.",
@@ -123,40 +98,36 @@ export const LITERAL_OBJECTIVE_CONTRACT = keepContext([
   "- For an enumerated error, message, or rejection, prefer the widest plausible trigger over silently reinterpreting ambiguous nearby input. Narrow it only when the contract or pre-existing required tests explicitly require acceptance.",
   "- That loud-error preference applies only to enumerated errors. Otherwise accept permissively: do not invent behavior, restrictions, validation errors, required fields, uniqueness/format constraints, or follow-up requirements.",
   "- Produce named types, shapes, and formats exactly; do not substitute proxies, frozen collections, tuples-for-lists, or wrappers unless required because consumers may check identity.",
-  "- Where behavior is unspecified, preserve input verbatim rather than normalizing, deduplicating, reordering, or rewriting it.",
-].join("\n"));
-
-export const REVIEWER_SPEC_VS_OBJECTIVE_GUARD =
-  "External spec/standard conformance alone does not make a wide trigger for an enumerated error defective; classify that spec-vs-objective tension as beyond_objective, not blocking.";
-
-export const REVIEWER_OVERIMPLEMENTATION_GUARD =
-  "Treat unrequired validation errors, required fields, uniqueness/format constraints, immutability wrappers, and normalization as required_by_objective defects when they reject permitted inputs or change permitted shapes. Probe at least one contract-permitted input absent from implementation-authored tests.";
-
-export const ACCEPTANCE_MATRIX_CONTRACT = [
+  "- Where behavior is unspecified, preserve input verbatim rather than normalizing, deduplicating, reordering, or rewriting it."
+].join(`
+`));
+var REVIEWER_SPEC_VS_OBJECTIVE_GUARD = "External spec/standard conformance alone does not make a wide trigger for an enumerated error defective; classify that spec-vs-objective tension as beyond_objective, not blocking.";
+var REVIEWER_OVERIMPLEMENTATION_GUARD = "Treat unrequired validation errors, required fields, uniqueness/format constraints, immutability wrappers, and normalization as required_by_objective defects when they reject permitted inputs or change permitted shapes. Probe at least one contract-permitted input absent from implementation-authored tests.";
+var ACCEPTANCE_MATRIX_CONTRACT = [
   "Acceptance matrix:",
   "- Derive one row per explicit objective/criteria clause, requirement, named artifact, command, gate, invariant, deliverable, and literal example; map each to a current-checkout command, test, scenario, artifact inspection, or state assertion. Check literal examples character-for-character.",
   "- Record it in the first receipt/implementation notes, keep it current, map completion claims to current evidence, and neither add out-of-contract rows nor omit inconvenient ones.",
   "- Include constrained interface decisions: exact return/field identity, required versus optional fields, duplicate handling, ordering, and raw versus normalized text; when open, record the permissive/preserving choice.",
-  "- For stateful work, enumerate states, legal transitions, cross-state invariants, and handling of illegal transitions/unexpected inputs; tie relevant rows to transition and invariant checks, not only happy-path end states.",
-].join("\n");
-
-export const CONTRACT_FIDELITY_AUDIT = [
+  "- For stateful work, enumerate states, legal transitions, cross-state invariants, and handling of illegal transitions/unexpected inputs; tie relevant rows to transition and invariant checks, not only happy-path end states."
+].join(`
+`);
+var CONTRACT_FIDELITY_AUDIT = [
   "Contract-fidelity risk classes:",
   "- Select only classes supported by the literal contract and repository: exact public API/type identity; positive and negative build tags/features/configuration variants; schemas/generated artifacts and omitted/zero-value fields; states/transitions/invariants; configurable paths, working directories, precedence, and caller-controlled state; low-level APIs across feature flags; permitted omitted, empty, zero, duplicate, aliased, ordered, unusual, or verbatim-text inputs; and unenumerated errors.",
-  "- Before claiming readiness, probe each applicable class against the current checkout. Fix divergence or record its evidence-based justification in the receipt/notes; do not manufacture requirements outside the literal contract.",
-].join("\n");
-
-export const REVIEWER_INTERCOM_COORDINATION_PROTOCOL = [
+  "- Before claiming readiness, probe each applicable class against the current checkout. Fix divergence or record its evidence-based justification in the receipt/notes; do not manufacture requirements outside the literal contract."
+].join(`
+`);
+var REVIEWER_INTERCOM_COORDINATION_PROTOCOL = [
   "Concurrent reviewer coordination (constructive quorum):",
   "- At review start, use Intercom to discover sibling reviewers and share validation plans and check ownership.",
   "- Claim, serialize, announce, and release expensive or conflicting shared-checkout/environment work such as suites, builds, package operations, browser/E2E sessions, migrations, and generated-artifact steps; share reusable command evidence.",
   "- First, inspect independently and form a preliminary assessment before reading or relying on sibling findings or verdicts. After the exchange, inspect independently and return your own verdict rather than copying or deferring to sibling conclusions.",
   "- Then run exactly one bounded evidence-exchange round over Intercom: share your preliminary verdict, concise findings, and evidence; challenge blocking findings, surface defects a sibling missed, and correct objective/acceptance-criteria misreadings. Do not start a second round or continue substantive discussion.",
   "- Verdicts change only through concrete evidence, never through deference to a sibling's approval or rejection; inspect shared evidence yourself before deciding.",
-  "- In `overall_explanation`, record whether deliberation changed your preliminary verdict and, if it did, which concrete evidence caused the change. If it did not, say so; return your own structured decision even when dissent remains.",
-].join("\n");
-
-export const REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT = [
+  "- In `overall_explanation`, record whether deliberation changed your preliminary verdict and, if it did, which concrete evidence caused the change. If it did not, say so; return your own structured decision even when dissent remains."
+].join(`
+`);
+var REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT = [
   "Independent verification:",
   "- Before reading receipts, implementation-authored tests, or prior reviews, derive per-clause observable checks from the literal objective/criteria, including supported boundary, edge, negative, invalid, permitted-input, exact type/shape/text, and state-transition probes.",
   CONTRACT_FIDELITY_AUDIT,
@@ -164,60 +135,68 @@ export const REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT = [
   "- Implementation-authored tests, snapshots, and receipts corroborate but never replace independently derived checks; exact API, build, or schema clauses require the applicable independent compile, type, build-variant, or schema probe.",
   "- A missing applicable compile/type/build/schema probe remains missing in requirements_traceability; explain it, add an objective-aligned finding when materially deficient, and set stop_review_loop=false.",
   "- For any missing, blocked, or failed material probe, record its command/scenario and observed result or limitation in overall_explanation and requirements_traceability, use the remaining-verification or finding fields, and set stop_review_loop=false. If tools or dependencies still prevent necessary verification after reasonable recovery, populate reviewer_error.",
-  "- Before stop_review_loop=true, require overall_correctness to be patch is correct, every objective-relevant implementation and validation requirements_traceability entry proven, no blocking objective-aligned finding, direct evidence or a clear not-applicable justification for each applicable risk, and reviewer_error null or omitted. Otherwise set stop_review_loop=false and report the gap consistently.",
-].join("\n");
-
-export const REGRESSION_EVIDENCE_CONTRACT = [
+  "- Before stop_review_loop=true, require overall_correctness to be patch is correct, every objective-relevant implementation and validation requirements_traceability entry proven, no blocking objective-aligned finding, direct evidence or a clear not-applicable justification for each applicable risk, and reviewer_error null or omitted. Otherwise set stop_review_loop=false and report the gap consistently."
+].join(`
+`);
+var REGRESSION_EVIDENCE_CONTRACT = [
   "Durable regression evidence:",
   "- A reproduced defect is fixed only when a focused test or repeatable check covers the failing scenario and passes after the fix (and fails before it or demonstrably exercises it). Persist it in the test suite where norms allow; otherwise record an exact rerunnable command and observed output in the receipt/notes.",
-  "- Keep a reproduced finding unresolved when its fix has only a one-off manual check.",
-].join("\n");
-
-export const FINDINGS_CONSOLIDATION_CONTRACT = [
+  "- Keep a reproduced finding unresolved when its fix has only a one-off manual check."
+].join(`
+`);
+var FINDINGS_CONSOLIDATION_CONTRACT = [
   "Treat the latest review round as one consolidated batch: read all blocking findings, group shared root causes, and repair the full batch with validation and durable regression evidence in this turn.",
-  "Defer only a genuinely blocked or contract-contradicting finding, recording the reason in the receipt.",
-].join("\n");
-
-/**
- * `keepContext`-protected: every clause here is a prohibition, and prohibitions are the class
- * compaction erodes first — they are terse, stated once, and low-density next to the objective
- * they bound. Losing this reads as license to keep going.
- */
-export const SCOPE_DISCIPLINE_CONTRACT = keepContext([
+  "Defer only a genuinely blocked or contract-contradicting finding, recording the reason in the receipt."
+].join(`
+`);
+var SCOPE_DISCIPLINE_CONTRACT = keepContext([
   "Scope discipline:",
   "- Before writing code, state the goal in one sentence and list the acceptance criteria. That list is the contract. Freeze it.",
-  "- Done means the contract, not \"good.\" When all criteria pass, stop. Polish, refactors, and \"while I'm here\" fixes are new work, not this work.",
+  `- Done means the contract, not "good." When all criteria pass, stop. Polish, refactors, and "while I'm here" fixes are new work, not this work.`,
   "- Every addition must trace to a criterion. If you cannot point at the criterion a change serves, do not make it. Log it instead.",
   "- Keep a deferred list, not a growing diff. When you notice a bug, smell, or missing feature outside the contract, write one line in a deferred note and move on. Surface it at the end.",
   "- Distinguish blockers from improvements. Change scope only if a criterion is impossible or wrong as written — and say so explicitly before proceeding; never silently absorb the work.",
-  "- Watch for the tells. \"It would be cleaner if...\", \"we should also...\", \"this really ought to...\" mean you are about to move the goalpost. Stop and check the contract.",
+  '- Watch for the tells. "It would be cleaner if...", "we should also...", "this really ought to..." mean you are about to move the goalpost. Stop and check the contract.',
   "- Prefer the smallest diff that satisfies the contract: fewer files touched, fewer abstractions introduced, no speculative generality for futures nobody asked for.",
-  "- Report three things at the end: what the contract was, evidence each criterion passes, and the deferred list. Scope changes belong in the report, never in the diff.",
-].join("\n"));
-
-export const EVIDENCE_CLOSURE_POLICY = [
+  "- Report three things at the end: what the contract was, evidence each criterion passes, and the deferred list. Scope changes belong in the report, never in the diff."
+].join(`
+`));
+var EVIDENCE_CLOSURE_POLICY = [
   "Convergence flag (stop_review_loop):",
   "- stop_review_loop is the single authoritative convergence signal; the harness trusts it without recomputing approval from findings, priorities, or requirements_traceability.",
   "- Derive stop_review_loop=false while any objective-relevant blocking work remains: a P0/P1/P2 finding, a required_by_objective finding at any priority including P3, or an unproven implementation/validation requirement.",
   "- Derive stop_review_loop=true when independent verification proves implementation and validation and only non-blocking items remain: consistent_with_objective P3 items, beyond_objective/contradicts_objective observations, an authorized post-approval PR/MR/review action, or reviewer quorum. Never hold it false for those items.",
-  "- If the bounded loop ends first, preserve unresolved findings and remaining work for a human rather than relabeling them.",
-].join("\n");
-
-/**
- * `keepContext`-protected: this binds the stage to a specific checkout, and a checkout is
- * exactly the kind of identifier a stage must not lose. Compacted away during a long run, an
- * agent hitting a lock or dirty state invents a second worktree and the delivered delta lands
- * somewhere the reviewers never look. It is two lines, so protection costs almost nothing.
- */
-export const WORKTREE_DISCIPLINE_CONTRACT = keepContext([
+  "- If the bounded loop ends first, preserve unresolved findings and remaining work for a human rather than relabeling them."
+].join(`
+`);
+var WORKTREE_DISCIPLINE_CONTRACT = keepContext([
   "Work in the workflow-designated checkout. Do not create another worktree, clone, or repository copy unless the task requests it; conflicts, locks, dirty state, and failed commands do not authorize one.",
-  "Bring required work found elsewhere into this checkout by applying, cherry-picking, or replaying it before continuing.",
-].join("\n"));
-
-export const REVIEW_CODE_DELTA_CONTRACT = [
+  "Bring required work found elsewhere into this checkout by applying, cherry-picking, or replaying it before continuing."
+].join(`
+`));
+var REVIEW_CODE_DELTA_CONTRACT = [
   "Code delta integrity:",
   "- Inspect the delivered checkout with version-control tooling (for git: `git worktree list`, `git status --short`, baseline diff, staged diff, and untracked files) and prove an objective-related delta exists before trusting receipts.",
   "- If summaries claim implementation but the checkout lacks it, return a blocking [P0] required_by_objective finding and require the work to be brought here. Never set stop_review_loop=true for an empty or unrelated implementation delta.",
   "- Unless the objective forbids committing, uncommitted claimed-ready work remains work: require a commit or intentional discard so delivery is durable.",
-  "- Treat modification, rename, or deletion of pre-existing tests or test functions as a finding requiring literal-contract justification; validating existing tests means running, not editing, them.",
-].join("\n");
+  "- Treat modification, rename, or deletion of pre-existing tests or test functions as a finding requiring literal-contract justification; validating existing tests means running, not editing, them."
+].join(`
+`);
+
+// dist/builtin/workflows/builtin/steering-context.ts
+function withPromptContract(options) {
+  return options.prompt === undefined ? options : { ...options, prompt: withSteeringPropagation(options.prompt) };
+}
+function withStepContract(step) {
+  const withPrompt = step.prompt === undefined ? step : { ...step, prompt: withSteeringPropagation(step.prompt) };
+  return withPrompt.task === undefined ? withPrompt : { ...withPrompt, task: withSteeringPropagation(withPrompt.task) };
+}
+function withSteeringPropagationContext(ctx) {
+  const wrapped = Object.create(ctx);
+  wrapped.task = (name, options) => ctx.task(name, withPromptContract(options));
+  wrapped.chain = (steps, options) => ctx.chain(steps.map(withStepContract), options);
+  wrapped.parallel = (steps, options) => ctx.parallel(steps.map(withStepContract), options);
+  return wrapped;
+}
+
+export { keepContext, REVIEWER_CALIBRATION_RULES, WORKER_PREFLIGHT_CONTRACT, E2E_VERIFICATION_GUIDANCE, CODE_QUALITY_VERIFICATION_GUIDANCE, REPO_INTENT_MINING_GUIDANCE, renderE2eQaVideoReviewGuidance, LITERAL_OBJECTIVE_CONTRACT, REVIEWER_SPEC_VS_OBJECTIVE_GUARD, REVIEWER_OVERIMPLEMENTATION_GUARD, ACCEPTANCE_MATRIX_CONTRACT, CONTRACT_FIDELITY_AUDIT, REVIEWER_INTERCOM_COORDINATION_PROTOCOL, REVIEWER_INDEPENDENT_VERIFICATION_CONTRACT, REGRESSION_EVIDENCE_CONTRACT, FINDINGS_CONSOLIDATION_CONTRACT, SCOPE_DISCIPLINE_CONTRACT, EVIDENCE_CLOSURE_POLICY, WORKTREE_DISCIPLINE_CONTRACT, REVIEW_CODE_DELTA_CONTRACT, withSteeringPropagationContext };

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