pulseed 0.0.1 → 0.1.1

package/dist/execution/task-verifier.js

@@ -0,0 +1,823 @@
+/**
+ * task-verifier.ts
+ *
+ * Verification logic extracted from TaskLifecycle:
+ *   - verifyTask
+ *   - handleVerdict
+ *   - handleFailure
+ *
+ * All functions are standalone and receive explicit dependencies instead of
+ * relying on `this`. TaskLifecycle keeps thin wrapper methods for backward
+ * compatibility.
+ */
+import { z } from "zod";
+import { VerificationResultSchema } from "../types/task.js";
+import { wrapXmlTag, formatKnowledge } from "../prompt/formatters.js";
+import { analyzeImpact } from "./impact-analyzer.js";
+// ─── CompletionJudgerResponseSchema: Zod schema for LLM completion judgment response ───
+const CompletionJudgerResponseSchema = z.object({
+    verdict: z.enum(["pass", "partial", "fail"]).default("fail"),
+    reasoning: z.string().default(""),
+    criteria_met: z.number().int().min(0).optional(),
+    criteria_total: z.number().int().min(0).optional(),
+});
+// ─── verifyTask ───
+/**
+ * Verify task execution results using 3-layer verification.
+ *
+ * Layer 1: Mechanical verification (via adapter in review session)
+ * Layer 2: LLM task reviewer (independent, no self-report)
+ * Layer 3: Executor self-report (reference only)
+ *
+ * Contradiction resolution:
+ * - L1 PASS + L2 PASS → pass
+ * - L1 PASS + L2 FAIL → re-review; if still FAIL → fail
+ * - L1 FAIL + L2 PASS → fail (mechanical priority)
+ * - L1 FAIL + L2 FAIL → fail
+ * - L1 SKIP → use L2 only (lower confidence)
+ */
+export async function verifyTask(deps, task, executionResult) {
+    // ─── Short-circuit: GitHub issue URL evidence ───
+    // When execution succeeded and output contains a GitHub issue URL,
+    // treat as mechanical pass without running full L1/L2 verification.
+    // Dimension updates are left to ObservationEngine (next loop iteration).
+    const githubIssueUrlPattern = /github\.com\/.+\/issues\/\d+/;
+    if (executionResult.success === true &&
+        executionResult.output &&
+        githubIssueUrlPattern.test(executionResult.output)) {
+        const scResult = VerificationResultSchema.parse({
+            task_id: task.id,
+            verdict: "pass",
+            confidence: 0.95,
+            evidence: [
+                {
+                    layer: "mechanical",
+                    description: "GitHub issue URL found in execution output — mechanical evidence of successful issue creation",
+                    confidence: 0.95,
+                },
+            ],
+            dimension_updates: [],
+            timestamp: new Date().toISOString(),
+        });
+        return scResult;
+    }
+    // ─── Layer 1: Mechanical verification ───
+    const l1Result = await runMechanicalVerification(deps, task);
+    // ─── Build optional enrichment blocks for LLM review ───
+    let knowledgeBlock = "";
+    if (deps.knowledgeManager?.getRelevantKnowledge) {
+        try {
+            const entries = await deps.knowledgeManager.getRelevantKnowledge(task.goal_id);
+            if (entries.length > 0) {
+                knowledgeBlock = wrapXmlTag("relevant_knowledge", formatKnowledge(entries.map((e) => ({ question: e.question, answer: e.answer, confidence: e.confidence }))));
+            }
+        }
+        catch { /* knowledge enrichment is optional */ }
+    }
+    let stateBlock = "";
+    try {
+        const goalDataForState = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
+        if (goalDataForState && typeof goalDataForState === "object") {
+            const dims = goalDataForState.dimensions;
+            const primaryDim = dims?.find((d) => d.name === task.primary_dimension);
+            if (primaryDim) {
+                const currentValue = typeof primaryDim.current_value === "number" ? primaryDim.current_value : undefined;
+                const threshold = primaryDim.threshold;
+                if (currentValue !== undefined) {
+                    stateBlock = wrapXmlTag("current_state", `Dimension: ${task.primary_dimension}, current value: ${currentValue}${threshold !== undefined ? `, target: ${JSON.stringify(threshold)}` : ""}`);
+                }
+            }
+        }
+    }
+    catch { /* state enrichment is optional */ }
+    // ─── Layer 2: LLM task reviewer (independent) ───
+    const l2Result = await runLLMReview(deps, task, executionResult, knowledgeBlock, stateBlock);
+    // ─── Layer 3: Executor self-report (reference only) ───
+    const executorReport = parseExecutorReport(executionResult);
+    // ─── Contradiction resolution ───
+    let verdict;
+    let confidence;
+    let l2Retry;
+    if (l1Result.applicable) {
+        if (l1Result.passed && l2Result.passed) {
+            verdict = "pass";
+            confidence = 0.9;
+        }
+        else if (l1Result.passed && l2Result.partial) {
+            // L1 pass + L2 partial → partial
+            verdict = "partial";
+            confidence = 0.7;
+        }
+        else if (l1Result.passed && !l2Result.passed && !l2Result.partial) {
+            // L1 pass + L2 fail → re-review
+            l2Retry = await runLLMReview(deps, task, executionResult, knowledgeBlock, stateBlock, 'main');
+            if (l2Retry.passed) {
+                verdict = "pass";
+                confidence = 0.75;
+            }
+            else if (l2Retry.partial) {
+                verdict = "partial";
+                confidence = 0.65;
+            }
+            else {
+                verdict = "fail";
+                confidence = 0.8;
+            }
+        }
+        else if (!l1Result.passed && l2Result.passed) {
+            // Mechanical verification takes priority
+            verdict = "fail";
+            confidence = 0.85;
+        }
+        else {
+            // Both fail (or L1 fail + L2 partial → fail, mechanical priority)
+            verdict = "fail";
+            confidence = 0.9;
+        }
+    }
+    else {
+        // L1 skipped — use L2 only with lower confidence
+        if (l2Result.passed) {
+            verdict = "pass";
+            confidence = 0.6;
+        }
+        else if (l2Result.partial) {
+            verdict = "partial";
+            confidence = 0.5;
+        }
+        else {
+            verdict = "fail";
+            confidence = 0.6;
+        }
+    }
+    // Handle partial from L2 when L1 is applicable but didn't fail
+    if (l1Result.applicable && l2Result.partial && verdict !== "fail") {
+        verdict = "partial";
+    }
+    // Use retry result for evidence when a retry occurred, to keep audit trail accurate
+    const effectiveL2 = l2Retry ?? l2Result;
+    const now = new Date().toISOString();
+    const evidence = [
+        ...(l1Result.applicable
+            ? [
+                {
+                    layer: "mechanical",
+                    description: l1Result.description,
+                    confidence: 0.9,
+                },
+            ]
+            : []),
+        {
+            layer: "independent_review",
+            description: effectiveL2.description,
+            confidence: effectiveL2.confidence,
+        },
+        {
+            layer: "self_report",
+            description: executorReport.summary,
+            confidence: 0.3, // self-report has lowest confidence
+        },
+    ];
+    // Build dimension_updates from task's target dimensions based on verdict.
+    // pass: significant progress (+0.2), partial: moderate progress (+0.15), fail: no update.
+    const progressByVerdict = {
+        pass: 0.2,
+        partial: 0.15,
+        fail: 0,
+    };
+    const progressDelta = progressByVerdict[verdict] ?? 0;
+    // Read goal state to get actual current dimension values for previous_value / new_value.
+    const goalDataForUpdate = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
+    const goalDimsForUpdate = goalDataForUpdate && typeof goalDataForUpdate === "object"
+        ? goalDataForUpdate.dimensions
+        : undefined;
+    const dimension_updates = verdict === "fail"
+        ? []
+        : task.target_dimensions.map((dimName) => {
+            const dim = goalDimsForUpdate?.find((d) => d.name === dimName);
+            const prevVal = dim !== undefined && typeof dim.current_value === "number"
+                ? dim.current_value
+                : null;
+            const newVal = prevVal !== null
+                ? Math.min(1, Math.max(0, prevVal + progressDelta))
+                : progressDelta;
+            return {
+                dimension_name: dimName,
+                previous_value: prevVal,
+                new_value: newVal,
+                confidence,
+            };
+        });
+    const verificationResult = VerificationResultSchema.parse({
+        task_id: task.id,
+        verdict,
+        confidence,
+        evidence,
+        dimension_updates,
+        timestamp: now,
+    });
+    // Post-verification: analyze impact for unintended side effects (opt-in)
+    let impactAnalysis;
+    if (deps.enableImpactAnalysis)
+        try {
+            impactAnalysis = await analyzeImpact({ llmClient: deps.llmClient, logger: deps.logger }, {
+                taskDescription: task.work_description,
+                taskOutput: executionResult.output,
+                verificationVerdict: verdict,
+                targetScope: task.scope_boundary.in_scope,
+            });
+            if (impactAnalysis.side_effects.length > 0) {
+                deps.logger?.warn("[task-verifier] Impact analysis detected side effects", {
+                    verdict: impactAnalysis.verdict,
+                    side_effects: impactAnalysis.side_effects,
+                    confidence: impactAnalysis.confidence,
+                });
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            deps.logger?.warn("[task-verifier] Impact analysis failed (non-fatal)", { error: msg });
+        }
+    // Persist verification result — include criteria fields from LLM review for failure context
+    await deps.stateManager.writeRaw(`verification/${task.id}/verification-result.json`, {
+        ...verificationResult,
+        criteria_met: effectiveL2.criteria_met,
+        criteria_total: effectiveL2.criteria_total,
+        impact_analysis: impactAnalysis,
+    });
+    return verificationResult;
+}
+// ─── handleVerdict ───
+/**
+ * Handle a verification verdict (pass/partial/fail).
+ */
+export async function handleVerdict(deps, task, verificationResult) {
+    // P0: Progress-verdict contradiction check (§4.1)
+    // If dimension values worsened but verdict is "pass", override to "partial"
+    // "Worsened" is threshold-type-aware: min-type expects increase, max-type expects decrease.
+    if (verificationResult.verdict === "pass" && verificationResult.dimension_updates?.length > 0) {
+        // Load goal dimensions to determine threshold type per dimension
+        const goalRawForGuard = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
+        const goalDimsForGuard = (goalRawForGuard &&
+            typeof goalRawForGuard === "object" &&
+            Array.isArray(goalRawForGuard.dimensions)
+            ? goalRawForGuard.dimensions
+            : []);
+        const anyWorsened = verificationResult.dimension_updates.some((u) => {
+            const prev = typeof u.previous_value === "number" ? u.previous_value : null;
+            const next = typeof u.new_value === "number" ? u.new_value : null;
+            if (prev === null || next === null)
+                return false;
+            // Determine threshold type for this dimension
+            const dimMeta = goalDimsForGuard.find((d) => d.name === u.dimension_name);
+            const thresholdType = dimMeta && typeof dimMeta.threshold === "object" && dimMeta.threshold !== null
+                ? dimMeta.threshold.type
+                : undefined;
+            // For min-type: lower value is worse (decrease = worsened)
+            // For max-type: higher value is worse (increase = worsened)
+            // For range/present/match or unknown: skip (can't determine direction safely)
+            if (thresholdType === "min") {
+                return next < prev - 0.05;
+            }
+            else if (thresholdType === "max") {
+                return next > prev + 0.05;
+            }
+            return false;
+        });
+        if (anyWorsened) {
+            deps.logger?.warn("progress-verdict contradiction: dimension value moved away from target but verdict was pass. Overriding to partial.");
+            verificationResult = { ...verificationResult, verdict: "partial" };
+        }
+    }
+    // Save failure context for fail/partial verdicts (§4.7)
+    if (verificationResult.verdict === "fail" || verificationResult.verdict === "partial") {
+        const firstEvidence = verificationResult.evidence?.[0];
+        const reasoning = typeof firstEvidence?.description === "string" ? firstEvidence.description : "";
+        // Read criteria_met/criteria_total from the persisted verification result (written by verifyTask)
+        let criteria_met;
+        let criteria_total;
+        try {
+            const raw = await deps.stateManager.readRaw(`verification/${task.id}/verification-result.json`);
+            if (raw && typeof raw.criteria_met === "number")
+                criteria_met = raw.criteria_met;
+            if (raw && typeof raw.criteria_total === "number")
+                criteria_total = raw.criteria_total;
+        }
+        catch {
+            // Non-fatal: criteria fields are best-effort
+        }
+        const failureContext = {
+            prev_task_description: task.work_description,
+            verdict: verificationResult.verdict,
+            reasoning,
+            criteria_met,
+            criteria_total,
+            timestamp: new Date().toISOString(),
+        };
+        try {
+            await deps.stateManager.writeRaw(`tasks/${task.goal_id}/last-failure-context.json`, failureContext);
+        }
+        catch {
+            // Non-fatal: failure context saving is best-effort
+        }
+    }
+    switch (verificationResult.verdict) {
+        case "pass": {
+            // Clear stale failure context (pass means previous failures are no longer relevant)
+            try {
+                await deps.stateManager.writeRaw(`tasks/${task.goal_id}/last-failure-context.json`, null);
+            }
+            catch {
+                // Non-fatal: clearing failure context is best-effort
+            }
+            // Record success
+            deps.trustManager.recordSuccess(task.task_category);
+            const now = new Date().toISOString();
+            // Reset consecutive failure count
+            const completedTask = {
+                ...task,
+                consecutive_failure_count: 0,
+                status: "completed",
+                completed_at: now,
+                verification_verdict: verificationResult.verdict,
+                verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
+            };
+            await deps.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, completedTask);
+            // Apply dimension_updates and update last_updated for the primary dimension.
+            const goalData = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
+            if (goalData && typeof goalData === "object") {
+                const goal = goalData;
+                const dimensions = goal.dimensions;
+                if (dimensions) {
+                    for (const dim of dimensions) {
+                        // Apply current_value updates from verification result
+                        const update = verificationResult.dimension_updates.find((u) => u.dimension_name === dim.name);
+                        if (update !== undefined && typeof update.new_value === "number") {
+                            const prev = typeof dim.current_value === "number" ? dim.current_value : 0;
+                            if (!checkDimensionDirection(task.intended_direction, prev, update.new_value, deps.logger, String(dim.name))) {
+                                continue;
+                            }
+                            dim.current_value = clampDimensionUpdate(prev, update.new_value, deps.logger, String(dim.name));
+                            // RC-3: Update confidence and last_observed_layer so gap-calculator
+                            // uses the verifier's confidence rather than stale observation confidence.
+                            dim.confidence = verificationResult.confidence ?? 0.70;
+                            dim.last_observed_layer = "mechanical";
+                        }
+                        // Update last_updated for the primary dimension
+                        if (dim.name === task.primary_dimension) {
+                            dim.last_updated = now;
+                        }
+                    }
+                    await deps.stateManager.writeRaw(`goals/${task.goal_id}/goal.json`, goal);
+                }
+            }
+            // Update task history
+            await appendTaskHistory(deps, task.goal_id, completedTask);
+            // Notify portfolio manager of task completion
+            if (deps.onTaskComplete && completedTask.strategy_id) {
+                deps.onTaskComplete(completedTask.strategy_id);
+            }
+            return { action: "completed", task: completedTask };
+        }
+        case "partial": {
+            // Check direction from evidence
+            const directionCorrect = isDirectionCorrect(verificationResult);
+            if (directionCorrect) {
+                // Apply partial dimension_updates to goal state
+                const goalDataPartial = await deps.stateManager.readRaw(`goals/${task.goal_id}/goal.json`);
+                if (goalDataPartial && typeof goalDataPartial === "object") {
+                    const goal = goalDataPartial;
+                    const dimensions = goal.dimensions;
+                    if (dimensions) {
+                        for (const dim of dimensions) {
+                            const update = verificationResult.dimension_updates.find((u) => u.dimension_name === dim.name);
+                            if (update !== undefined && typeof update.new_value === "number") {
+                                const prev = typeof dim.current_value === "number" ? dim.current_value : 0;
+                                if (!checkDimensionDirection(task.intended_direction, prev, update.new_value, deps.logger, String(dim.name))) {
+                                    continue;
+                                }
+                                dim.current_value = clampDimensionUpdate(prev, update.new_value, deps.logger, String(dim.name));
+                                // RC-3: Update confidence and last_observed_layer for partial verdicts too.
+                                dim.confidence = verificationResult.confidence ?? 0.70;
+                                dim.last_observed_layer = "mechanical";
+                            }
+                        }
+                        await deps.stateManager.writeRaw(`goals/${task.goal_id}/goal.json`, goal);
+                    }
+                }
+                const partialTask = {
+                    ...task,
+                    verification_verdict: verificationResult.verdict,
+                    verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
+                };
+                await appendTaskHistory(deps, task.goal_id, partialTask);
+                return { action: "keep", task: partialTask };
+            }
+            // Direction wrong — delegate to handleFailure
+            return handleFailure(deps, task, verificationResult);
+        }
+        case "fail": {
+            return handleFailure(deps, task, verificationResult);
+        }
+    }
+}
+// ─── handleFailure ───
+/**
+ * Handle a task failure: increment failure count, record failure,
+ * decide keep/discard/escalate.
+ */
+export async function handleFailure(deps, task, verificationResult) {
+    // Increment consecutive_failure_count
+    const updatedTask = {
+        ...task,
+        consecutive_failure_count: task.consecutive_failure_count + 1,
+        verification_verdict: verificationResult.verdict,
+        verification_evidence: verificationResult.evidence?.map((e) => e.description ?? String(e)) ?? [],
+    };
+    // Record failure with TrustManager
+    deps.trustManager.recordFailure(task.task_category);
+    // Persist updated task
+    await deps.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, updatedTask);
+    // Check escalation threshold
+    if (updatedTask.consecutive_failure_count >= 3) {
+        deps.stallDetector.checkConsecutiveFailures(task.goal_id, task.primary_dimension, updatedTask.consecutive_failure_count);
+        await appendTaskHistory(deps, task.goal_id, updatedTask);
+        return { action: "escalate", task: updatedTask };
+    }
+    // Direction check
+    const directionCorrect = isDirectionCorrect(verificationResult);
+    if (directionCorrect) {
+        await appendTaskHistory(deps, task.goal_id, updatedTask);
+        return { action: "keep", task: updatedTask };
+    }
+    // Direction wrong
+    if (updatedTask.reversibility === "reversible") {
+        // Attempt revert
+        const revertSuccess = await attemptRevert(deps, updatedTask);
+        if (revertSuccess) {
+            await appendTaskHistory(deps, task.goal_id, updatedTask);
+            return { action: "discard", task: updatedTask };
+        }
+        // Revert failed — set state_integrity to "uncertain" and escalate
+        await setDimensionIntegrity(deps, task.goal_id, task.primary_dimension, "uncertain");
+        await appendTaskHistory(deps, task.goal_id, updatedTask);
+        return { action: "escalate", task: updatedTask };
+    }
+    // irreversible or unknown → escalate
+    await appendTaskHistory(deps, task.goal_id, updatedTask);
+    return { action: "escalate", task: updatedTask };
+}
+// ─── Private helpers (module-local) ───
+/**
+ * Wrap a promise with a timeout. Rejects with a TimeoutError if the promise
+ * does not resolve within `ms` milliseconds.
+ */
+function withTimeout(promise, ms) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            reject(new Error(`completion_judger timeout after ${ms}ms`));
+        }, ms);
+        promise.then((value) => { clearTimeout(timer); resolve(value); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}
+/**
+ * Call an async function with retry + exponential backoff.
+ * On each failure (including timeout), wait `backoffMs * 2^attempt` before retrying.
+ * After `maxRetries` retries, the last error is re-thrown.
+ */
+async function withRetry(fn, maxRetries, backoffMs, logger, label) {
+    let lastErr;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (err) {
+            lastErr = err;
+            if (attempt < maxRetries) {
+                const delay = backoffMs * Math.pow(2, attempt);
+                const msg = err instanceof Error ? err.message : String(err);
+                logger?.warn(`[completion_judger] ${label ?? "LLM call"} failed (attempt ${attempt + 1}/${maxRetries + 1}): ${msg} — retrying in ${delay}ms`);
+                await new Promise((res) => setTimeout(res, delay));
+            }
+        }
+    }
+    throw lastErr;
+}
+async function runMechanicalVerification(deps, task) {
+    // Mechanical prefixes that indicate a command can be run directly
+    const mechanicalPrefixes = ["npm", "npx", "pytest", "sh", "bash", "node", "make", "cargo", "go ", "gh "];
+    // Find the first success criterion with a mechanically-verifiable verification_method
+    const mechanicalCriterion = task.success_criteria.find((c) => {
+        const method = c.verification_method.toLowerCase().trim();
+        return mechanicalPrefixes.some((prefix) => method.startsWith(prefix));
+    });
+    if (!mechanicalCriterion) {
+        return {
+            applicable: false,
+            passed: false,
+            description: "No mechanical verification criteria applicable",
+        };
+    }
+    // If no adapter registry is available, fall back to assumed pass (backward compat)
+    if (!deps.adapterRegistry) {
+        return {
+            applicable: true,
+            passed: true,
+            description: "Mechanical verification criteria detected (no adapter: assumed pass)",
+        };
+    }
+    // Select the first available adapter from the registry for command execution
+    const availableAdapters = deps.adapterRegistry.listAdapters();
+    if (availableAdapters.length === 0) {
+        return {
+            applicable: true,
+            passed: true,
+            description: "Mechanical verification criteria detected (no adapters registered: assumed pass)",
+        };
+    }
+    const adapterType = availableAdapters[0];
+    let adapter;
+    try {
+        adapter = deps.adapterRegistry.getAdapter(adapterType);
+    }
+    catch {
+        return {
+            applicable: true,
+            passed: true,
+            description: "Mechanical verification criteria detected (adapter lookup failed: assumed pass)",
+        };
+    }
+    // Execute the verification command via the adapter
+    const verificationCommand = mechanicalCriterion.verification_method.trim();
+    const verificationTimeoutMs = 30_000; // 30 seconds default for L1 mechanical checks
+    const agentTask = {
+        prompt: verificationCommand,
+        timeout_ms: verificationTimeoutMs,
+        adapter_type: adapterType,
+    };
+    let result;
+    try {
+        result = await adapter.execute(agentTask);
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        deps.logger?.error("runMechanicalVerification: adapter.execute() threw", { error: errMsg });
+        return {
+            applicable: true,
+            passed: false,
+            description: `Mechanical verification command threw: ${errMsg}`,
+        };
+    }
+    if (result.stopped_reason === "timeout") {
+        return {
+            applicable: true,
+            passed: false,
+            description: `Mechanical verification timed out after ${verificationTimeoutMs}ms (command: ${verificationCommand})`,
+        };
+    }
+    const passed = result.exit_code === 0 && result.success;
+    const description = passed
+        ? `Mechanical verification passed (exit 0): ${verificationCommand}`
+        : `Mechanical verification failed (exit ${result.exit_code ?? "null"}): ${verificationCommand}${result.error ? ` — ${result.error}` : ""}`;
+    return { applicable: true, passed, description };
+}
+async function runLLMReview(deps, task, executionResult, knowledgeBlock = "", stateBlock = "", modelTier = 'light') {
+    const timeoutMs = deps.completionJudgerConfig?.timeoutMs ?? 30_000;
+    const maxRetries = deps.completionJudgerConfig?.maxRetries ?? 2;
+    const retryBackoffMs = deps.completionJudgerConfig?.retryBackoffMs ?? 1_000;
+    // Create review session
+    const reviewSession = await deps.sessionManager.createSession("task_review", task.goal_id, task.id);
+    // Build review context (excludes executor self-report for bias prevention)
+    const reviewContext = deps.sessionManager.buildTaskReviewContext(task.goal_id, task.id);
+    const criteriaList = task.success_criteria
+        .map((c, i) => `${i + 1}. ${c.description} (blocking: ${c.is_blocking}, method: ${c.verification_method})`)
+        .join("\n");
+    const enrichmentBlocks = [knowledgeBlock, stateBlock].filter(Boolean).join("\n");
+    const prompt = `Evaluate task execution against success criteria.
+
+Task: ${task.work_description}
+Approach: ${task.approach}
+
+Criteria:
+${criteriaList}
+${enrichmentBlocks ? `\n${enrichmentBlocks}\n` : ""}
+Output (first 2000 chars):
+${executionResult.output.slice(0, 2000)}
+
+Status: ${executionResult.stopped_reason} | Success: ${executionResult.success}
+Context: ${reviewContext.map((s) => s.content).join(" ")}
+
+Return JSON:
+{"verdict": "pass"|"partial"|"fail", "reasoning": "...", "criteria_met": #, "criteria_total": #}`;
+    // Gateway path: route through PromptGateway when available
+    if (deps.gateway) {
+        let parsed;
+        try {
+            parsed = await withRetry(() => withTimeout(deps.gateway.execute({
+                purpose: "verification",
+                goalId: task.goal_id,
+                additionalContext: { review_prompt: prompt },
+                responseSchema: CompletionJudgerResponseSchema,
+                maxTokens: 1024,
+            }), timeoutMs), maxRetries, retryBackoffMs, deps.logger, `completion_judger for task ${task.id}`);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            deps.logger?.error(`[completion_judger] All retries exhausted for task ${task.id}: ${msg}`);
+            await deps.sessionManager.endSession(reviewSession.id, `completion_judger failed: ${msg}`);
+            return {
+                passed: false,
+                partial: false,
+                description: `completion_judger failed after ${maxRetries + 1} attempt(s): ${msg}`,
+                confidence: 0.0,
+            };
+        }
+        const verdictStr = parsed.verdict;
+        const result = {
+            passed: verdictStr === "pass",
+            partial: verdictStr === "partial",
+            description: parsed.reasoning || "LLM review completed",
+            confidence: verdictStr === "pass" ? 0.8 : verdictStr === "partial" ? 0.6 : 0.8,
+            criteria_met: parsed.criteria_met,
+            criteria_total: parsed.criteria_total,
+        };
+        await deps.sessionManager.endSession(reviewSession.id, `LLM review: ${verdictStr}`);
+        return result;
+    }
+    // Direct LLM path (fallback when no gateway)
+    let response;
+    try {
+        response = await withRetry(() => withTimeout((deps.reviewerLlmClient ?? deps.llmClient).sendMessage([{ role: "user", content: prompt }], {
+            system: "Review task results objectively against criteria. Ignore executor self-assessment.",
+            max_tokens: 1024,
+            model_tier: modelTier,
+        }), timeoutMs), maxRetries, retryBackoffMs, deps.logger, `completion_judger for task ${task.id}`);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        deps.logger?.error(`[completion_judger] All retries exhausted for task ${task.id}: ${msg}`);
+        await deps.sessionManager.endSession(reviewSession.id, `completion_judger failed: ${msg}`);
+        return {
+            passed: false,
+            partial: false,
+            description: `completion_judger failed after ${maxRetries + 1} attempt(s): ${msg}`,
+            confidence: 0.0,
+        };
+    }
+    try {
+        const rawJson = response.content.replace(/```json\n?/g, "").replace(/```/g, "").trim();
+        const parseResult = CompletionJudgerResponseSchema.safeParse(JSON.parse(rawJson));
+        if (!parseResult.success) {
+            deps.logger?.warn(`[completion_judger] Zod parse failed for task ${task.id}: ${parseResult.error.message}`);
+            await deps.sessionManager.endSession(reviewSession.id, "Failed to parse LLM review result");
+            return {
+                passed: false,
+                partial: false,
+                description: "Failed to parse LLM review result",
+                confidence: 0.3,
+            };
+        }
+        const parsed = parseResult.data;
+        const verdictStr = parsed.verdict;
+        const result = {
+            passed: verdictStr === "pass",
+            partial: verdictStr === "partial",
+            description: parsed.reasoning || "LLM review completed",
+            confidence: verdictStr === "pass" ? 0.8 : verdictStr === "partial" ? 0.6 : 0.8,
+            criteria_met: parsed.criteria_met,
+            criteria_total: parsed.criteria_total,
+        };
+        await deps.sessionManager.endSession(reviewSession.id, `LLM review: ${verdictStr}`);
+        return result;
+    }
+    catch {
+        deps.logger?.warn(`[completion_judger] JSON.parse failed for task ${task.id}`);
+        await deps.sessionManager.endSession(reviewSession.id, "Failed to parse LLM review result");
+        return {
+            passed: false,
+            partial: false,
+            description: "Failed to parse LLM review result",
+            confidence: 0.3,
+        };
+    }
+}
+function parseExecutorReport(executionResult) {
+    // Parse executor's output for self-assessment (reference only)
+    return {
+        completed: executionResult.success,
+        summary: executionResult.output.slice(0, 500),
+        partial_results: [],
+        blockers: executionResult.error ? [executionResult.error] : [],
+    };
+}
+function isDirectionCorrect(verificationResult) {
+    // Direction is correct when the verdict is "partial" (some criteria met)
+    // Direction is wrong when the verdict is "fail" (no criteria met / wrong approach)
+    return verificationResult.verdict === "partial";
+}
+async function attemptRevert(deps, task) {
+    // Attempt to revert a task's changes
+    // In MVP, we create a revert prompt and check if it succeeds
+    // This is called only for reversible tasks
+    try {
+        const revertSession = await deps.sessionManager.createSession("task_execution", task.goal_id, task.id);
+        const revertPrompt = `Revert task "${task.work_description}". Undo all changes in: ${task.scope_boundary.in_scope.join(", ")}.
+
+Return JSON: {"success": true|false, "reason": "..."}`;
+        const response = await deps.llmClient.sendMessage([{ role: "user", content: revertPrompt }], { system: "Revert failed task changes. Respond with JSON only.", max_tokens: 512, model_tier: "main" });
+        await deps.sessionManager.endSession(revertSession.id, response.content);
+        // Parse structured JSON response
+        try {
+            const parsed = deps.llmClient.parseJSON(response.content, z.object({ success: z.boolean(), reason: z.string() }));
+            return parsed.success;
+        }
+        catch {
+            // If parse fails, assume revert failed
+            return false;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+async function setDimensionIntegrity(deps, goalId, dimensionName, integrity) {
+    // Attempt to update the dimension's state_integrity flag
+    // Read the goal, find the dimension, update integrity
+    const goalData = await deps.stateManager.readRaw(`goals/${goalId}/goal.json`);
+    if (goalData && typeof goalData === "object") {
+        const goal = goalData;
+        const dimensions = goal.dimensions;
+        if (dimensions) {
+            for (const dim of dimensions) {
+                if (dim.name === dimensionName) {
+                    dim.state_integrity = integrity;
+                }
+            }
+            await deps.stateManager.writeRaw(`goals/${goalId}/goal.json`, goal);
+        }
+    }
+}
+async function appendTaskHistory(deps, goalId, task) {
+    const historyPath = `tasks/${goalId}/task-history.json`;
+    const existing = await deps.stateManager.readRaw(historyPath);
+    const history = Array.isArray(existing) ? existing : [];
+    const actual_elapsed_ms = task.started_at && task.completed_at
+        ? new Date(task.completed_at).getTime() - new Date(task.started_at).getTime()
+        : null;
+    const estimated_duration_ms = task.estimated_duration
+        ? deps.durationToMs(task.estimated_duration)
+        : null;
+    history.push({
+        task_id: task.id,
+        status: task.status,
+        primary_dimension: task.primary_dimension,
+        consecutive_failure_count: task.consecutive_failure_count,
+        completed_at: task.completed_at ?? new Date().toISOString(),
+        actual_elapsed_ms,
+        estimated_duration_ms,
+    });
+    await deps.stateManager.writeRaw(historyPath, history);
+}
+// ─── P0 Guard 1: dimension_updates change magnitude limit (§3.2) ───
+/**
+ * Clamp a proposed dimension update to within ±30% absolute or ±30% relative
+ * of the current value (whichever is larger). Logs a warning when clamping occurs.
+ *
+ * Exported for unit testing.
+ */
+export function clampDimensionUpdate(current, proposed, logger, dimName) {
+    const absLimit = 0.3;
+    const relLimit = Math.abs(current) * 0.3;
+    const maxDelta = Math.max(absLimit, relLimit);
+    const clamped = Math.max(current - maxDelta, Math.min(current + maxDelta, proposed));
+    if (clamped !== proposed) {
+        logger?.warn(`dimension_update clamped: dim=${dimName}, proposed=${proposed}, applied=${clamped}, current=${current}`);
+    }
+    return clamped;
+}
+// ─── §4.5 Guard: dimension_updates direction check ───
+/**
+ * Check whether a proposed dimension update moves in the intended direction.
+ * Returns true if the update should be applied, false if it should be skipped.
+ *
+ * Exported for unit testing.
+ */
+export function checkDimensionDirection(intendedDirection, currentValue, proposedValue, logger, dimName) {
+    if (!intendedDirection || intendedDirection === "neutral")
+        return true;
+    const actualDirection = proposedValue > currentValue
+        ? "increase"
+        : proposedValue < currentValue
+            ? "decrease"
+            : "neutral";
+    if (intendedDirection === "increase" && actualDirection === "decrease") {
+        logger?.warn(`dimension_update direction mismatch: task intended ${intendedDirection}, but update suggests ${actualDirection} for dim ${dimName ?? "unknown"}`);
+        return false;
+    }
+    if (intendedDirection === "decrease" && actualDirection === "increase") {
+        logger?.warn(`dimension_update direction mismatch: task intended ${intendedDirection}, but update suggests ${actualDirection} for dim ${dimName ?? "unknown"}`);
+        return false;
+    }
+    return true;
+}
+//# sourceMappingURL=task-verifier.js.map