steroids-cli 0.9.30 → 0.9.32

package/dist/commands/loop-phases.d.ts

@@ -21,6 +21,6 @@ export interface CreditExhaustionResult {
     message: string;
     retryAfterMs?: number;
 }
-export declare function runCoderPhase(db: ReturnType<typeof openDatabase>['db'], task: ReturnType<typeof getTask>, projectPath: string, action: 'start' | 'resume', jsonMode?: boolean, coordinatorCache?: Map<string, CoordinatorResult>, coordinatorThresholds?: number[], leaseFence?: LeaseFenceContext): Promise<CreditExhaustionResult | void>;
+export declare function runCoderPhase(db: ReturnType<typeof openDatabase>['db'], task: ReturnType<typeof getTask>, projectPath: string, action: 'start' | 'resume', jsonMode?: boolean, coordinatorCache?: Map<string, CoordinatorResult>, coordinatorThresholds?: number[], leaseFence?: LeaseFenceContext, branchName?: string): Promise<CreditExhaustionResult | void>;
 export declare function runReviewerPhase(db: ReturnType<typeof openDatabase>['db'], task: ReturnType<typeof getTask>, projectPath: string, jsonMode?: boolean, coordinatorResult?: CoordinatorResult, branchName?: string, leaseFence?: LeaseFenceContext): Promise<CreditExhaustionResult | void>;
 //# sourceMappingURL=loop-phases.d.ts.map

package/dist/commands/loop-phases.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"loop-phases.d.ts","sourceRoot":"","sources":["../../src/commands/loop-phases.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,OAAO,EAWR,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAU9D,OAAO,EAA8C,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAwBpH,OAAO,EAAE,KAAK,iBAAiB,EAAE,CAAC;AAElC,UAAU,iBAAiB;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA8CD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,yBAAyB,GAAG,YAAY,CAAC;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAkLD,wBAAsB,aAAa,CACjC,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,IAAI,CAAC,EACzC,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAChC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,GAAG,QAAQ,EAC1B,QAAQ,UAAQ,EAChB,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACjD,qBAAqB,CAAC,EAAE,MAAM,EAAE,EAChC,UAAU,CAAC,EAAE,iBAAiB,GAC7B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAwSxC;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,IAAI,CAAC,EACzC,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAChC,WAAW,EAAE,MAAM,EACnB,QAAQ,UAAQ,EAChB,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,UAAU,GAAE,MAAe,EAC3B,UAAU,CAAC,EAAE,iBAAiB,GAC7B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAgbxC"}
+{"version":3,"file":"loop-phases.d.ts","sourceRoot":"","sources":["../../src/commands/loop-phases.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EACL,OAAO,EAaR,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAU9D,OAAO,EAA8C,KAAK,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AA2BpH,OAAO,EAAE,KAAK,iBAAiB,EAAE,CAAC;AAElC,UAAU,iBAAiB;IACzB,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AA8CD;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,MAAM,EAAE,yBAAyB,GAAG,YAAY,CAAC;IACjD,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,OAAO,GAAG,UAAU,CAAC;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAoTD,wBAAsB,aAAa,CACjC,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,IAAI,CAAC,EACzC,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAChC,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,GAAG,QAAQ,EAC1B,QAAQ,UAAQ,EAChB,gBAAgB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACjD,qBAAqB,CAAC,EAAE,MAAM,EAAE,EAChC,UAAU,CAAC,EAAE,iBAAiB,EAC9B,UAAU,SAAS,GAClB,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAikBxC;AAED,wBAAsB,gBAAgB,CACpC,EAAE,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC,IAAI,CAAC,EACzC,IAAI,EAAE,UAAU,CAAC,OAAO,OAAO,CAAC,EAChC,WAAW,EAAE,MAAM,EACnB,QAAQ,UAAQ,EAChB,iBAAiB,CAAC,EAAE,iBAAiB,EACrC,UAAU,GAAE,MAAe,EAC3B,UAAU,CAAC,EAAE,iBAAiB,GAC7B,OAAO,CAAC,sBAAsB,GAAG,IAAI,CAAC,CAwcxC"}

package/dist/commands/loop-phases.js

@@ -13,6 +13,7 @@ const reviewer_js_1 = require("../orchestrator/reviewer.js");
 const coordinator_js_1 = require("../orchestrator/coordinator.js");
 const push_js_1 = require("../git/push.js");
 const status_js_1 = require("../git/status.js");
+const submission_resolution_js_1 = require("../git/submission-resolution.js");
 const invoke_js_1 = require("../orchestrator/invoke.js");
 const fallback_handler_js_1 = require("../orchestrator/fallback-handler.js");
 const loader_js_1 = require("../config/loader.js");
@@ -136,9 +137,58 @@ async function checkNonRetryableProviderFailure(result, role, projectPath, revie
     }
     return null;
 }
