@visorcraft/idlehands 1.4.6 → 2.0.1

package/dist/anton/controller.js

@@ -4,139 +4,154 @@
  * Coordinates all components: parser, prompt, verifier, lock, git, session.
  * Structured as a deterministic orchestration flow for autonomous task execution.
  */
+import * as fs from 'fs';
+import * as path from 'path';
+import { isToolLoopBreak, AUTO_CONTINUE_PROMPT } from '../bot/auto-continue.js';
 import { ensureCleanWorkingTree, getWorkingDiff, commitAll, restoreTrackedChanges, cleanUntracked, createBranch, getUntrackedFiles, removeUntrackedFiles, } from '../git.js';
-import { execute, loadActiveRuntime, runOnHost } from '../runtime/executor.js';
-import { waitForModelsReady } from '../runtime/health.js';
-import { plan } from '../runtime/planner.js';
-import { loadRuntimes } from '../runtime/store.js';
 import { estimateTokens } from '../utils.js';
 import { acquireAntonLock, releaseAntonLock, touchAntonLock } from './lock.js';
 import { parseTaskFile, findRunnablePendingTasks, markTaskChecked, insertSubTasks, autoCompleteAncestors, } from './parser.js';
-import { buildAntonPrompt, parseAntonResult, classifyTaskComplexity } from './prompt.js';
 import { ensureAgentsTasksDir, makeUniqueTaskPlanFilename, buildDiscoveryPrompt, parseDiscoveryResult, buildRequirementsReviewPrompt, parseRequirementsReviewResult, ensurePlanFileExistsOrBootstrap, } from './preflight.js';
+import { buildAntonPrompt, parseAntonResult, classifyTaskComplexity } from './prompt.js';
 import { formatDryRunPlan } from './reporter.js';
+import { classifyInfraError, ensureAntonRuntimeReady } from './runtime-ready.js';
 import { buildSessionConfig, buildPreflightConfig, buildDecomposeConfig, buildVerifyConfig, defaultCreateSession, } from './session.js';
 import { captureLintBaseline, detectVerificationCommands, runVerification } from './verifier.js';
