@kenkaiiii/ggcoder 4.3.230 → 4.3.232

package/dist/core/goal-controller.js

@@ -1,15 +1,28 @@
-import { formatGoalBlockingPrerequisites, goalHasBlockingPrerequisites, } from "./goal-store.js";
+import { formatGoalBlockingPrerequisites, goalHasBlockingPrerequisites, goalHasUnmetLocalPrerequisites, unmetLocalGoalPrerequisites, } from "./goal-store.js";
 import { formatGoalReferencesForPrompt, referencesRequiringAcknowledgement, } from "./goal-references.js";
 export const DEFAULT_GOAL_TASK_ATTEMPT_LIMIT = 5;
 export const DEFAULT_GOAL_VERIFIER_FIX_LIMIT = 5;
+export const DEFAULT_GOAL_STRATEGY_LIMIT = 2;
+/**
+ * Hard ceiling on total controller decisions per run. A safety net that
+ * guarantees termination even if some unforeseen state oscillates without
+ * tripping the per-dimension attempt/strategy/verifier/audit limits. Set high
+ * enough that legitimate large goals never hit it.
+ */
+export const DEFAULT_GOAL_DECISION_LIMIT = 300;
 export const APPLY_INTEGRATION_TO_MAIN_TASK_TITLE = "Apply integrated worktree to main";
-export const COMMIT_INTEGRATED_GOAL_CHANGES_TASK_TITLE = "Commit integrated goal changes";
-const FINAL_COMPLETION_AUDIT_TASK_TITLE = "Audit Goal completion evidence";
+export const RESOLVE_LOCAL_PREREQUISITES_TASK_TITLE = "Resolve local Goal prerequisites";
+export const RE_STRATEGIZE_GOAL_TASK_TITLE = "Re-strategize Goal approach";
+export const FINAL_COMPLETION_AUDIT_TASK_TITLE = "Audit Goal completion evidence";
 const BUILD_GOAL_EVIDENCE_PATH_TASK_TITLE = "Build Goal evidence path";
 const BUILD_GOAL_VERIFICATION_HARNESS_TASK_TITLE = "Build Goal verification harness";
 const DEFINE_GOAL_VERIFIER_TASK_TITLE = "Define Goal verifier";
 const FIX_VERIFIER_FAILURE_TASK_TITLE = "Fix verifier failure";
 const DEFAULT_GOAL_COMPLETION_AUDIT_LIMIT = 3;
+/** Count of controller decisions already recorded as durable evidence. */
+export function goalDecisionCount(run) {
+    return run.evidence.filter((item) => item.label.startsWith("Goal decision:")).length;
+}
 function needsHarnessInstrumentation(run) {
     return run.harness.some((item) => !item.command && !item.path);
 }