+function summarizeErrorMessage(error) {
+    const raw = error instanceof Error ? error.message : String(error);
+    return raw.replace(/\s+/g, ' ').trim().slice(0, 220);
+}
+/**
+ * Classify orchestrator invocation failures so we can distinguish transient parse
+ * noise from hard provider/config failures (auth/model/availability).
+ */
+async function classifyOrchestratorFailure(error, projectPath) {
+    const message = summarizeErrorMessage(error);
+    const lower = message.toLowerCase();
+    if (lower.includes('orchestrator ai provider not configured')) {
+        return { type: 'orchestrator_unconfigured', message, retryable: false };
+    }
+    if (lower.includes("provider '") && lower.includes('is not available')) {
+        return { type: 'provider_unavailable', message, retryable: false };
+    }
+    const config = (0, loader_js_1.loadConfig)(projectPath);
+    const providerName = config.ai?.orchestrator?.provider;
+    if (!providerName) {
+        return { type: 'orchestrator_unconfigured', message, retryable: false };
+    }
+    const registry = await (0, registry_js_1.getProviderRegistry)();
+    const provider = registry.tryGet(providerName);
+    if (!provider) {
+        return { type: 'provider_unavailable', message, retryable: false };
+    }
+    const syntheticFailure = {
+        success: false,
+        exitCode: 1,
+        stdout: '',
+        stderr: message,
+        duration: 0,
+        timedOut: false,
+    };
+    const classified = provider.classifyResult(syntheticFailure);
+    if (!classified) {
+        return null;
+    }
+    return {
+        type: classified.type,
+        message: classified.message || message,
+        retryable: classified.retryable,
+    };
+}
 const MAX_ORCHESTRATOR_PARSE_RETRIES = 3;
+const MAX_CONTRACT_VIOLATION_RETRIES = 3;
 const CODER_PARSE_FALLBACK_MARKER = '[retry] FALLBACK: Orchestrator failed, defaulting to retry';
 const REVIEWER_PARSE_FALLBACK_MARKER = '[unclear] FALLBACK: Orchestrator failed, retrying review';
+const CONTRACT_CHECKLIST_MARKER = '[contract:checklist]';
+const CONTRACT_REJECTION_RESPONSE_MARKER = '[contract:rejection_response]';
+const MUST_IMPLEMENT_MARKER = '[must_implement]';
 function countConsecutiveOrchestratorFallbackEntries(db, taskId, marker) {
     const audit = (0, queries_js_1.getTaskAudit)(db, taskId);
     let count = 0;
@@ -173,6 +223,34 @@ function countConsecutiveUnclearEntries(db, taskId) {
     }
     return count;
 }
