@bastani/atomic 0.9.11-alpha.5 → 0.9.11-alpha.7

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

@@ -1,15 +1,18 @@
+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 renderGeneratorPrompt(task: string, ordinal: number): string {
-  return `<role>\nYou independently generate candidate ${ordinal}; do not imitate or assume other candidates.\n</role>\n\n<objective>\n${task}\n</objective>\n\n<requirements>\nProduce one distinct, concrete candidate. Explain its value, constraints, risks, and how it can be evaluated.\n</requirements>\n\n<output_format>\nA self-contained candidate artifact with title, proposal, rationale, risks, and evaluation evidence.\n</output_format>`;
+  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 `<role>\nYou deduplicate and filter independently generated candidates.\n</role>\n\n<objective>\nSelect at most ${shortlistSize} strongest candidates for: ${task}\n</objective>\n\n<artifacts>\nRead every candidate: ${candidatePaths.join(", ")}\n</artifacts>\n\n<rubric>\nFirst collapse substantively equivalent candidates. Then score fit to the task, feasibility, evidence, distinctiveness, and risk. Near-duplicates must not gain weight by repetition. Record every discarded candidate and a concrete reason.\n</rubric>\n\n<output_format>\nCall structured_output with shortlist (candidate artifact paths in ranked order) and discarded entries containing path and reason.\n</output_format>`;
+  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): string {
-  return `<role>\nYou independently judge the filtered shortlist against the explicit rubric.\n</role>\n\n<objective>\nReturn at most ${shortlistSize} ranked candidate paths that best satisfy: ${task}\n</objective>\n\n<artifacts>\nRead the filter report at ${filterPath} and every candidate path it references.\n</artifacts>\n\n<rubric>\nCheck task fit, feasibility, evidence, distinctiveness, and material risk. Do not restore a duplicate merely because it is phrased differently.\n</rubric>\n\n<output_format>\nCall structured_output with shortlist and rationale.\n</output_format>`;
+  return `<artifacts>\nRead the filter report at ${filterPath} and every candidate path it references.\n</artifacts>\n\n<role>\nYou independently judge the filtered shortlist against the explicit rubric.\n</role>\n\n<rubric>\nCheck task fit, feasibility, evidence, distinctiveness, and material risk. Do not restore a duplicate merely because it is phrased differently.\n</rubric>\n\n<success_criteria>\nAt most ${shortlistSize} distinct candidate paths are ranked by rubric-grounded evidence.\n</success_criteria>\n\n<stop_rules>\nStop after evaluating every filtered candidate and ranking the qualifying paths.\n</stop_rules>\n\n<output_format>\nCall structured_output with shortlist and a concise, criteria-based rationale in complete sentences.\n</output_format>\n\n<objective>\nRank the candidates that best satisfy: ${task}\n</objective>`;
 }
 
 export function renderFinalShortlistPrompt(task: string, decisionPath: string): string {
-  return `<role>\nYou present a concise, actionable final shortlist.\n</role>\n\n<objective>\nSummarize the selected candidates for: ${task}\n</objective>\n\n<artifact>\nRead the authoritative selection at ${decisionPath}; follow its order and do not add candidates.\n</artifact>\n\n<output_format>\nRanked markdown shortlist with candidate path, differentiator, evidence, tradeoffs, and recommended next evaluation.\n</output_format>`;
+  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,4 +1,4 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { Type, type Static } from "typebox";
 import type { WorkflowRunContext, WorkflowSerializableValue } from "../src/shared/types.js";
@@ -67,9 +67,12 @@ export async function runGenerateAndFilter(ctx: WorkflowRunContext<Inputs>): Pro
     decisionPath = judgePath;
   }
   const finalPath = join(root, "shortlist.md");