@@ -168,85 +181,57 @@ function finalAuditTaskCount(run) {
 function hasApplyIntegrationTask(run) {
     return run.tasks.some((task) => task.title === APPLY_INTEGRATION_TO_MAIN_TASK_TITLE);
 }
-function hasCommitIntegratedChangesTask(run) {
-    return run.tasks.some((task) => task.title === COMMIT_INTEGRATED_GOAL_CHANGES_TASK_TITLE);
-}
-function pendingAfterDependenciesImplementationTasks(run) {
-    return run.tasks.filter((task) => task.status === "done" && task.mergeStrategy === "after_dependencies" && !!task.worktree);
-}
-function appliedIntegrationEvidence(run) {
-    return run.evidence.some((item) => item.label === "Integrated worktree applied to main" ||
-        item.label === "Goal decision: apply_integration_to_main");
-}
-function committedIntegrationEvidence(run) {
-    return run.evidence.some((item) => item.label === "Integrated Goal changes committed");
+/**
+ * Done worktree tasks whose committed candidate changes must reach the main
+ * checkout. Ordering is expressed by dependsOn; this gate only excludes tasks
+ * explicitly marked integration="manual". Read-only tasks (audit, etc.)
+ * produce no candidate changes and are excluded.
+ */
+function pendingWorktreeIntegrationTasks(run) {
+    return run.tasks.filter((task) => task.status === "done" &&
+        !!task.worktree &&
+        task.integration !== "manual" &&
+        (task.candidate?.changedFiles?.length ?? 0) > 0);
+}
+/** Typed integration gate: candidates reached main (applied or committed). */
+function integrationApplied(run) {
+    return run.integration?.status === "applied" || run.integration?.status === "committed";
+}
+/** Typed integration gate: integrated changes are committed in main. */
+function integrationCommitted(run) {
+    return run.integration?.status === "committed";
 }
 function hasIntegratedWorktreeChanges(run) {
-    return (pendingAfterDependenciesImplementationTasks(run).length > 0 || appliedIntegrationEvidence(run));
+    return (pendingWorktreeIntegrationTasks(run).length > 0 ||
+        (run.integration != null && run.integration.status !== "none"));
+}
+/**
+ * True when the latest verifier result predates the most recent substantive
+ * (non-audit, non-integration) worker completion, so the verifier evidence is
+ * stale and must be re-run before the audit/completion gates can trust it.
+ */
+function verifierStaleAfterWorker(run) {
+    return (!!run.verifier?.lastResult?.checkedAt &&
+        !!run.lastSubstantiveWorkerAt &&
+        run.lastSubstantiveWorkerAt > run.verifier.lastResult.checkedAt);
 }
 function needsMainIntegrationApplyTask(run) {
-    return (pendingAfterDependenciesImplementationTasks(run).length > 0 &&
+    return (pendingWorktreeIntegrationTasks(run).length > 0 &&
         !hasApplyIntegrationTask(run) &&
-        !appliedIntegrationEvidence(run));
-}
-function needsIntegratedGoalChangesCommitTask(run) {
-    return (hasIntegratedWorktreeChanges(run) &&
-        appliedIntegrationEvidence(run) &&
-        run.verifier?.lastResult?.status === "pass" &&
-        !latestNonAuditWorkerEvidenceAfterVerifier(run) &&
-        !hasCommitIntegratedChangesTask(run) &&
-        !committedIntegrationEvidence(run));
+        !integrationApplied(run));
 }
 function shouldCreateFinalAuditTask(run, limit = DEFAULT_GOAL_COMPLETION_AUDIT_LIMIT) {
     return finalAuditTaskCount(run) < limit;
 }
-function isFinalAuditWorkerEvidence(run, label) {
-    const match = /^Worker\s+(\S+)\s+/.exec(label);
-    const workerId = match?.[1];
-    if (!workerId)
-        return false;
-    return run.tasks.some((task) => task.title === FINAL_COMPLETION_AUDIT_TASK_TITLE && task.workerId === workerId);
-}
-function isCompletionAuditDecision(label) {
-    return label === "Goal decision: completion_audit";
-}
-function latestMatchingEvidence(evidence, predicate) {
-    return evidence.filter(predicate).sort((a, b) => b.createdAt.localeCompare(a.createdAt))[0];
-}
-function latestNonAuditWorkerEvidenceAfterVerifier(run) {
-    const verifierCheckedAt = run.verifier?.lastResult?.checkedAt;
-    if (!verifierCheckedAt)
-        return undefined;
-    return latestMatchingEvidence(run.evidence, (item) => item.createdAt > verifierCheckedAt &&
-        item.label.startsWith("Worker ") &&
-        !isFinalAuditWorkerEvidence(run, item.label));
-}
-function latestCompletionRelevantEvidenceAfterVerifier(run) {
-    const verifierCheckedAt = run.verifier?.lastResult?.checkedAt;
-    if (!verifierCheckedAt)
-        return undefined;
-    return latestMatchingEvidence(run.evidence, (item) => {
-        if (item.createdAt <= verifierCheckedAt)
-            return false;
-        if (isFinalAuditWorkerEvidence(run, item.label))
-            return false;
-        if (isCompletionAuditDecision(item.label))
-            return false;
-        if (item.label === "Verifier result" || item.label.startsWith("Verifier "))
-            return false;
-        return item.label.startsWith("Worker ") || item.label.startsWith("Goal decision:");
-    });
-}
 export function hasFreshGoalCompletionAudit(run) {
     const verifierResult = run.verifier?.lastResult;
     if (!verifierResult || verifierResult.status !== "pass") {
         return { ok: false, reason: "Goal has no passing verifier result to audit." };
     }
-    const postVerifierWorkerEvidence = latestNonAuditWorkerEvidenceAfterVerifier(run);
-    if (postVerifierWorkerEvidence) {
+    if (verifierStaleAfterWorker(run)) {
         return {
             ok: false,
-            reason: `Latest verifier result is stale after later Goal worker evidence: ${postVerifierWorkerEvidence.label}.`,
+            reason: "Latest verifier result is stale after a later substantive Goal worker completion.",
         };
     }
     const audit = run.completionAudit;
@@ -256,19 +241,7 @@ export function hasFreshGoalCompletionAudit(run) {
     if (audit.status !== "pass") {
         return { ok: false, reason: `Final completion audit status is ${audit.status}.` };
     }
-    if (!audit.summary.startsWith("FINAL_AUDIT_PASS")) {
-        return {
-            ok: false,
-            reason: "Final completion audit pass summary must start with FINAL_AUDIT_PASS.",
-        };
-    }
-    if (!audit.summary.includes(`verifier_checked_at=${verifierResult.checkedAt}`)) {
-        return {
-            ok: false,
-            reason: "Final completion audit pass summary must include latest verifier_checked_at.",
-        };
-    }
-    if (!audit.outputPath && !audit.summary.match(/(?:output|artifact|log|path)=\S+/)) {
+    if (!audit.outputPath) {
         return {
             ok: false,
             reason: "Final completion audit pass must reference verifier output or artifacts.",
@@ -286,13 +259,6 @@ export function hasFreshGoalCompletionAudit(run) {
             reason: "Final completion audit is older than the latest verifier result.",
         };
     }
-    const newerEvidence = latestCompletionRelevantEvidenceAfterVerifier(run);
-    if (newerEvidence && newerEvidence.createdAt > audit.checkedAt) {
-        return {
-            ok: false,
-            reason: `Final completion audit is stale after later Goal evidence: ${newerEvidence.label}.`,
-        };
-    }
     return { ok: true, reason: "Final completion audit passed after latest verifier evidence." };
 }
 function buildEvidencePlanTaskPrompt(run) {
@@ -311,21 +277,14 @@ function buildVerifierTaskPrompt(run) {
         `Define and build a real end-to-end verifier for this Goal. Begin from the intended experience and required senses/signals already implied by the success criteria and evidence plan, including mandatory Goal references. Choose a proportional local/free verifier that observes those signals and catches the important goal-specific failures; do not add generic simulations, screenshots, benchmarks, or scripts unless they directly support that proof. Update the Goal with a verifier_command, verifier_description, and verifier_cwd when the command must run from an isolated worker worktree. The verifier must be runnable locally/free and produce durable command or file evidence, not narrative or human visual inspection. If an external prerequisite is missing, mark it missing with exact user instructions.`);
 }
 function buildApplyIntegrationToMainTaskPrompt(run) {
-    const integrationTasks = pendingAfterDependenciesImplementationTasks(run)
+    const integrationTasks = pendingWorktreeIntegrationTasks(run)
         .map((task) => `- ${task.id} / ${task.title}: worktree=${task.worktree?.path ?? "unknown"}; branch=${task.worktree?.branchName ?? "unknown"}; base=${task.worktree?.baseRef ?? "unknown"}; summary=${task.lastSummary?.slice(0, 600) ?? "none"}`)
         .join("\n");
     return (`Goal: ${run.goal}\n\n` +
         referencePromptSection(run.references) +
-        `Apply accepted integration worktree changes into the user's main checkout before any release, verifier, final audit, commit, or completion. This task intentionally runs in the main checkout, not a new isolated worktree.\n\n` +
-        `Integrated/after-dependencies worker outputs to apply:\n${integrationTasks || "- none recorded"}\n\n` +
-        `For each integrated worktree, inspect its candidate packet, patch, diffstat, changed files, base SHA, verification logs, and risk notes. Apply or port only accepted changes to the main checkout; reject stale/risky/unrelated artifacts with durable evidence. Preserve user work. Run targeted checks in the main checkout after applying. Record durable evidence with label "Integrated worktree applied to main" containing the source worktree(s), accepted/rejected artifacts, changed files, diffstat, commands/results, and restart-needed note. Do not commit changes in this task; the controller will schedule a separate commit task after main-checkout verification evidence exists. Do not mark the whole Goal complete.`);
-}
-function buildCommitIntegratedGoalChangesTaskPrompt(run) {
-    return (`Goal: ${run.goal}\n\n` +
-        referencePromptSection(run.references) +
-        `Commit verified integrated Goal changes in the user's main checkout before final audit or completion. This task intentionally runs in the main checkout, not a new isolated worktree.\n\n` +
-        `Before committing, inspect git status and recent durable evidence to confirm accepted worktree changes were applied to main and main-checkout verification passed. Preserve user work: commit only files that belong to this Goal's accepted integrated changes, and do not stage unrelated user edits. If unrelated dirty files exist, block with exact paths and instructions instead of committing them.\n\n` +
-        `Run a targeted pre-commit check appropriate to the changed files if no fresh main-checkout verification evidence exists. Create one git commit with a concise message describing the Goal changes. Record durable evidence with label "Integrated Goal changes committed" containing the commit hash, staged/committed files, verification command/result used for confidence, and any restart-needed note. Do not mark the whole Goal complete.`);
+        `Apply accepted integration worktree changes into the user's main checkout before any release, verifier, final audit, or completion. This task intentionally runs in the main checkout, not a new isolated worktree.\n\n` +
+        `Integrated candidate worker outputs to apply:\n${integrationTasks || "- none recorded"}\n\n` +
+        `For each integrated worktree, inspect its candidate packet, patch, diffstat, changed files, base SHA, verification logs, and risk notes. Apply or port only accepted changes to the main checkout; reject stale/risky/unrelated artifacts with durable evidence. Preserve user work. Run targeted checks in the main checkout after applying. Record durable evidence with label "Integrated worktree applied to main" containing the source worktree(s), accepted/rejected artifacts, changed files, diffstat, commands/results, and restart-needed note. The orchestrator will deterministically commit/confirm accepted changes after this worker exits. Do not mark the whole Goal complete.`);
 }
 function incompleteTasks(run) {
     return run.tasks.filter((task) => task.status !== "done");
@@ -425,7 +384,7 @@ export function canCompleteGoalRun(run) {
     const requiredEvidence = hasRequiredGoalEvidence(run);
     if (!requiredEvidence.ok)
         return requiredEvidence;
-    if (hasIntegratedWorktreeChanges(run) && !committedIntegrationEvidence(run)) {
+    if (hasIntegratedWorktreeChanges(run) && !integrationCommitted(run)) {
         return {
             ok: false,
             reason: "Integrated Goal changes have not been committed in the main checkout.",
@@ -481,7 +440,7 @@ function buildFinalCompletionAuditTaskPrompt(run) {
         `Latest verifier: status=${verifier?.status ?? "unknown"}; checkedAt=${verifier?.checkedAt ?? "unknown"}; command=${verifier?.command ?? run.verifier?.command ?? "not recorded"}; output=${verifier?.outputPath ?? "not recorded"}; summary=${verifier?.summary ?? "not recorded"}\n\n` +
         `Evidence plan:\n${evidencePlanItems || "- none"}\n\n` +
         `Recent durable evidence:\n${recentEvidence || "- none"}\n\n` +
-        `Read the referenced report/log/source artifacts and compare them with the latest verifier result. The coordinator schedules and records decisions/state; the verifier path/UI/controller executes the configured verifier command as the final pre-audit gate and records goals verify evidence; this final audit records goals audit only after comparing the latest verifier output and references, including [original-goal-prompt] and durable GOAL_PLAN evidence. If an evidence-plan item is still planned but already matched by durable verifier/source/file evidence, update that evidence_plan item to status=ready with a concise evidence summary before recording the audit; if proof is missing, create a new pending Goal task with exact fix instructions and do not pass the audit. If everything matches, record a passing completion audit with the goals tool by using action=audit, verification_status=pass, output_path matching the verifier output when available, and a summary that starts with "FINAL_AUDIT_PASS" and includes "verifier_checked_at=${verifier?.checkedAt ?? "unknown"}", "original-goal-prompt", and "GOAL_PLAN". If anything is missing, stale, contradictory, or unverified, create a new pending Goal task with exact instructions to fix it, record evidence describing the mismatch, and leave the audit failing or absent so the coordinator resumes a worker until fixed.`);
+        `Read the referenced report/log/source artifacts and compare them with the latest verifier result. The coordinator schedules and records decisions/state; the verifier path/UI/controller executes the configured verifier command as the final pre-audit gate and records goals verify evidence; this final audit records goals audit only after comparing the latest verifier output and references, including [original-goal-prompt] and durable GOAL_PLAN evidence. If an evidence-plan item is still planned but already matched by durable verifier/source/file evidence, update that evidence_plan item to status=ready with a concise evidence summary before recording the audit; if proof is missing, create a new pending Goal task with exact fix instructions and do not pass the audit. If everything matches, record a passing completion audit with the goals tool using action=audit and verification_status=pass: write a plain-prose summary of which durable artifacts you compared and reference any mandatory non-prompt Goal references (and, when this Goal uses GOAL_PLAN planning, mention original-goal-prompt and GOAL_PLAN). The system auto-stamps FINAL_AUDIT_PASS and verifier_checked_at and fills output_path from the recorded verifier run, so do not transcribe the timestamp; any remaining contract gaps are returned all at once. If anything is missing, stale, contradictory, or unverified, create a new pending Goal task with exact instructions to fix it, record evidence describing the mismatch, and leave the audit failing or absent so the coordinator resumes a worker until fixed.`);
 }
 function buildVerifierFailureTaskPrompt(run) {
     const result = run.verifier?.lastResult;
@@ -501,11 +460,137 @@ function buildVerifierFailureTaskPrompt(run) {
         `Prior verifier summaries:\n${priorSummaries}\n\n` +
         `Run targeted diagnostics, fix the root cause, update durable Goal evidence with the goals tool, and rerun the exact verifier command. Do not mark the Goal complete.`);
 }
+function buildResolveLocalPrerequisitesTaskPrompt(run) {
+    const items = unmetLocalGoalPrerequisites(run)
+        .map((item) => `- ${item.label} (${item.status})${item.checkCommand ? `; check: ${item.checkCommand}` : ""}${item.instructions ? `; instructions: ${item.instructions}` : ""}`)
+        .join("\n");
+    return (`Goal: ${run.goal}\n\n` +
+        referencePromptSection(run.references) +
+        `Resolve the following local Goal prerequisites so the Goal can proceed unattended. These are not user-supplied external inputs; satisfy each one locally with free tools.\n\n` +
+        `${items || "- none recorded"}\n\n` +
+        `For each prerequisite, make its check pass locally (install/configure/build as needed using local/free tooling), then record durable evidence and update the prerequisite to status=met with the goals tool (action="prerequisite"). If a prerequisite turns out to genuinely require user-supplied external input, mark it kind=external with exact user instructions instead of guessing.`);
+}
+function isReStrategizeTask(task) {
+    return task.title.startsWith(RE_STRATEGIZE_GOAL_TASK_TITLE);
+}
+export function goalStrategyTaskCount(run) {
+    return run.tasks.filter(isReStrategizeTask).length;
+}
+function workerEvidenceContentsForTask(run, task) {
+    if (!task.workerId)
+        return [];
+    return run.evidence
+        .filter((item) => {
+        const match = /^Worker\s+(\S+)\s+/.exec(item.label);
+        return match?.[1] === task.workerId;
+    })
+        .map((item) => (item.content ?? "").trim())
+        .filter(Boolean);
+}
+/**
+ * No-progress signal for an implementation task: the latest two worker evidence
+ * contents for the task's worker are identical, so re-running the same approach
+ * is unlikely to make progress.
+ */
+export function taskFailureRepeatedWithoutProgress(run, task) {
+    const contents = workerEvidenceContentsForTask(run, task);
+    if (contents.length < 2)
+        return false;
+    return contents[contents.length - 1] === contents[contents.length - 2];
+}
+function buildReStrategizeTaskPrompt(run, focus) {
+    const priorContents = focus
+        ? workerEvidenceContentsForTask(run, focus)
+        : run.evidence
+            .filter((item) => item.label.startsWith("Verifier"))
+            .map((item) => (item.content ?? "").trim())
+            .filter(Boolean);
+    const priorSummaries = priorContents
+        .slice(-3)
+        .map((content) => `- ${content.slice(0, 500)}`)
+        .join("\n");
+    const what = focus ? `task "${focus.title}" (${focus.id})` : "the configured verifier";
+    return (`Original objective: ${run.goal}\n\n` +
+        referencePromptSection(run.references) +
+        `Prior attempts at ${what} repeatedly failed without progress.\n\n` +
+        `Prior attempt summaries:\n${priorSummaries || "- none recorded"}\n\n` +
+        `Analyze why the prior attempts failed, then take a fundamentally different approach to accomplish the original objective. Do not repeat the same strategy. Use local/free tools, record durable evidence with the goals tool, and update task status.${focus ? ` When you accomplish the objective, also mark the original failing task ${focus.id} done with the goals tool so the Goal can proceed.` : ""} If the objective genuinely requires user-supplied external input, record it as an external prerequisite with exact instructions.`);
+}
+/**
+ * Bounded re-strategy escalation: run an existing recoverable re-strategy task,
+ * else create one (up to the strategy limit), else terminate the run in
+ * `failed` with a structured diagnosis brief. Replaces the former pause/block
+ * dead-ends so the loop always either changes state or resolves.
+ */
+function reStrategizeOrFailDecision(run, options, context) {
+    const attemptLimit = options.taskAttemptLimit ?? DEFAULT_GOAL_TASK_ATTEMPT_LIMIT;
+    // Run an existing recoverable re-strategy task, but only while it still has
+    // attempt budget left, so a perpetually-failing strategy task cannot loop.
+    const recoverableStrategy = run.tasks.find((item) => isReStrategizeTask(item) && recoverableTask(item) && item.attempts < attemptLimit);
+    if (recoverableStrategy) {
+        return {
+            kind: "start_worker",
+            task: recoverableStrategy,
+            attempts: recoverableStrategy.attempts + 1,
+            reason: context.startReason,
+        };
+    }
+    const strategyLimit = options.strategyLimit ?? DEFAULT_GOAL_STRATEGY_LIMIT;
+    const strategyCount = goalStrategyTaskCount(run);
+    if (strategyCount < strategyLimit) {
+        // Distinct titles per attempt so the orchestrator creates a fresh task
+        // instead of reusing an exhausted same-title one.
+        const title = strategyCount === 0
+            ? RE_STRATEGIZE_GOAL_TASK_TITLE
+            : `${RE_STRATEGIZE_GOAL_TASK_TITLE} (${strategyCount + 1})`;
+        return {
+            kind: "create_task",
+            title,
+            prompt: buildReStrategizeTaskPrompt(run, context.focus),
+            reason: `${context.startReason} (${strategyCount + 1}/${strategyLimit})`,
+        };
+    }
+    return {
+        kind: "terminal",
+        status: "failed",
+        reason: buildGoalFailureDiagnosis(run, context.failReason),
+    };
+}
+/**
+ * Structured diagnosis brief recorded when a Goal terminates in `failed` so the
+ * run ends resolved (not spinning, not silently paused) with an honest verdict.
+ */
+export function buildGoalFailureDiagnosis(run, reason) {
+    const attempts = run.tasks
+        .map((task) => `- ${task.title} (${task.id}): status=${task.status}; attempts=${task.attempts}${task.lastSummary ? `; last=${task.lastSummary.slice(0, 240)}` : ""}`)
+        .join("\n");
+    const failureSignatures = Array.from(new Set(run.evidence
+        .filter((item) => item.label === "Verifier fail" || item.label === "Verifier result")
+        .map((item) => (item.content ?? "").trim())
+        .filter(Boolean)))
+        .slice(-5)
+        .map((signature) => `- ${signature.slice(0, 240)}`)
+        .join("\n");
+    const verifier = run.verifier?.lastResult;
+    const externalNeeds = run.prerequisites
+        .filter((item) => (item.status !== "met" || !item.evidence?.trim()) && item.kind === "external")
+        .map((item) => `- ${item.label}: ${item.instructions ?? "user-supplied input required"}`)
+        .join("\n");
+    return [
+        "GOAL_FAILURE_DIAGNOSIS",
+        `objective=${run.goal}`,
+        `reason=${reason}`,
+        `tasks:\n${attempts || "- none"}`,
+        `distinct_failure_signatures:\n${failureSignatures || "- none"}`,
+        `latest_verifier=${verifier ? `${verifier.status} (exit ${verifier.exitCode ?? "unknown"}): ${verifier.summary?.slice(0, 240) ?? ""}` : "none"}`,
+        `human_decision_needed:\n${externalNeeds || "- none"}`,
+    ].join("\n");
+}
 export function formatGoalControllerDecision(decision) {
     const parts = [`kind=${decision.kind}`];
     if ("reason" in decision)
         parts.push(`reason=${decision.reason}`);
-    if (decision.kind === "start_worker" || decision.kind === "pause") {
+    if (decision.kind === "start_worker") {
         parts.push(`task=${decision.task.id}`, `title=${decision.task.title}`, `attempts=${decision.attempts}`);
         if (decision.task.workerId)
             parts.push(`worker=${decision.task.workerId}`);
@@ -516,8 +601,8 @@ export function formatGoalControllerDecision(decision) {
         if (decision.task.expectedChangedScope?.length) {
             parts.push(`expected_changed_scope=${decision.task.expectedChangedScope.join(",")}`);
         }
-        if (decision.task.mergeStrategy)
-            parts.push(`merge_strategy=${decision.task.mergeStrategy}`);
+        if (decision.task.integration)
+            parts.push(`integration=${decision.task.integration}`);
     }
     if (decision.kind === "wait" && decision.workerId)
         parts.push(`worker=${decision.workerId}`);
@@ -541,6 +626,17 @@ export function decideGoalNextAction(run, options = {}) {
         }
         return { kind: "complete", reason: completion.reason };
     }
+    // Hard termination guarantee: if a run somehow keeps making decisions without
+    // completing or hitting a narrower limit, fail with a diagnosis rather than
+    // loop forever.
+    const decisionLimit = options.decisionLimit ?? DEFAULT_GOAL_DECISION_LIMIT;
+    if (goalDecisionCount(run) > decisionLimit) {
+        return {
+            kind: "terminal",
+            status: "failed",
+            reason: buildGoalFailureDiagnosis(run, `Goal exceeded the maximum of ${decisionLimit} controller decisions without completing; stopping to avoid an unbounded loop.`),
+        };
+    }
     if (goalHasBlockingPrerequisites(run)) {
         return { kind: "blocked", reason: formatGoalBlockingPrerequisites(run) };
     }
@@ -565,17 +661,38 @@ export function decideGoalNextAction(run, options = {}) {
             ...(runningTask.workerId ? { workerId: runningTask.workerId } : {}),
         };
     }
+    if (goalHasUnmetLocalPrerequisites(run)) {
+        const duplicateDecision = duplicateAutoTaskDecision(run, RESOLVE_LOCAL_PREREQUISITES_TASK_TITLE, "Local Goal prerequisites must be satisfied locally before implementation.");
+        if (duplicateDecision)
+            return duplicateDecision;
+        return {
+            kind: "create_task",
+            title: RESOLVE_LOCAL_PREREQUISITES_TASK_TITLE,
+            prompt: buildResolveLocalPrerequisitesTaskPrompt(run),
+            reason: `Resolving ${unmetLocalGoalPrerequisites(run).length} local Goal prerequisite(s) locally instead of blocking.`,
+        };
+    }
     const task = nextRunnableTask(run);
     if (task) {
         const attempts = task.attempts + 1;
         const limit = options.taskAttemptLimit ?? DEFAULT_GOAL_TASK_ATTEMPT_LIMIT;
         if (attempts > limit) {
-            return {
-                kind: "pause",
-                task,
-                attempts,
-                reason: `Attempt limit reached for task ${task.title}.`,
-            };
+            // Past the soft attempt limit: keep retrying while the failure signature
+            // keeps changing (still making progress); on a no-progress repeat,
+            // re-strategize a bounded number of times, then fail with a diagnosis.
+            if (!isReStrategizeTask(task) && !taskFailureRepeatedWithoutProgress(run, task)) {
+                return {
+                    kind: "start_worker",
+                    task,
+                    attempts,
+                    reason: `Goal task "${task.title}" passed the soft attempt limit but is still making progress; continuing attempt ${attempts}.`,
+                };
+            }
+            return reStrategizeOrFailDecision(run, options, {
+                focus: task,
+                startReason: `Re-strategizing "${task.title}" with a fundamentally different approach.`,
+                failReason: `Task "${task.title}" could not be completed after ${task.attempts} attempt(s) and the bounded re-strategy limit.`,
+            });
         }
         return {
             kind: "start_worker",
@@ -589,8 +706,9 @@ export function decideGoalNextAction(run, options = {}) {
         const missingDependencies = dependencyBlockedTask.dependencies.filter((dependencyId) => !run.tasks.some((item) => taskMatchesDependency(item, dependencyId)));
         if (missingDependencies.length > 0) {
             return {
-                kind: "blocked",
-                reason: `Goal task "${dependencyBlockedTask.task.title}" depends on missing task(s): ${missingDependencies.join(", ")}.`,
+                kind: "terminal",
+                status: "failed",
+                reason: buildGoalFailureDiagnosis(run, `Goal task "${dependencyBlockedTask.task.title}" depends on missing task(s) that cannot be synthesized: ${missingDependencies.join(", ")}.`),
             };
         }
         return {
@@ -610,16 +728,8 @@ export function decideGoalNextAction(run, options = {}) {
             reason: "Accepted integration worktree changes must be applied to the user's main checkout before verifier, final audit, release, commit, or completion.",
         };
     }
-    if (needsIntegratedGoalChangesCommitTask(run)) {
-        return {
-            kind: "create_task",
-            title: COMMIT_INTEGRATED_GOAL_CHANGES_TASK_TITLE,
-            prompt: buildCommitIntegratedGoalChangesTaskPrompt(run),
-            reason: "Verified integrated Goal changes must be committed in the user's main checkout before final audit or completion.",
-        };
-    }
     if (run.verifier?.lastResult?.status === "pass" &&
-        latestNonAuditWorkerEvidenceAfterVerifier(run) &&
+        verifierStaleAfterWorker(run) &&
         run.verifier?.command) {
         return {
             kind: "run_verifier",
@@ -638,8 +748,9 @@ export function decideGoalNextAction(run, options = {}) {
                 };
             }
             return {
-                kind: "blocked",
-                reason: "Verifier passed, but final completion audit did not reconcile the Goal evidence plan after bounded attempts.",
+                kind: "terminal",
+                status: "failed",
+                reason: buildGoalFailureDiagnosis(run, "Verifier passed, but the final completion audit could not reconcile the Goal evidence plan after bounded attempts."),
             };
         }
         const duplicateDecision = duplicateAutoTaskDecision(run, BUILD_GOAL_EVIDENCE_PATH_TASK_TITLE, "Goal evidence plan still requires local instrumentation or exact prerequisite handling before verification.");
@@ -665,18 +776,18 @@ export function decideGoalNextAction(run, options = {}) {
     }
     if (run.verifier?.lastResult?.status === "fail") {
         if (hasRepeatedVerifierFailure(run)) {
-            return {
-                kind: "blocked",
-                reason: "Verifier produced the same failure repeatedly; pause for diagnosis before creating more fix tasks.",
-            };
+            return reStrategizeOrFailDecision(run, options, {
+                startReason: "Verifier produced the same failure repeatedly; re-strategizing with a fundamentally different approach.",
+                failReason: "Verifier produced the same failure repeatedly and bounded re-strategy attempts were exhausted.",
+            });
         }
         const limit = options.verifierFixLimit ?? DEFAULT_GOAL_VERIFIER_FIX_LIMIT;
         const blockedFixTask = existingBlockedTaskWithTitle(run, FIX_VERIFIER_FAILURE_TASK_TITLE);
         if (blockedFixTask) {
-            return {
-                kind: "blocked",
-                reason: "A blocked verifier-fix task already exists; not creating another fix worker until the existing blocker is reconciled.",
-            };
+            return reStrategizeOrFailDecision(run, options, {
+                startReason: "A blocked verifier-fix task exists; re-strategizing the verifier fix with a different approach.",
+                failReason: "A verifier-fix task was blocked and bounded re-strategy attempts were exhausted.",
+            });
         }
         if (shouldCreateVerifierFixTask(run, limit)) {
             return {
@@ -687,16 +798,9 @@ export function decideGoalNextAction(run, options = {}) {
             };
         }
         return {
-            kind: "pause",
-            task: {
-                id: "verifier-fix-limit",
-                title: FIX_VERIFIER_FAILURE_TASK_TITLE,
-                prompt: "Verifier fix attempt limit reached.",
-                status: "blocked",
-                attempts: limit,
-            },
-            attempts: limit,
-            reason: `Verifier fix task limit reached (${limit}).`,
+            kind: "terminal",
+            status: "failed",
+            reason: buildGoalFailureDiagnosis(run, `Verifier failed and the bounded verifier-fix limit (${limit}) was reached without a pass.`),
         };
     }
     if (run.verifier?.lastResult?.status === "pass") {
@@ -709,8 +813,9 @@ export function decideGoalNextAction(run, options = {}) {
             };
         }
         return {
-            kind: "blocked",
-            reason: "Verifier passed, but final completion audit did not pass after bounded attempts.",
+            kind: "terminal",
+            status: "failed",
+            reason: buildGoalFailureDiagnosis(run, "Verifier passed, but the final completion audit did not pass after bounded attempts."),
         };
     }
     if (run.verifier?.command) {