+function countConsecutiveTaggedOrchestratorEntries(db, taskId, requiredTag, tagFamilyPrefix) {
+    const audit = (0, queries_js_1.getTaskAudit)(db, taskId);
+    let count = 0;
+    for (let i = audit.length - 1; i >= 0; i--) {
+        const entry = audit[i];
+        if (entry.actor !== 'orchestrator') {
+            continue; // tolerate non-orchestrator audit noise
+        }
+        const notes = entry.notes ?? '';
+        if (notes.includes(requiredTag)) {
+            count += 1;
+            continue;
+        }
+        if (tagFamilyPrefix && notes.includes(tagFamilyPrefix)) {
+            break; // same family, different category = sequence ended
+        }
+        break;
+    }
+    return count;
+}
+function countLatestOpenRejectionItems(notes) {
+    if (!notes)
+        return 0;
+    return notes
+        .split('\n')
+        .filter(line => /^\s*[-*]\s*\[\s\]\s+/.test(line))
+        .length;
+}
 function hasCoderCompletionSignal(output) {
     const lower = output.toLowerCase();
     if (/\b(?:not|no)\s+(?:task\s+)?(?:is\s+)?(?:complete|complete[d]?|finished|done|ready)\b/.test(lower)) {
@@ -180,57 +258,117 @@ function hasCoderCompletionSignal(output) {
     }
     return /\b(?:task\s+)?(?:is\s+)?(?:complete|complete[d]?|implemented|finished|done|ready for review|ready)\b/.test(lower);
 }
-async function runCoderPhase(db, task, projectPath, action, jsonMode = false, coordinatorCache, coordinatorThresholds, leaseFence) {
+function extractSubmissionCommitToken(output) {
+    const match = output.match(/^\s*SUBMISSION_COMMIT\s*:\s*([0-9a-fA-F]{7,40})\b/im);
+    return match?.[1] ?? null;
+}
+function resolveCoderSubmittedCommitSha(projectPath, coderOutput, options = {}) {
+    const tokenSha = extractSubmissionCommitToken(coderOutput);
+    if (tokenSha && (0, status_js_1.isCommitReachableWithFetch)(projectPath, tokenSha, { forceFetch: true })) {
+        try {
+            return (0, node_child_process_1.execSync)(`git rev-parse ${tokenSha}^{commit}`, {
+                cwd: projectPath,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'pipe'],
+            }).trim();
+        }
+        catch {
+            return tokenSha;
+        }
+    }
+    if (options.requireExplicitToken) {
+        return undefined;
+    }
+    return (0, status_js_1.getCurrentCommitSha)(projectPath) || undefined;
+}
+async function runCoderPhase(db, task, projectPath, action, jsonMode = false, coordinatorCache, coordinatorThresholds, leaseFence, branchName = 'main') {
     if (!task)
         return;
     refreshParallelWorkstreamLease(projectPath, leaseFence);
     let coordinatorGuidance;
     const thresholds = coordinatorThresholds || [2, 5, 9];
+    const persistedMustImplement = (0, queries_js_1.getLatestMustImplementGuidance)(db, task.id);
+    const activeMustImplement = persistedMustImplement &&
+        task.status === 'in_progress' &&
+        task.rejection_count >= persistedMustImplement.rejection_count_watermark
+        ? persistedMustImplement
+        : null;
     // Run coordinator at rejection thresholds (same as before)
     const shouldInvokeCoordinator = thresholds.includes(task.rejection_count);
     const cachedResult = coordinatorCache?.get(task.id);
-    if (shouldInvokeCoordinator) {
+    if (activeMustImplement) {
+        coordinatorGuidance = activeMustImplement.guidance;
+        coordinatorCache?.set(task.id, {
+            success: true,
+            decision: 'guide_coder',
+            guidance: activeMustImplement.guidance,
+        });
         if (!jsonMode) {
-            console.log(`\n>>> Task has ${task.rejection_count} rejections (threshold hit) - invoking COORDINATOR...\n`);
+            console.log(`\nActive MUST_IMPLEMENT override detected (rc=${activeMustImplement.rejection_count_watermark})`);
         }
-        try {
-            const rejectionHistory = (0, queries_js_1.getTaskRejections)(db, task.id);
-            const coordExtra = {};
-            if (task.section_id) {
-                const allSectionTasks = (0, queries_js_1.listTasks)(db, { sectionId: task.section_id });
-                coordExtra.sectionTasks = allSectionTasks.map(t => ({
-                    id: t.id, title: t.title, status: t.status,
-                }));
-            }
-            coordExtra.submissionNotes = (0, queries_js_1.getLatestSubmissionNotes)(db, task.id);
-            const modified = (0, status_js_1.getModifiedFiles)(projectPath);
-            if (modified.length > 0) {
-                coordExtra.gitDiffSummary = modified.join('\n');
-            }
-            if (cachedResult) {
-                coordExtra.previousGuidance = cachedResult.guidance;
-            }
-            const coordResult = await (0, coordinator_js_1.invokeCoordinator)(task, rejectionHistory, projectPath, coordExtra);
-            if (coordResult) {
-                coordinatorGuidance = coordResult.guidance;
-                coordinatorCache?.set(task.id, coordResult);
-                (0, queries_js_1.addAuditEntry)(db, task.id, task.status, task.status, 'coordinator', {
-                    actorType: 'orchestrator',
-                    notes: `[${coordResult.decision}] ${coordResult.guidance}`,
-                });
-                if (!jsonMode) {
-                    console.log(`\nCoordinator decision: ${coordResult.decision}`);
-                    console.log('Coordinator guidance stored for both coder and reviewer.');
-                }
+    }
+    if (shouldInvokeCoordinator) {
+        if (activeMustImplement &&
+            task.rejection_count === activeMustImplement.rejection_count_watermark) {
+            if (!jsonMode) {
+                console.log('\nSkipping coordinator reinvocation in same rejection cycle due to active MUST_IMPLEMENT override');
             }
         }
-        catch (error) {
+        else {
             if (!jsonMode) {
-                console.warn('Coordinator invocation failed, continuing without guidance:', error);
+                console.log(`\n>>> Task has ${task.rejection_count} rejections (threshold hit) - invoking COORDINATOR...\n`);
+            }
+            try {
+                const rejectionHistory = (0, queries_js_1.getTaskRejections)(db, task.id);
+                const coordExtra = {};
+                if (task.section_id) {
+                    const allSectionTasks = (0, queries_js_1.listTasks)(db, { sectionId: task.section_id });
+                    coordExtra.sectionTasks = allSectionTasks.map(t => ({
+                        id: t.id, title: t.title, status: t.status,
+                    }));
+                }
+                coordExtra.submissionNotes = (0, queries_js_1.getLatestSubmissionNotes)(db, task.id);
+                const modified = (0, status_js_1.getModifiedFiles)(projectPath);
+                if (modified.length > 0) {
+                    coordExtra.gitDiffSummary = modified.join('\n');
+                }
+                if (cachedResult) {
+                    coordExtra.previousGuidance = cachedResult.guidance;
+                }
+                if (activeMustImplement) {
+                    coordExtra.lockedMustImplementGuidance = activeMustImplement.guidance;
+                    coordExtra.lockedMustImplementWatermark = activeMustImplement.rejection_count_watermark;
+                }
+                const coordResult = await (0, coordinator_js_1.invokeCoordinator)(task, rejectionHistory, projectPath, coordExtra);
+                if (coordResult) {
+                    const mustKeepOverride = activeMustImplement &&
+                        task.rejection_count > activeMustImplement.rejection_count_watermark;
+                    const normalizedGuidance = mustKeepOverride && !coordResult.guidance.includes('MUST_IMPLEMENT:')
+                        ? `${activeMustImplement.guidance}\n\nAdditional coordinator guidance:\n${coordResult.guidance}`
+                        : coordResult.guidance;
+                    coordinatorGuidance = normalizedGuidance;
+                    coordinatorCache?.set(task.id, {
+                        ...coordResult,
+                        guidance: normalizedGuidance,
+                    });
+                    (0, queries_js_1.addAuditEntry)(db, task.id, task.status, task.status, 'coordinator', {
+                        actorType: 'orchestrator',
+                        notes: `[${coordResult.decision}] ${normalizedGuidance}`,
+                    });
+                    if (!jsonMode) {
+                        console.log(`\nCoordinator decision: ${coordResult.decision}`);
+                        console.log('Coordinator guidance stored for both coder and reviewer.');
+                    }
+                }
+            }
+            catch (error) {
+                if (!jsonMode) {
+                    console.warn('Coordinator invocation failed, continuing without guidance:', error);
+                }
             }
         }
     }
-    else if (cachedResult) {
+    else if (cachedResult && !activeMustImplement) {
         coordinatorGuidance = cachedResult.guidance;
         if (!jsonMode && task.rejection_count >= 2) {
             console.log(`\nReusing cached coordinator guidance (decision: ${cachedResult.decision})`);
@@ -282,6 +420,8 @@ async function runCoderPhase(db, task, projectPath, action, jsonMode = false, co
     const lastRejectionNotes = task.rejection_count > 0
         ? (0, queries_js_1.getTaskRejections)(db, task.id).slice(-1)[0]?.notes ?? undefined
         : undefined;
+    const requiresExplicitSubmissionCommit = (lastRejectionNotes ?? '').includes('[commit_recovery]');
+    const rejectionItemCount = countLatestOpenRejectionItems(lastRejectionNotes);
     const context = {
         task: {
             id: task.id,
@@ -289,6 +429,7 @@ async function runCoderPhase(db, task, projectPath, action, jsonMode = false, co
             description: task.title, // Use title as description for now
             rejection_notes: lastRejectionNotes,
             rejection_count: task.rejection_count,
+            rejection_item_count: rejectionItemCount,
         },
         coder_output: {
             stdout: coderResult.stdout,
@@ -306,40 +447,57 @@ async function runCoderPhase(db, task, projectPath, action, jsonMode = false, co
     }
     catch (error) {
         console.error('Orchestrator invocation failed:', error);
-        // Check if coder seems finished even if orchestrator failed
-        const isTaskComplete = hasCoderCompletionSignal(coderResult.stdout);
-        // Only count as having work if there are actual relevant uncommitted changes,
-        // changed files, or recent commits
-        const hasWork = hasRelevantChanges;
-        if (isTaskComplete && hasWork) {
+        const orchestratorFailure = await classifyOrchestratorFailure(error, projectPath);
+        if (orchestratorFailure && !orchestratorFailure.retryable) {
             orchestratorOutput = JSON.stringify({
-                action: has_uncommitted ? 'stage_commit_submit' : 'submit',
-                reasoning: 'FALLBACK: Orchestrator failed but coder signaled completion',
-                commits: commits.map(c => c.sha),
-                next_status: 'review',
-                metadata: {
-                    files_changed: files_changed.length,
-                    confidence: 'low',
-                    exit_clean: true,
-                    has_commits: commits.length > 0,
-                }
-            });
-        }
-        else {
-            // Fallback to safe default: retry
-            orchestratorOutput = JSON.stringify({
-                action: 'retry',
-                reasoning: 'FALLBACK: Orchestrator failed, defaulting to retry',
+                action: 'error',
+                reasoning: `FALLBACK: Non-retryable orchestrator failure (${orchestratorFailure.type})`,
                 commits: [],
-                next_status: 'in_progress',
+                next_status: 'failed',
                 metadata: {
                     files_changed: 0,
                     confidence: 'low',
-                    exit_clean: true,
+                    exit_clean: false,
                     has_commits: false,
                 }
             });
         }
+        else {
+            // Check if coder seems finished even if orchestrator failed
+            const isTaskComplete = hasCoderCompletionSignal(coderResult.stdout);
+            // Only count as having work if there are actual relevant uncommitted changes,
+            // changed files, or recent commits
+            const hasWork = hasRelevantChanges;
+            if (isTaskComplete && hasWork) {
+                orchestratorOutput = JSON.stringify({
+                    action: has_uncommitted ? 'stage_commit_submit' : 'submit',
+                    reasoning: 'FALLBACK: Orchestrator failed but coder signaled completion',
+                    commits: commits.map(c => c.sha),
+                    next_status: 'review',
+                    metadata: {
+                        files_changed: files_changed.length,
+                        confidence: 'low',
+                        exit_clean: true,
+                        has_commits: commits.length > 0,
+                    }
+                });
+            }
+            else {
+                // Fallback to safe default: retry
+                orchestratorOutput = JSON.stringify({
+                    action: 'retry',
+                    reasoning: 'FALLBACK: Orchestrator failed, defaulting to retry',
+                    commits: [],
+                    next_status: 'in_progress',
+                    metadata: {
+                        files_changed: 0,
+                        confidence: 'low',
+                        exit_clean: true,
+                        has_commits: false,
+                    }
+                });
+            }
+        }
     }
     // STEP 5: Parse orchestrator output with fallback
     const handler = new fallback_handler_js_1.OrchestrationFallbackHandler();
@@ -391,6 +549,90 @@ async function runCoderPhase(db, task, projectPath, action, jsonMode = false, co
             }
         }
     }
+    // Contract-violation handling (structured-first, legacy-prefix fallback).
+    const legacyChecklistViolation = /^CHECKLIST_REQUIRED:/i.test(decision.reasoning || '');
+    const legacyRejectionResponseViolation = /^REJECTION_RESPONSE_REQUIRED:/i.test(decision.reasoning || '');
+    const contractViolation = decision.contract_violation
+        ?? (legacyChecklistViolation ? 'checklist_required' : null)
+        ?? (legacyRejectionResponseViolation ? 'rejection_response_required' : null);
+    if (contractViolation) {
+        const marker = contractViolation === 'checklist_required'
+            ? CONTRACT_CHECKLIST_MARKER
+            : CONTRACT_REJECTION_RESPONSE_MARKER;
+        const reasonText = (decision.reasoning || '')
+            .replace(/^CHECKLIST_REQUIRED:\s*/i, '')
+            .replace(/^REJECTION_RESPONSE_REQUIRED:\s*/i, '')
+            .trim();
+        const cleanReason = reasonText || 'Required output contract not satisfied';
+        const consecutiveContractViolations = countConsecutiveTaggedOrchestratorEntries(db, task.id, marker, '[contract:') + 1;
+        if (consecutiveContractViolations >= MAX_CONTRACT_VIOLATION_RETRIES) {
+            decision = {
+                ...decision,
+                action: 'error',
+                next_status: 'failed',
+                contract_violation: contractViolation,
+                reasoning: `${marker} ${cleanReason} (retry_limit ${consecutiveContractViolations}/${MAX_CONTRACT_VIOLATION_RETRIES})`,
+                metadata: {
+                    ...decision.metadata,
+                    confidence: 'low',
+                    exit_clean: false,
+                },
+            };
+        }
+        else {
+            decision = {
+                ...decision,
+                action: 'retry',
+                next_status: 'in_progress',
+                contract_violation: contractViolation,
+                reasoning: `${marker} ${cleanReason} (retry ${consecutiveContractViolations}/${MAX_CONTRACT_VIOLATION_RETRIES})`,
+                metadata: {
+                    ...decision.metadata,
+                    confidence: 'medium',
+                },
+            };
+        }
+    }
+    // Enforce orchestrator authority over weak/unsupported WONT_FIX claims.
+    const structuredOverrideItems = Array.isArray(decision.wont_fix_override_items)
+        ? decision.wont_fix_override_items.filter(item => typeof item === 'string' && item.trim().length > 0)
+        : [];
+    const legacyWontFixOverrideMatch = (decision.reasoning || '').match(/WONT_FIX_OVERRIDE:\s*([\s\S]+)/i);
+    const fallbackLegacyItems = legacyWontFixOverrideMatch?.[1]
+        ? legacyWontFixOverrideMatch[1]
+            .split('\n')
+            .map(line => line.trim())
+            .filter(Boolean)
+        : [];
+    const overrideItems = structuredOverrideItems.length > 0 ? structuredOverrideItems : fallbackLegacyItems;
+    if (overrideItems.length > 0) {
+        const mandatoryLines = overrideItems.map((item, idx) => `${idx + 1}. ${item}`);
+        const mandatoryGuidance = `MUST_IMPLEMENT:
+${mandatoryLines.join('\n')}
+
+This is a mandatory orchestrator override. Implement these changes before resubmitting.
+Only use WONT_FIX if you provide exceptional technical evidence and the orchestrator explicitly accepts it.`;
+        const persistedNote = `${MUST_IMPLEMENT_MARKER}[rc=${task.rejection_count}] ${mandatoryGuidance}`;
+        (0, queries_js_1.addAuditEntry)(db, task.id, task.status, task.status, 'coordinator', {
+            actorType: 'orchestrator',
+            notes: persistedNote,
+        });
+        coordinatorCache?.set(task.id, {
+            success: true,
+            decision: 'guide_coder',
+            guidance: mandatoryGuidance,
+        });
+        decision = {
+            ...decision,
+            action: 'retry',
+            next_status: 'in_progress',
+            reasoning: `${MUST_IMPLEMENT_MARKER} WONT_FIX override applied`,
+            metadata: {
+                ...decision.metadata,
+                confidence: 'medium',
+            },
+        };
+    }
     // STEP 6: Log orchestrator decision for audit trail
     (0, queries_js_1.addAuditEntry)(db, task.id, task.status, decision.next_status, 'orchestrator', {
         actorType: 'orchestrator',
@@ -399,14 +641,76 @@ async function runCoderPhase(db, task, projectPath, action, jsonMode = false, co
     // STEP 7: Execute the decision
     switch (decision.action) {
         case 'submit':
-            (0, queries_js_1.updateTaskStatus)(db, task.id, 'review', 'orchestrator', decision.reasoning);
+            {
+                const submissionCommitSha = resolveCoderSubmittedCommitSha(projectPath, coderResult.stdout, {
+                    requireExplicitToken: requiresExplicitSubmissionCommit,
+                });
+                if (!submissionCommitSha && requiresExplicitSubmissionCommit) {
+                    (0, queries_js_1.addAuditEntry)(db, task.id, task.status, task.status, 'orchestrator', {
+                        actorType: 'orchestrator',
+                        notes: '[retry] Awaiting explicit SUBMISSION_COMMIT token for commit recovery',
+                    });
+                    if (!jsonMode) {
+                        console.log('\n⟳ Waiting for explicit SUBMISSION_COMMIT token from coder');
+                    }
+                    break;
+                }
+                if (!submissionCommitSha || !(0, status_js_1.isCommitReachable)(projectPath, submissionCommitSha)) {
+                    (0, queries_js_1.updateTaskStatus)(db, task.id, 'failed', 'orchestrator', 'Task failed: cannot submit to review without a valid commit hash');
+                    if (!jsonMode) {
+                        console.log('\n✗ Task failed (submission commit missing or not in workspace)');
+                    }
+                    break;
+                }
+                if (leaseFence?.parallelSessionId) {
+                    const pushResult = (0, push_js_1.pushToRemote)(projectPath, 'origin', branchName);
+                    if (!pushResult.success) {
+                        (0, queries_js_1.updateTaskStatus)(db, task.id, 'failed', 'orchestrator', `Task failed: cannot publish submission commit ${submissionCommitSha} to ${branchName} before review`);
+                        if (!jsonMode) {
+                            console.log('\n✗ Task failed (unable to push submission commit to branch for review)');
+                        }
+                        break;
+                    }
+                }
+                (0, queries_js_1.updateTaskStatus)(db, task.id, 'review', 'orchestrator', decision.reasoning, submissionCommitSha);
+            }
             if (!jsonMode) {
                 console.log(`\n✓ Coder complete, submitted to review (confidence: ${decision.metadata.confidence})`);
             }
             break;
         case 'stage_commit_submit':
             if (!has_uncommitted) {
-                (0, queries_js_1.updateTaskStatus)(db, task.id, 'review', 'orchestrator', 'Auto-commit skipped: no uncommitted changes');
+                const submissionCommitSha = resolveCoderSubmittedCommitSha(projectPath, coderResult.stdout, {
+                    requireExplicitToken: requiresExplicitSubmissionCommit,
+                });
+                if (!submissionCommitSha && requiresExplicitSubmissionCommit) {
+                    (0, queries_js_1.addAuditEntry)(db, task.id, task.status, task.status, 'orchestrator', {
+                        actorType: 'orchestrator',
+                        notes: '[retry] Awaiting explicit SUBMISSION_COMMIT token for commit recovery',
+                    });
+                    if (!jsonMode) {
+                        console.log('\n⟳ Waiting for explicit SUBMISSION_COMMIT token from coder');
+                    }
+                    break;
+                }
+                if (!submissionCommitSha || !(0, status_js_1.isCommitReachable)(projectPath, submissionCommitSha)) {
+                    (0, queries_js_1.updateTaskStatus)(db, task.id, 'failed', 'orchestrator', 'Task failed: cannot submit to review without a valid commit hash');
+                    if (!jsonMode) {
+                        console.log('\n✗ Task failed (submission commit missing or not in workspace)');
+                    }
+                    break;
+                }
+                if (leaseFence?.parallelSessionId) {
+                    const pushResult = (0, push_js_1.pushToRemote)(projectPath, 'origin', branchName);
+                    if (!pushResult.success) {
+                        (0, queries_js_1.updateTaskStatus)(db, task.id, 'failed', 'orchestrator', `Task failed: cannot publish submission commit ${submissionCommitSha} to ${branchName} before review`);
+                        if (!jsonMode) {
+                            console.log('\n✗ Task failed (unable to push submission commit to branch for review)');
+                        }
+                        break;
+                    }
+                }
+                (0, queries_js_1.updateTaskStatus)(db, task.id, 'review', 'orchestrator', 'Auto-commit skipped: no uncommitted changes', submissionCommitSha);
                 if (!jsonMode) {
                     console.log('\n✓ Auto-commit skipped (no uncommitted files) and submitted to review');
                 }
@@ -421,7 +725,25 @@ async function runCoderPhase(db, task, projectPath, action, jsonMode = false, co
                     cwd: projectPath,
                     stdio: 'pipe'
                 });
-                (0, queries_js_1.updateTaskStatus)(db, task.id, 'review', 'orchestrator', `Auto-committed and submitted (${decision.reasoning})`);
+                const submissionCommitSha = (0, status_js_1.getCurrentCommitSha)(projectPath) || undefined;
+                if (!submissionCommitSha || !(0, status_js_1.isCommitReachable)(projectPath, submissionCommitSha)) {
+                    (0, queries_js_1.updateTaskStatus)(db, task.id, 'failed', 'orchestrator', 'Task failed: auto-committed but commit hash is not in current workspace');
+                    if (!jsonMode) {
+                        console.log('\n✗ Task failed (auto-commit hash not in workspace)');
+                    }
+                    break;
+                }
+                if (leaseFence?.parallelSessionId) {
+                    const pushResult = (0, push_js_1.pushToRemote)(projectPath, 'origin', branchName);
+                    if (!pushResult.success) {
+                        (0, queries_js_1.updateTaskStatus)(db, task.id, 'failed', 'orchestrator', `Task failed: cannot publish submission commit ${submissionCommitSha} to ${branchName} before review`);
+                        if (!jsonMode) {
+                            console.log('\n✗ Task failed (unable to push submission commit to branch for review)');
+                        }
+                        break;
+                    }
+                }
+                (0, queries_js_1.updateTaskStatus)(db, task.id, 'review', 'orchestrator', `Auto-committed and submitted (${decision.reasoning})`, submissionCommitSha);
                 if (!jsonMode) {
                     console.log(`\n✓ Auto-committed and submitted to review (confidence: ${decision.metadata.confidence})`);
                 }
@@ -455,6 +777,17 @@ async function runReviewerPhase(db, task, projectPath, jsonMode = false, coordin
     const config = (0, loader_js_1.loadConfig)(projectPath);
     const multiReviewEnabled = (0, reviewer_js_1.isMultiReviewEnabled)(config);
     const strict = config.ai?.review?.strict ?? true;
+    const submissionResolution = (0, submission_resolution_js_1.resolveSubmissionCommitWithRecovery)(projectPath, (0, queries_js_1.getSubmissionCommitShas)(db, task.id));
+    if (submissionResolution.status !== 'resolved') {
+        const attemptsText = submissionResolution.attempts.join(' | ') || 'none';
+        (0, queries_js_1.updateTaskStatus)(db, task.id, 'in_progress', 'orchestrator', `[commit_recovery] Missing reachable submission hash (${submissionResolution.reason}; attempts: ${attemptsText}). ` +
+            `Treating task as resubmission. Coder must output exact line: SUBMISSION_COMMIT: <sha> for the commit that implements the task.`);
+        if (!jsonMode) {
+            console.log('\n⟳ Reviewer hash missing; returning task to coder for hash resubmission');
+        }
+        return;
+    }
+    const submissionCommitSha = submissionResolution.sha;
     let reviewerResult;
     let reviewerResults = [];
     // STEP 1: Invoke reviewer(s)
@@ -692,13 +1025,17 @@ async function runReviewerPhase(db, task, projectPath, jsonMode = false, coordin
         }
         catch (error) {
             console.error('Orchestrator invocation failed:', error);
+            const orchestratorFailure = await classifyOrchestratorFailure(error, projectPath);
             const handler = new fallback_handler_js_1.OrchestrationFallbackHandler();
             const reviewerStdout = reviewerResult?.stdout ?? '';
             const explicitDecision = handler.extractExplicitReviewerDecision(reviewerStdout);
+            const failureReason = orchestratorFailure
+                ? `${orchestratorFailure.type}: ${orchestratorFailure.message}`
+                : summarizeErrorMessage(error);
             if (explicitDecision) {
                 decision = {
                     decision: explicitDecision,
-                    reasoning: `FALLBACK: Orchestrator failed but reviewer explicitly signaled ${explicitDecision.toUpperCase()}`,
+                    reasoning: `FALLBACK: Orchestrator failed (${failureReason}) but reviewer explicitly signaled ${explicitDecision.toUpperCase()}`,
                     notes: reviewerStdout,
                     next_status: explicitDecision === 'approve' ? 'completed' :
                         explicitDecision === 'reject' ? 'in_progress' :
@@ -715,7 +1052,7 @@ async function runReviewerPhase(db, task, projectPath, jsonMode = false, coordin
             else {
                 decision = {
                     decision: 'unclear',
-                    reasoning: 'FALLBACK: Orchestrator failed, retrying review',
+                    reasoning: `FALLBACK: Orchestrator failed (${failureReason}), retrying review`,
                     notes: 'Review unclear, retrying',
                     next_status: 'review',
                     metadata: {
@@ -776,7 +1113,7 @@ async function runReviewerPhase(db, task, projectPath, jsonMode = false, coordin
                         description: followUp.description,
                         sectionId: task.section_id,
                         referenceTaskId: task.id,
-                        referenceCommit: commit_sha || undefined,
+                        referenceCommit: submissionCommitSha,
                         requiresPromotion,
                         depth: nextDepth,
                     });
@@ -795,7 +1132,7 @@ async function runReviewerPhase(db, task, projectPath, jsonMode = false, coordin
         }
     }
     // STEP 6: Execute the decision
-    const commitSha = commit_sha || undefined;
+    const commitSha = submissionCommitSha;
     switch (decision.decision) {
         case 'approve':
             (0, queries_js_1.approveTask)(db, task.id, 'orchestrator', decision.notes, commitSha);