-import { isToolLoopBreak, AUTO_CONTINUE_PROMPT } from '../bot/auto-continue.js';
-function endpointBase(endpoint) {
-    if (!endpoint)
-        return null;
-    const e = endpoint.trim().replace(/\/+$/, '');
-    if (!e)
-        return null;
-    return e.endsWith('/v1') ? e : `${e}/v1`;
-}
-async function probeEndpointReady(endpoint) {
-    const base = endpointBase(endpoint);
-    if (!base)
-        return { ok: false, reason: 'endpoint-not-configured' };
-    const ctrl = new AbortController();
-    const t = setTimeout(() => ctrl.abort(), 7000);
-    try {
-        const res = await fetch(`${base}/models`, { signal: ctrl.signal });
-        if (res.status === 503)
-            return { ok: false, reason: 'loading-http-503' };
-        if (!res.ok)
-            return { ok: false, reason: `http-${res.status}` };
-        return { ok: true, reason: 'ok' };
-    }
-    catch (e) {
-        const msg = String(e?.message ?? e).toLowerCase();
-        if (msg.includes('aborted'))
-            return { ok: false, reason: 'timeout' };
-        return { ok: false, reason: msg.slice(0, 120) };
-    }
-    finally {
-        clearTimeout(t);
+// ─────────────────────────────────────────────────────────────────────────────
+// L2 Retry Enhancement Helpers
+// ─────────────────────────────────────────────────────────────────────────────
+/**
+ * Extract file paths mentioned in an L2 failure reason.
+ * Looks for patterns like: app/Models/Channel.php, src/foo/bar.ts, etc.
+ */
+function extractFilePathsFromL2Reason(reason) {
+    const patterns = [
+        // PHP/Laravel style: app/Models/Channel.php, app/Http/Controllers/Foo.php
+        /\b(app\/[\w\/]+\.php)\b/gi,
+        // General file paths with extensions
+        /\b((?:src|lib|tests?)\/[\w\/.-]+\.\w+)\b/gi,
+        // Model names that can be mapped to files: "Channel model" -> app/Models/Channel.php
+        /\b(\w+)\s+model\b/gi,
+    ];
+    const found = new Set();
+    for (const pattern of patterns) {
+        const matches = reason.matchAll(pattern);
+        for (const match of matches) {
+            const p = match[1];
+            // If it's a model name reference like "Channel model", convert to path
+            if (/model$/i.test(match[0]) && !/\.php$/i.test(p)) {
+                found.add(`app/Models/${p}.php`);
+            }
+            else {
+                found.add(p);
+            }
+        }
     }
+    return [...found];
 }
-function classifyInfraError(err) {
-    const msg = String(err?.message ?? err ?? '').toLowerCase();
-    if (!msg)
-        return 'other';
-    if (msg.includes('aborted') || msg.includes('cancel'))
-        return 'other';
-    if (msg.includes('503') || msg.includes('model is loading') || msg.includes('loading')) {
-        return 'loading';
-    }
-    const infraPatterns = [
-        'econnrefused',
-        'could not connect',
-        'connection refused',
-        'enotfound',
-        'fetch failed',
-        'connect timeout',
-        'socket hang up',
-        'no models found',
-        'endpoint',
+/**
+ * Detect if L2 reason indicates a "missing implementation" pattern.
+ * Returns true if the model wrote tests but forgot the actual implementation.
+ */
+function isL2MissingImplementation(reason) {
+    const missingPatterns = [
+        /missing\s+(?:from|in)\s+/i,
+        /no\s+(?:corresponding|evidence|actual)/i,
+        /relationship\s+(?:method\s+)?is\s+missing/i,
+        /but\s+(?:the|there['']?s?\s+no)/i,
+        /tests?\s+(?:expect|added|written).*but/i,
+        /should\s+be\s+(?:hasMany|hasOne|belongsTo|morphMany)/i,
     ];
-    if (infraPatterns.some((p) => msg.includes(p))) {
-        return 'infra_down';
-    }
-    return 'other';
+    return missingPatterns.some((p) => p.test(reason));
 }
-async function ensureAntonRuntimeReady(idlehandsConfig, opts) {
-    const endpointProbe = await probeEndpointReady(idlehandsConfig.endpoint);
-    if (endpointProbe.ok)
-        return { ok: true, detail: 'endpoint-ready' };
-    // Try runtime orchestration recovery when endpoint probe fails.
-    let rtConfig;
+/**
+ * Try to read a file's contents for injection into retry context.
+ * Returns null if file doesn't exist or is too large.
+ */
+function readFileForL2Injection(projectDir, filePath) {
+    const MAX_FILE_SIZE = 15000; // ~15KB, reasonable for injection
     try {
-        rtConfig = await loadRuntimes();
+        const fullPath = path.resolve(projectDir, filePath);
+        if (!fs.existsSync(fullPath))
+            return null;
+        const stat = fs.statSync(fullPath);
+        if (stat.size > MAX_FILE_SIZE)
+            return null;
+        return fs.readFileSync(fullPath, 'utf8');
     }
     catch {
-        return {
-            ok: false,
-            detail: `endpoint-not-ready (${endpointProbe.reason}); runtimes-unavailable`,
-        };
-    }
-    const active = await loadActiveRuntime();
-    let targetModelId;
-    if (active?.modelId && rtConfig.models.some((m) => m.id === active.modelId && m.enabled)) {
-        targetModelId = active.modelId;
-    }
-    else if (typeof idlehandsConfig.model === 'string' &&
-        rtConfig.models.some((m) => m.id === idlehandsConfig.model && m.enabled)) {
-        targetModelId = idlehandsConfig.model;
-    }
-    if (!targetModelId) {
-        return {
-            ok: false,
-            detail: `endpoint-not-ready (${endpointProbe.reason}); no-runtime-model-mapping`,
-        };
+        return null;
     }
-    const planOut = plan({ modelId: targetModelId, mode: 'live', forceRestart: opts.forceRestart }, rtConfig, active);
-    if (!planOut.ok) {
-        return { ok: false, detail: `runtime-plan-failed ${planOut.code}: ${planOut.reason}` };
+}
+/**
+ * Build enhanced retry context when L2 fails due to missing implementation.
+ * - On first L2 failure: Add strong guidance about which files to modify
+ * - On 2+ L2 failures: Inject the actual file contents so model can see what's missing
+ */
+function buildL2EnhancedRetryContext(l2Reason, l2FailCount, projectDir, taskText) {
+    const parts = [];
+    const filePaths = extractFilePathsFromL2Reason(l2Reason);
+    const isMissingImpl = isL2MissingImplementation(l2Reason);
+    if (!isMissingImpl || filePaths.length === 0) {
+        // Not a "missing implementation" pattern, no enhancement needed
+        return '';
     }
-    const execRes = await execute(planOut, {
-        force: true,
-        confirm: async () => true,
-    });
-    if (!execRes.ok) {
-        return { ok: false, detail: `runtime-exec-failed: ${execRes.error ?? 'unknown'}` };
+    parts.push('');
+    parts.push('═══════════════════════════════════════════════════════════════════════');
+    parts.push('⚠️  CRITICAL: AI REVIEW FAILED — MISSING IMPLEMENTATION DETECTED');
+    parts.push('═══════════════════════════════════════════════════════════════════════');
+    parts.push('');
+    parts.push(`The AI review found that you wrote tests but FORGOT THE ACTUAL IMPLEMENTATION.`);
+    parts.push(`Task: "${taskText}"`);
+    parts.push('');
+    parts.push('YOU MUST MODIFY THESE FILES:');
+    for (const fp of filePaths) {
+        parts.push(`  → ${fp}`);
     }
-    const timeoutMs = Math.max(10_000, opts.timeoutMs ?? (planOut.model.launch.probe_timeout_sec ?? 600) * 1000);
-    for (const resolvedHost of planOut.hosts) {
-        const hostCfg = rtConfig.hosts.find((h) => h.id === resolvedHost.id);
-        if (!hostCfg)
-            continue;
-        const ready = await waitForModelsReady(runOnHost, hostCfg, planOut.model.runtime_defaults?.port ?? 8080, {
-            timeoutMs,
-            intervalMs: planOut.model.launch.probe_interval_ms ?? 2000,
-        });
-        if (!ready.ok) {
-            return {
-                ok: false,
-                detail: `wait-ready failed on ${resolvedHost.id}: ${ready.reason ?? 'timeout'}`,
-            };
+    parts.push('');
+    // After 2+ identical L2 failures, inject file contents
+    if (l2FailCount >= 2) {
+        parts.push('Since you have failed this verification multiple times, here are the current');
+        parts.push('contents of the files you need to modify:');
+        parts.push('');
+        for (const fp of filePaths) {
+            const contents = readFileForL2Injection(projectDir, fp);
+            if (contents !== null) {
+                parts.push(`┌─── ${fp} ───`);
+                parts.push(contents);
+                parts.push(`└─── end of ${fp} ───`);
+                parts.push('');
+            }
+            else {
+                parts.push(`[Could not read ${fp} — file may not exist or is too large]`);
+                parts.push('');
+            }
         }
     }
-    return { ok: true, detail: 'runtime-ready' };
+    parts.push('INSTRUCTIONS:');
+    parts.push('1. READ the files listed above (they are your existing code)');
+    parts.push('2. ADD the missing method/relationship to the model file');
+    parts.push('3. Do NOT just modify tests — the MODEL/SOURCE file must change');
+    parts.push('4. The L2 review expects to see your implementation in the diff');
+    parts.push('');
+    return parts.join('\n');
+}
+const STRUCTURED_RESULT_RECOVERY_PROMPT = `Your previous reply did not include a valid <anton-result> block.
+Do NOT call tools.
+Return ONLY this block shape and nothing else:
+<anton-result>
+status: done|failed|blocked|decompose
+reason: <optional>
+subtasks:
+- <only when status=decompose>
+</anton-result>`;
+function isStructuredResultParseFailure(reason) {
+    if (!reason)
+        return false;
+    return (reason === 'Agent did not emit structured result' ||
+        reason === 'No status line found in result block' ||
+        reason.startsWith('Unknown status:'));
 }
-/**
- * Main Anton orchestrator.
- */
 export async function runAnton(opts) {
     const { config, idlehandsConfig, progress, abortSignal, apiKey, vault, lens } = opts;
     const createSessionFn = opts.createSession || defaultCreateSession;
@@ -153,6 +168,7 @@ export async function runAnton(opts) {
     const taskRetryCount = new Map();
     const lastFailureReason = new Map();
     const consecutiveIdenticalCount = new Map();
+    const l2FailCount = new Map(); // Track consecutive L2 failures per task
     let lockHeartbeatTimer = null;
     // SIGINT handler
     const handleAbort = () => {
@@ -253,8 +269,15 @@ export async function runAnton(opts) {
                         parts.push('- Test command failed');
                     if (v.l1_lint === false)
                         parts.push('- Lint command failed');
-                    if (v.l2_ai === false && v.l2_reason)
+                    if (v.l2_ai === false && v.l2_reason) {
                         parts.push(`- AI review: ${v.l2_reason}`);
+                        // Enhanced L2 retry context: stronger guidance + file injection on repeated failures
+                        const currentL2Count = l2FailCount.get(currentTask.key) || 0;
+                        const l2Enhancement = buildL2EnhancedRetryContext(v.l2_reason, currentL2Count, config.projectDir, currentTask.text);
+                        if (l2Enhancement) {
+                            parts.push(l2Enhancement);
+                        }
+                    }
                     // Include error output (filtered to errors only, no warnings) so the
                     // agent can see and fix the exact issues.
                     if (v.commandOutput) {
@@ -351,6 +374,9 @@ export async function runAnton(opts) {
                 continue;
             }
             const attemptNumber = retries + 1;
+            // Publish active task context early so /anton status + heartbeat keep working
+            // during preflight stages (discovery/review), not only implementation.
+            progress.onTaskStart(currentTask, attemptNumber, currentProgress);
             // Optional preflight pipeline: discovery -> requirements review.
             // Runs on first attempt for each task. Retries are stage-local to avoid churn.
             if (config.preflightEnabled && retries === 0) {
@@ -361,6 +387,7 @@ export async function runAnton(opts) {
                 await ensureAgentsTasksDir(config.projectDir);
                 const plannedFilePath = taskPlanByTaskKey.get(currentTask.key) ?? makeUniqueTaskPlanFilename(config.projectDir);
                 let discoveryIterationCap = Math.max(1, Math.floor(config.preflightSessionMaxIterations ?? 500));
+                let discoveryRetryHint;
                 // Stage 1: discovery (retry discovery only).
                 for (let discoveryTry = 0; discoveryTry <= preflightMaxRetries; discoveryTry++) {
                     const stageStart = Date.now();
@@ -375,18 +402,22 @@ export async function runAnton(opts) {
                             taskFilePath: config.taskFile,
                             projectDir: config.projectDir,
                             planFilePath: plannedFilePath,
+                            retryHint: discoveryRetryHint,
                         });
+                        let discoveryTimeoutHandle;
                         const discoveryRes = await Promise.race([
-                            discoverySession.ask(discoveryPrompt),
-                            new Promise((_, reject) => setTimeout(() => {
-                                try {
-                                    discoverySession?.cancel();
-                                }
-                                catch {
-                                    // best effort
-                                }
-                                reject(new Error('preflight-discovery-timeout'));
-                            }, discoveryTimeoutMs)),
+                            discoverySession.ask(discoveryPrompt).finally(() => clearTimeout(discoveryTimeoutHandle)),
+                            new Promise((_, reject) => {
+                                discoveryTimeoutHandle = setTimeout(() => {
+                                    try {
+                                        discoverySession?.cancel();
+                                    }
+                                    catch {
+                                        // best effort
+                                    }
+                                    reject(new Error('preflight-discovery-timeout'));
+                                }, discoveryTimeoutMs);
+                            }),
                         ]);
                         const discoveryTokens = discoverySession.usage.prompt + discoverySession.usage.completion;
                         totalTokens += discoveryTokens;
@@ -432,8 +463,9 @@ export async function runAnton(opts) {
                             status: timeout ? 'timeout' : 'error',
                             error: errMsg,
                         });
+                        const short = errMsg.length > 180 ? `${errMsg.slice(0, 177)}...` : errMsg;
+                        discoveryRetryHint = `Previous discovery attempt failed: ${short}. Do not edit source files. Only update ${plannedFilePath} and return strict JSON.`;
                         if (discoveryTry < preflightMaxRetries) {
-                            const short = errMsg.length > 180 ? `${errMsg.slice(0, 177)}...` : errMsg;
                             if (/max iterations exceeded/i.test(errMsg)) {
                                 const nextCap = Math.min(Math.max(discoveryIterationCap * 2, discoveryIterationCap + 2), 1000);
                                 if (nextCap > discoveryIterationCap) {
@@ -445,21 +477,22 @@ export async function runAnton(opts) {
                             progress.onStage?.(`⚠️ Discovery failed (${discoveryTry + 1}/${preflightTotalTries}): ${short}. Retrying discovery...`);
                             continue;
                         }
-                        const preflightAttempt = {
-                            taskKey: currentTask.key,
-                            taskText: currentTask.text,
-                            attempt: attemptNumber,
-                            durationMs: Date.now() - stageStart,
-                            tokensUsed: 0,
-                            status: timeout ? 'timeout' : 'error',
-                            verification: undefined,
-                            error: `preflight-error(discovery): ${errMsg}`,
-                            commitHash: undefined,
-                        };
-                        attempts.push(preflightAttempt);
-                        taskRetryCount.set(currentTask.key, retries + 1);
-                        if (!config.skipOnFail)
-                            break mainLoop;
+                        // Final discovery failure: degrade gracefully by bootstrapping a fallback plan file
+                        // so Anton can still proceed to implementation/review instead of hard-failing task 1.
+                        const fallbackState = await ensurePlanFileExistsOrBootstrap({
+                            absPath: plannedFilePath,
+                            task: currentTask,
+                            source: 'discovery',
+                        });
+                        if (fallbackState === 'bootstrapped') {
+                            progress.onStage?.(`⚠️ Discovery failed after ${preflightTotalTries} tries (${short}). Bootstrapped fallback plan and continuing: ${plannedFilePath}`);
+                        }
+                        else {
+                            progress.onStage?.(`⚠️ Discovery failed after ${preflightTotalTries} tries (${short}). Reusing existing plan and continuing: ${plannedFilePath}`);
+                        }
+                        taskPlanByTaskKey.set(currentTask.key, plannedFilePath);
+                        discoveryOk = true;
+                        break;
                     }
                     finally {
                         try {
@@ -491,17 +524,20 @@ export async function runAnton(opts) {
                             progress.onStage?.('🧪 Requirements review: refining plan...');
                             reviewSession = await createSessionFn(buildPreflightConfig(idlehandsConfig, config, reviewTimeoutSec, reviewIterationCap), apiKey);
                             const reviewPrompt = buildRequirementsReviewPrompt(reviewPlanFile);
+                            let reviewTimeoutHandle;
                             const reviewRes = await Promise.race([
-                                reviewSession.ask(reviewPrompt),
-                                new Promise((_, reject) => setTimeout(() => {
-                                    try {
-                                        reviewSession?.cancel();
-                                    }
-                                    catch {
-                                        // best effort
-                                    }
-                                    reject(new Error('preflight-review-timeout'));
-                                }, reviewTimeoutMs)),
+                                reviewSession.ask(reviewPrompt).finally(() => clearTimeout(reviewTimeoutHandle)),
+                                new Promise((_, reject) => {
+                                    reviewTimeoutHandle = setTimeout(() => {
+                                        try {
+                                            reviewSession?.cancel();
+                                        }
+                                        catch {
+                                            // best effort
+                                        }
+                                        reject(new Error('preflight-review-timeout'));
+                                    }, reviewTimeoutMs);
+                                }),
                             ]);
                             const reviewTokens = reviewSession.usage.prompt + reviewSession.usage.completion;
                             totalTokens += reviewTokens;
@@ -582,7 +618,6 @@ export async function runAnton(opts) {
                 }
             }
             progress.onStage?.('🛠️ Implementation: executing vetted plan...');
-            progress.onTaskStart(currentTask, attemptNumber, currentProgress);
             let session;
             let attempt;
             const taskComplexity = classifyTaskComplexity(currentTask.text);
@@ -650,8 +685,7 @@ export async function runAnton(opts) {
                         if (effectiveRetryContext) {
                             if (trimPass === 0) {
                                 // First trim: cut command output to 1000 chars
-                                effectiveRetryContext = effectiveRetryContext
-                                    .replace(/=== Full error output from failed commands ===[\s\S]*?=== End of error output ===/, (m) => {
+                                effectiveRetryContext = effectiveRetryContext.replace(/=== Full error output from failed commands ===[\s\S]*?=== End of error output ===/, (m) => {
                                     const inner = m.slice(m.indexOf('===\n') + 4, m.lastIndexOf('\n==='));
                                     return `=== Error output (trimmed) ===\n${inner.slice(0, 1000)}\n...(truncated)\n=== End of error output ===`;
                                 });
@@ -659,8 +693,7 @@ export async function runAnton(opts) {
                             }
                             else if (trimPass === 1) {
                                 // Second trim: drop command output entirely, keep just summary
-                                effectiveRetryContext = effectiveRetryContext
-                                    .replace(/\n*=== (Full e|E)rror output[\s\S]*?=== End of error output ===\n*/, '\n(Full error output omitted due to prompt budget — run the lint/test command to see errors)\n');
+                                effectiveRetryContext = effectiveRetryContext.replace(/\n*=== (Full e|E)rror output[\s\S]*?=== End of error output ===\n*/, '\n(Full error output omitted due to prompt budget — run the lint/test command to see errors)\n');
                                 console.error(`[anton:budget] trimPass=2: dropped retry command output entirely`);
                             }
                             else {
@@ -685,16 +718,20 @@ export async function runAnton(opts) {
                             try {
                                 progress.onToolLoop?.(currentTask.text, event);
                             }
-                            catch { /* best effort */ }
+                            catch {
+                                /* best effort */
+                            }
                         },
                         onCompaction: (event) => {
                             try {
                                 progress.onCompaction?.(currentTask.text, event);
                             }
-                            catch { /* best effort */ }
+                            catch {
+                                /* best effort */
+                            }
                         },
                         onTurnEnd: (stats) => {
-                            const tokens = session ? (session.usage.prompt + session.usage.completion) : 0;
+                            const tokens = session ? session.usage.prompt + session.usage.completion : 0;
                             console.error(`[anton:turn] task="${currentTask.text.slice(0, 40)}" turn=${stats.turn} toolCalls=${stats.toolCalls} tokens=${tokens}`);
                         },
                     };
@@ -768,17 +805,41 @@ export async function runAnton(opts) {
                     }
                     const taskEndMs = Date.now();
                     const durationMs = taskEndMs - taskStartMs;
-                    const tokensUsed = session.usage.prompt + session.usage.completion;
+                    let tokensUsed = session.usage.prompt + session.usage.completion;
+                    // Parse structured result (with one-shot recovery for format-only failures).
+                    let agentResult = parseAntonResult(result.text);
+                    if (agentResult.status === 'blocked' &&
+                        isStructuredResultParseFailure(agentResult.reason) &&
+                        !abortSignal.aborted &&
+                        !controller.signal.aborted) {
+                        try {
+                            progress.onStage?.('⚠️ Agent omitted structured result. Requesting format-only recovery...');
+                            const repaired = await session.ask(STRUCTURED_RESULT_RECOVERY_PROMPT);
+                            iterationsUsed += repaired.turns;
+                            agentResult = parseAntonResult(repaired.text);
+                            tokensUsed = session.usage.prompt + session.usage.completion;
+                        }
+                        catch (repairErr) {
+                            console.error(`[anton:result-recovery] failed: ${repairErr}`);
+                        }
+                    }
+                    // If result is still parse-broken, treat as failed (retriable) instead of blocked (terminal).
+                    if (agentResult.status === 'blocked' && isStructuredResultParseFailure(agentResult.reason)) {
+                        agentResult = {
+                            status: 'failed',
+                            reason: `structured-result-parse-failure: ${agentResult.reason}`,
+                            subtasks: [],
+                        };
+                    }
                     // Per-attempt token cost guardrail (not just prompt size).
                     if (tokensUsed > config.maxPromptTokensPerAttempt) {
                         throw new Error(`attempt-token-budget-exceeded: used=${tokensUsed} max=${config.maxPromptTokensPerAttempt}`);
                     }
-                    // Parse structured result
-                    const agentResult = parseAntonResult(result.text);
                     console.error(`[anton:result] task="${currentTask.text.slice(0, 50)}" status=${agentResult.status} reason=${agentResult.reason ?? 'none'} subtasks=${agentResult.subtasks.length} tokens=${tokensUsed} duration=${Math.round(durationMs / 1000)}s`);
                     if (isComplexDecompose) {
                         console.error(`[anton:debug] decompose result: status=${agentResult.status} subtasks=${agentResult.subtasks.length} reason=${agentResult.reason ?? 'none'}`);
-                        if (agentResult.status === 'blocked' && agentResult.reason === 'Agent did not emit structured result') {
+                        if (agentResult.status === 'failed' &&
+                            (agentResult.reason ?? '').startsWith('structured-result-parse-failure')) {
                             console.error(`[anton:debug] decompose raw output (first 500 chars): ${(result.text ?? '').slice(0, 500)}`);
                         }
                     }
@@ -858,7 +919,9 @@ export async function runAnton(opts) {
                         try {
                             progress.onVerification?.(currentTask.text, verification);
                         }
-                        catch { /* best effort */ }
+                        catch {
+                            /* best effort */
+                        }
                         if (verification.passed) {
                             status = 'passed';
                             if (config.autoCommit) {
@@ -989,6 +1052,15 @@ export async function runAnton(opts) {
                     consecutiveIdenticalCount.set(currentTask.key, 1);
                 }
                 lastFailureReason.set(currentTask.key, currentReason);
+                // Track L2-specific failures for enhanced retry context
+                if (attempt.verification?.l2_ai === false) {
+                    l2FailCount.set(currentTask.key, (l2FailCount.get(currentTask.key) || 0) + 1);
+                    console.error(`[anton:l2-fail] task="${currentTask.text.slice(0, 40)}" l2_fail_count=${l2FailCount.get(currentTask.key)}`);
+                }
+            }
+            else {
+                // Task passed — reset L2 fail count
+                l2FailCount.delete(currentTask.key);
             }
             // Report task end
             progress.onTaskEnd(currentTask, attempt, currentProgress);
@@ -1002,7 +1074,7 @@ export async function runAnton(opts) {
             // break when maxRetriesPerTask is reached (if skipOnFail is false).
             // Previously this broke immediately on the first failure, preventing
             // the AI from fixing verification errors (e.g. lint) on retry.
-            const isFail = (attempt.status === 'failed' || attempt.status === 'error');
+            const isFail = attempt.status === 'failed' || attempt.status === 'error';
             if (isFail && !config.skipOnFail) {
                 const retries = taskRetryCount.get(currentTask.key) || 0;
                 if (retries >= config.maxRetriesPerTask) {