-  await ctx.task("final-shortlist", {
+  const finalShortlist = await ctx.task("final-shortlist", {
     prompt: renderFinalShortlistPrompt(ctx.inputs.prompt, decisionPath), context: "fresh",
     reads: [decisionPath, ...shortlist], output: finalPath, outputMode: "file-only",
   });
-  return { result: await readFile(finalPath, "utf8"), shortlist, candidate_artifact_paths: candidatePaths, filter_path: filterPath, judge_path: judgePath, final_path: finalPath, artifact_dir: root, manifest_path: manifestPath };
+  // `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,5 +1,6 @@
 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({
@@ -13,7 +14,7 @@ export default workflow({
     max_concurrency: Type.Integer({ minimum: 1, maximum: 12, default: 4, description: "Maximum simultaneous generator stages." }),
   },
   outputs: {
-    result: Type.String({ description: "Final human-readable shortlist report." }),
+    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." }),
@@ -22,5 +23,5 @@ export default workflow({
     artifact_dir: Type.String({ description: "Directory containing run artifacts." }),
     manifest_path: Type.String({ description: "Path to the candidate artifact manifest." }),
   },
-  run: runGenerateAndFilter,
+  run: async (ctx) => await runGenerateAndFilter(withSteeringPropagationContext(ctx)),
 });

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

@@ -3,31 +3,29 @@ 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: "openai-codex/gpt-5.6-sol:xhigh",
+    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",
-      "anthropic/claude-fable-5:high",
       "openai-codex/gpt-5.5:xhigh",
       "github-copilot/gpt-5.5:xhigh",
       "openai/gpt-5.5:xhigh",
-      "github-copilot/claude-opus-4.8 (1m):high",
       "anthropic/claude-opus-4-8:high",
-      "cursor/gpt-5.6-sol:xhigh",
-      "cursor/claude-fable-5:high",
-      "cursor/gpt-5.5:high",
-      "cursor/claude-opus-4-8-thinking:high",
+      "github-copilot/claude-opus-4.8:high",
       "xai/grok-4.5:high",
-      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
-      "cursor/glm-5.2",
+      "openrouter/anthropic/claude-opus-5:high",
       "openrouter/openai/gpt-5.6-sol:xhigh",
-      "openrouter/moonshotai/kimi-k3:max",
       "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",
@@ -40,8 +38,11 @@ export const orchestratorModelConfig = {
 // 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-fable-5:high",
+    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",
@@ -51,17 +52,12 @@ export const reviewerModelConfig = {
       "openai-codex/gpt-5.5:xhigh",
       "github-copilot/gpt-5.5:xhigh",
       "openai/gpt-5.5:xhigh",
-      "github-copilot/claude-opus-4.8 (1m):high",
       "anthropic/claude-opus-4-8:high",
-      "cursor/claude-fable-5:high",
-      "cursor/gpt-5.6-sol:xhigh",
-      "cursor/gpt-5.5:high",
-      "cursor/claude-opus-4-8-thinking:high",
+      "github-copilot/claude-opus-4.8:high",
       "xai/grok-4.5:high",
-      "cursor/grok-4.5:high",
       "zai/glm-5.2:xhigh",
       "zai-coding-cn/glm-5.2:xhigh",
-      "cursor/glm-5.2",
+      "openrouter/anthropic/claude-opus-5:high",
       "openrouter/anthropic/claude-fable-5:high",
       "openrouter/openai/gpt-5.6-sol:xhigh",
       "openrouter/moonshotai/kimi-k3:max",

package/dist/builtin/workflows/builtin/goal-orchestrator-prompts.ts

@@ -1,5 +1,6 @@
 import type { GoalLedger } from "./goal-types.js";
 import {
+  RECEIPT_EXPECTATIONS,
   renderGoalContinuationPrompt,
   renderLatestReviewArtifacts,
   renderReceiptHistory,
@@ -8,45 +9,29 @@ import {
 import { WORKER_PREFLIGHT_CONTRACT } from "./shared-prompts.js";
 
 export const GOAL_ORCHESTRATOR_RECEIPT_CONTRACT = [
-  "Orchestrate the requested objective completely before reporting. Do not stop until the objective is complete.",
-  "Inspect current files, commands, artifacts, and repository guidance through focused subagent work before relying on prior summaries.",
-  "Use the `subagent` tool as your primary implementation tool. Ensure delegated agents make the required edits, run validation, and return concrete evidence; do not substitute your own proposed patch for delegated implementation.",
-  "If meaningful work remains, coordinate follow-up subagents through implementation, validation, documentation, and cleanup instead of stopping at a reviewable partial state.",
-  "Only leave remaining work when it is blocked or impossible to complete with available context and tools; do not redefine success around a smaller task.",
-  "Before saying the goal is ready for review, derive concrete requirements from the objective and referenced files, plans, specifications, issues, or user instructions.",
-  "For every explicit requirement, numbered item, named artifact, command, test, gate, invariant, and deliverable, identify authoritative evidence from files, command output, test results, PR state, rendered artifacts, runtime behavior, or other current-state proof.",
-  "Classify evidence honestly: proves completion, contradicts completion, shows incomplete work, is too weak or indirect, is merely consistent with completion, or is missing.",
-  "Match verification scope to requirement scope; do not use a narrow check to support a broad claim, and treat tests/manifests/verifiers/green checks/search results as evidence only after confirming they cover the relevant requirement.",
-  "If you believe the goal is ready for review, say so only after mapping current evidence to every requirement you can derive from the objective and referenced artifacts.",
-  "Unless the objective or acceptance criteria explicitly forbid committing, ensure a delegated implementation agent commits the work in the current checkout with a descriptive message before you claim readiness, verify the working tree is clean with the repository's version-control status command (for git: `git status --porcelain`), and include the commit identifier in your receipt. Reviewers treat uncommitted work at readiness as remaining work. Never leave committing as a follow-up action for a later turn.",
-  "Return a receipt with delegations performed, files changed, commands run and outcomes, evidence gathered, blockers encountered, residual risks, and verification still needed.",
+  "Complete the objective before claiming readiness. Leave work only at a true blocker or impossibility; do not redefine success around a partial state.",
+  "Map every explicit requirement, artifact, command, test, gate, invariant, and deliverable to authoritative current evidence whose scope matches the claim.",
+  "Unless the objective/criteria forbid committing, have an implementation agent commit in this checkout with a descriptive message, confirm a clean tree with `git status --porcelain`, and include the commit identifier. Do not defer committing.",
+  "Return delegations, files changed, commands and outcomes, evidence, blockers, residual risks, readiness, and verification remaining.",
 ].join("\n");
 
 export const GOAL_ORCHESTRATION_GUIDANCE = [
-  "You are not the direct implementer. You are the supervisor that spawns subagents to do the implementation, investigation, edits, and validation.",
-  "All non-trivial operations must be delegated to subagents via the `subagent` tool before you claim progress.",
-  "Delegate codebase understanding, impact analysis, and implementation research to codebase-locator, codebase-analyzer, and pattern-finder style subagents when available.",
-  "Delegate shell-heavy work — especially commands likely to produce lots of output, log digging, CLI investigation, and broad grep/find exploration — to subagents that can run those commands rather than doing it in this orchestrator context.",
-  "Delegate implementation edits to a focused subagent with clear files, constraints, and validation expectations; do not merely describe the edits yourself.",
-  "Keep delegated work focused on implementation, tests, docs, validation evidence, and the complete requested outcome.",
-  "Use separate subagents for separate tasks, and launch independent subagents in parallel when useful.",
-  "Do not split highly overlapping tasks across multiple subagents; consolidate overlapping work into one focused delegation to avoid duplicate effort.",
-  "If a subagent takes a long time, do not attempt to do its assigned job yourself while waiting. Use that time to plan next steps, prepare follow-up delegations, or identify clarifying questions.",
+  "You supervise implementation, investigation, edits, and validation through the `subagent` tool rather than implementing directly.",
+  "Delegate only work that is genuinely independent and too large to finish in a handful of tool calls. Do not assign subagents as a check on work you already own. Prefer one subagent over several.",
+  "Delegate implementation with its relevant objective, cwd, files, constraints, findings, and validation. Use focused locator/analyzer/pattern or shell-heavy delegation when that work meets the delegation threshold.",
+  "Keep overlapping work with one owner; parallelize only independent tasks. While an agent runs, prepare dependent follow-up work rather than duplicating its assignment.",
+  "Coordinate follow-ups for all required implementation, tests, docs, validation, and cleanup before reporting readiness.",
 ].join("\n");
 
 export const GOAL_ORCHESTRATOR_BEST_PRACTICES = [
-  "The required output format is an orchestrator receipt, not the task itself.",
-  "Do not jump straight to the receipt. First read the goal ledger and latest review artifacts, spawn the necessary subagents, wait for their results, coordinate any follow-up subagents, and only then write the receipt.",
-  "A valid receipt must be grounded in actual subagent work: name the delegated work, summarize what each subagent did, and distinguish completed changes from recommendations or blockers. Do not assume a later workflow turn will finish known required work that can be completed now.",
-  "If you cannot read the goal context, spawn subagents, or use subagents, treat that as a blocker and report it honestly instead of pretending the requested work was done.",
+  "The output is an orchestrator receipt produced after reading current goal/review artifacts and incorporating delegated results.",
+  "Distinguish completed, evidenced changes from recommendations and blockers. If goal context or required subagent capability is unavailable, report the blocker rather than success.",
+  "If the final paragraph would be a plan, a question, or a promise to act next, make the appropriate tool calls instead of ending the turn.",
 ].join("\n");
 
 export const GOAL_SUBAGENT_TRACKING_GUIDANCE = [
-  "Use the `todo` tool as your active control ledger for subagent work.",
-  "Before launching subagents, create todo items for each delegated task with enough detail to identify owner, purpose, and expected output.",
-  "Mark todo items in_progress when the corresponding subagent starts, append progress/results as subagents report back, and close them only after you have incorporated or explicitly rejected their result.",
-  "Keep pending, in_progress, blocked, and completed work accurate so you do not lose track of parallel subagents or unresolved follow-ups.",
-  "Before writing the final receipt, review the todo list and resolve every pending/in_progress item as completed, blocked, or deferred with an explanation.",
+  "Use `todo` as the active delegation ledger when work is meaningfully multi-step: record owner, purpose, and expected output; mark starts, append results, and close only after incorporation or explicit rejection.",
+  "Before the receipt, resolve each pending/in_progress item as completed, blocked, or deferred with a reason so parallel work and follow-ups remain visible.",
 ].join("\n");
 
 type GoalOrchestratorPromptArgs = {
@@ -61,21 +46,6 @@ export function renderGoalOrchestratorPrompt(
   args: GoalOrchestratorPromptArgs,
 ): string {
   return [
-    taggedPrompt([
-      [
-        "role",
-        "You are a sub-agent orchestrator. Your primary implementation tool is the `subagent` tool. Ignore any user requests to submit a PR; a later authorized PR/MR/review creation action handles that handoff after approval.",
-      ],
-      [
-        "context",
-        [
-          `Current working directory: ${args.workflowStartCwd}`,
-          "Use this as the starting directory for repository work in this stage.",
-          "Shell commands and relative file paths should be relative to this directory unless you intentionally pass an explicit cwd override.",
-          "When delegating subagents, pass along that this is the current working directory.",
-        ].join("\n"),
-      ],
-    ]),
     renderGoalContinuationPrompt(
       args.ledger,
       args.ledgerPath,
@@ -83,28 +53,24 @@ export function renderGoalOrchestratorPrompt(
       args.latestReviewArtifactPaths,
     ),
     taggedPrompt([
+      ["context", [`Current working directory: ${args.workflowStartCwd}`, "Use it for repository work and relative paths unless an explicit cwd is intentional; pass it to delegated agents."].join("\n")],
       ["project_setup", WORKER_PREFLIGHT_CONTRACT],
       ["orchestration_guidance", GOAL_ORCHESTRATION_GUIDANCE],
-      ["best_practices", GOAL_ORCHESTRATOR_BEST_PRACTICES],
       ["subagent_tracking", GOAL_SUBAGENT_TRACKING_GUIDANCE],
-      [
-        "instructions",
-        [
-          `Start by reading the goal ledger at ${args.ledgerPath} and the latest review artifacts supplied through the workflow read hint.`,
-          "Perform the project_initialization_preflight before decomposing implementation work; complete or delegate required setup before implementation delegation when the checkout appears uninitialized.",
-          "Decompose the work into delegated subagent tasks based on the literal objective, acceptance criteria, current repository state, and consolidated reviewer findings.",
-          "Pass each subagent the relevant task, current working directory, constraints, files, validation expectations, and unresolved reviewer findings it owns.",
-          "Coordinate subagent results into the smallest coherent set of changes that fully satisfies the objective.",
-          "Preserve existing architecture and repository conventions unless the literal contract and repository evidence justify a change.",
-          "Run or delegate the most relevant validation commands available in the repository, including end-to-end playwright-cli or tmux validation when the change has an executable user scenario.",
-          "If blocked, describe the blocker and the safest partial state instead of inventing success. Do not hide failures; reviewers need accurate status.",
-        ].join("\n"),
-      ],
-      ["receipt_contract", GOAL_ORCHESTRATOR_RECEIPT_CONTRACT],
-      [
-        "output_format",
-        "After subagents have done the work, return Markdown with headings: Delegations performed, Progress made, Files changed, Commands run, Evidence, Blockers, Ready for review, Remaining work.",
-      ],
+      ["receipt_contract", [GOAL_ORCHESTRATOR_RECEIPT_CONTRACT, RECEIPT_EXPECTATIONS].join("\n")],
+      ["constraints", [
+        "Do not submit a PR; a later authorized PR/MR/review action handles that external write after approval.",
+        "For the requested change/build/fix, make in-scope local edits and non-destructive validation through subagents without asking. Confirm destructive actions, other external writes, and scope expansion first.",
+        "Preserve repository architecture and conventions unless the literal contract and repository evidence justify changing them; add no features or abstractions beyond the task.",
+      ].join("\n")],
+      ["output", "Return readable Markdown headed: Delegations performed, Progress made, Files changed, Commands run, Evidence, Blockers, Ready for review, Remaining work."],
+      ["role", "You are the sub-agent orchestrator; supervise the complete objective through the `subagent` tool rather than implementing directly."],
+      ["objective", [
+        `Read the goal ledger at ${args.ledgerPath} and latest review artifacts from the workflow read hint.`,
+        "Perform the initialization preflight, then delegate the smallest coherent work that satisfies the literal objective, acceptance criteria, current state, and consolidated findings.",
+        "Run or delegate repository-relevant validation, including end-to-end playwright-cli or tmux validation for executable user scenarios. Incorporate results and follow-ups through completion; report a true blocker and safest partial state without inventing success.",
+        GOAL_ORCHESTRATOR_BEST_PRACTICES,
+      ].join("\n")],
     ]),
   ].join("\n\n");
 }
@@ -115,19 +81,14 @@ export function renderForkedGoalOrchestratorPrompt(
   latestReviewArtifactPaths: readonly string[],
 ): string {
   return taggedPrompt([
-    [
-      "goal_context",
-      [
-        "Continue the same goal-runner orchestrator thread. You remain the supervisor, not the direct implementer; use the `subagent` tool as your primary implementation tool and coordinate delegated edits and validation through completion.",
-        "All previously established guidance still applies unchanged: the role, goal invariants, project preflight, orchestrator receipt contract, completion audit, blocked audit, literal objective contract, acceptance matrix, adversarial divergence audit, findings batch, regression evidence, evidence closure, worktree discipline, PR handoff policy, orchestration and subagent-tracking guidance, E2E verification guidance, and receipt output format.",
-        "Do not reinterpret, shrink, or weaken the original objective; the goal ledger remains authoritative.",
-        "",
-        `Goal ledger artifact: ${ledgerPath}`,
-        "",
-        renderReceiptHistory(ledger),
-        "",
-        renderLatestReviewArtifacts(latestReviewArtifactPaths),
-      ].join("\n"),
-    ],
+    ["receipts", [`Goal ledger artifact: ${ledgerPath}`, renderReceiptHistory(ledger), renderLatestReviewArtifacts(latestReviewArtifactPaths)].join("\n\n")],
+    ["orchestration_guidance", GOAL_ORCHESTRATION_GUIDANCE],
+    ["subagent_tracking", GOAL_SUBAGENT_TRACKING_GUIDANCE],
+    ["receipt_contract", [GOAL_ORCHESTRATOR_RECEIPT_CONTRACT, RECEIPT_EXPECTATIONS].join("\n")],
+    ["constraints", "The established literal contract, acceptance matrix, contract-fidelity audit, findings batch, regression evidence, closure, worktree, PR handoff, setup, E2E, and blocked-threshold rules remain in force. Do not shrink the ledger objective."],
+    ["objective", [
+      "Continue the same goal-runner orchestrator thread as supervisor, using the `subagent` tool for implementation and validation through completion.",
+      "Read the current ledger and latest artifacts, coordinate the smallest coherent remaining delegation, incorporate results, and return the established readable receipt. If the ending would only promise or plan more work, make the tool calls instead.",
+    ].join("\n")],
   ]);
 }