conatus 0.1.0

package/dist/task-lifecycle.js

@@ -0,0 +1,1161 @@
+import { randomUUID } from "node:crypto";
+import { execFileSync as _execFileSync } from "node:child_process";
+import * as _fs from "node:fs";
+import * as _path from "node:path";
+import { z } from "zod";
+import { scoreAllDimensions, rankDimensions } from "./drive/drive-scorer.js";
+import { TaskSchema, VerificationResultSchema } from "./types/task.js";
+import { AdapterRegistry } from "./adapter-layer.js";
+export { AdapterRegistry };
+const DEBUG = process.env.MOTIVA_DEBUG === "true";
+// ─── Schema for LLM-generated task fields ───
+const LLMGeneratedTaskSchema = z.object({
+    work_description: z.string(),
+    rationale: z.string(),
+    approach: z.string(),
+    success_criteria: z.array(z.object({
+        description: z.string(),
+        verification_method: z.string(),
+        is_blocking: z.boolean().default(true),
+    })),
+    scope_boundary: z.object({
+        in_scope: z.array(z.string()),
+        out_of_scope: z.array(z.string()),
+        blast_radius: z.string(),
+    }),
+    constraints: z.array(z.string()),
+    reversibility: z.enum(["reversible", "irreversible", "unknown"]).default("reversible"),
+    estimated_duration: z
+        .object({
+        value: z.number(),
+        unit: z.enum(["minutes", "hours", "days", "weeks"]),
+    })
+        .nullable()
+        .default(null),
+});
+// ─── TaskLifecycle ───
+/**
+ * TaskLifecycle manages the full lifecycle of tasks:
+ * select target dimension -> generate task -> approval check -> execute -> verify -> handle verdict.
+ */
+export class TaskLifecycle {
+    stateManager;
+    llmClient;
+    sessionManager;
+    trustManager;
+    strategyManager;
+    stallDetector;
+    approvalFn;
+    ethicsGate;
+    capabilityDetector;
+    logger;
+    adapterRegistry;
+    healthCheckEnabled;
+    execFileSyncFn;
+    onTaskComplete;
+    constructor(stateManager, llmClient, sessionManager, trustManager, strategyManager, stallDetector, options) {
+        this.stateManager = stateManager;
+        this.llmClient = llmClient;
+        this.sessionManager = sessionManager;
+        this.trustManager = trustManager;
+        this.strategyManager = strategyManager;
+        this.stallDetector = stallDetector;
+        this.approvalFn = options?.approvalFn ?? ((_task) => Promise.resolve(false));
+        this.ethicsGate = options?.ethicsGate;
+        this.capabilityDetector = options?.capabilityDetector;
+        this.logger = options?.logger;
+        this.adapterRegistry = options?.adapterRegistry;
+        this.healthCheckEnabled = options?.healthCheckEnabled ?? false;
+        this.execFileSyncFn = options?.execFileSyncFn ?? _execFileSync;
+    }
+    // ─── setOnTaskComplete ───
+    /**
+     * Register a callback to be invoked when a task completes successfully.
+     * Used by PortfolioManager to track task completion times per strategy.
+     */
+    setOnTaskComplete(callback) {
+        this.onTaskComplete = callback;
+    }
+    // ─── selectTargetDimension ───
+    /**
+     * Select the highest-priority dimension to work on based on drive scoring.
+     *
+     * @param gapVector - current gap state for the goal
+     * @param driveContext - per-dimension timing/deadline/opportunity context
+     * @returns the name of the top-ranked dimension
+     * @throws if gapVector has no gaps (empty)
+     */
+    selectTargetDimension(gapVector, driveContext) {
+        if (gapVector.gaps.length === 0) {
+            throw new Error("selectTargetDimension: gapVector has no gaps (empty gap vector)");
+        }
+        const scores = scoreAllDimensions(gapVector, driveContext);
+        const ranked = rankDimensions(scores);
+        // ranked is sorted descending by final_score; take the top one
+        return ranked[0].dimension_name;
+    }
+    // ─── generateTask ───
+    /**
+     * Generate a task for the given goal and target dimension via LLM.
+     *
+     * @param goalId - the goal this task belongs to
+     * @param targetDimension - the dimension this task should improve
+     * @param strategyId - optional override; if not provided, uses active strategy
+     * @returns the generated and persisted Task
+     */
+    async generateTask(goalId, targetDimension, strategyId, knowledgeContext, adapterType, existingTasks, workspaceContext) {
+        const prompt = this.buildTaskGenerationPrompt(goalId, targetDimension, knowledgeContext, adapterType, existingTasks, workspaceContext);
+        const response = await this.llmClient.sendMessage([{ role: "user", content: prompt }], {
+            system: "You are a task generation assistant. Given a goal and target dimension, generate a concrete, actionable task. Respond with a JSON object inside a markdown code block.",
+            max_tokens: 2048,
+        });
+        let generated;
+        try {
+            generated = this.llmClient.parseJSON(response.content, LLMGeneratedTaskSchema);
+        }
+        catch (err) {
+            this.logger?.error("Task generation failed: LLM response did not match expected schema.", { rawResponse: response.content.substring(0, 500) });
+            throw err;
+        }
+        // Resolve strategy_id
+        const activeStrategy = this.strategyManager.getActiveStrategy(goalId);
+        const resolvedStrategyId = strategyId ?? activeStrategy?.id ?? null;
+        const taskId = randomUUID();
+        const now = new Date().toISOString();
+        const task = TaskSchema.parse({
+            id: taskId,
+            goal_id: goalId,
+            strategy_id: resolvedStrategyId,
+            target_dimensions: [targetDimension],
+            primary_dimension: targetDimension,
+            work_description: generated.work_description,
+            rationale: generated.rationale,
+            approach: generated.approach,
+            success_criteria: generated.success_criteria,
+            scope_boundary: generated.scope_boundary,
+            constraints: generated.constraints,
+            reversibility: generated.reversibility,
+            estimated_duration: generated.estimated_duration,
+            status: "pending",
+            created_at: now,
+        });
+        // Persist
+        this.stateManager.writeRaw(`tasks/${goalId}/${taskId}.json`, task);
+        return task;
+    }
+    // ─── checkIrreversibleApproval ───
+    /**
+     * Check whether the task requires human approval and, if so, request it.
+     *
+     * @param task - the task to check
+     * @param confidence - observation confidence for the approval check (default 0.5)
+     * @returns true if approved or approval not needed; false if approval was denied
+     */
+    async checkIrreversibleApproval(task, confidence = 0.5) {
+        const domain = task.task_category;
+        const needsApproval = this.trustManager.requiresApproval(task.reversibility, domain, confidence, task.task_category);
+        if (!needsApproval) {
+            return true;
+        }
+        const approved = await this.approvalFn(task);
+        return approved;
+    }
+    // ─── executeTask ───
+    /**
+     * Execute a task via the given adapter.
+     *
+     * Creates a session, builds context, converts to AgentTask, executes
+     * via adapter, ends session, and updates task status based on result.
+     */
+    async executeTask(task, adapter) {
+        // Create execution session
+        const session = this.sessionManager.createSession("task_execution", task.goal_id, task.id);
+        // Build context
+        const contextSlots = this.sessionManager.buildTaskExecutionContext(task.goal_id, task.id);
+        // Convert to AgentTask
+        let prompt;
+        if (adapter.adapterType === "github_issue") {
+            // For github_issue adapter, format as a structured JSON block so
+            // GitHubIssueAdapter.parsePrompt extracts a proper title instead of
+            // picking up the context-slot label as the issue title.
+            const titleLine = task.work_description.split("\n")[0]?.trim() ?? task.work_description;
+            const title = titleLine.length > 120 ? titleLine.slice(0, 117) + "..." : titleLine;
+            const issuePayload = JSON.stringify({ title, body: task.work_description });
+            prompt = `\`\`\`github-issue\n${issuePayload}\n\`\`\``;
+        }
+        else {
+            // Build prompt with task description as primary content
+            const taskDescription = `You are an AI agent executing a task.\n\nTask: ${task.work_description}\n\nApproach: ${task.approach}\n\nSuccess Criteria:\n${task.success_criteria.map((c) => `- ${c.description}`).join("\n")}`;
+            const contextContent = contextSlots
+                .filter((slot) => slot.content.trim().length > 0) // Skip empty slots
+                .sort((a, b) => a.priority - b.priority)
+                .map((slot) => `[${slot.label}]\n${slot.content}`)
+                .join("\n\n");
+            prompt = contextContent
+                ? `${taskDescription}\n\n--- Context ---\n${contextContent}`
+                : taskDescription;
+        }
+        const timeoutMs = task.estimated_duration
+            ? this.durationToMs(task.estimated_duration)
+            : 30 * 60 * 1000; // default 30 minutes
+        const agentTask = {
+            prompt,
+            timeout_ms: timeoutMs,
+            adapter_type: adapter.adapterType,
+        };
+        // Update task status to running
+        const runningTask = { ...task, status: "running", started_at: new Date().toISOString() };
+        this.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, runningTask);
+        // Execute
+        let result;
+        try {
+            // Generic dedup check — any adapter may optionally implement checkDuplicate
+            if ('checkDuplicate' in adapter && typeof adapter.checkDuplicate === 'function') {
+                try {
+                    const isDuplicate = await adapter.checkDuplicate(agentTask);
+                    if (isDuplicate) {
+                        // Return synthetic result — task already exists, skip execution
+                        result = {
+                            success: true,
+                            output: 'Skipped: duplicate task detected by adapter',
+                            error: null,
+                            exit_code: 0,
+                            elapsed_ms: 0,
+                            stopped_reason: 'completed',
+                        };
+                        // End session and update task status without calling adapter.execute
+                        const skipSummary = 'Task skipped: duplicate detected by adapter';
+                        this.sessionManager.endSession(session.id, skipSummary);
+                        const skipNow = new Date().toISOString();
+                        const skippedTask = { ...runningTask, status: 'completed', completed_at: skipNow };
+                        this.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, skippedTask);
+                        return result;
+                    }
+                }
+                catch { /* non-fatal: proceed with execution if dedup check fails */ }
+            }
+            result = await adapter.execute(agentTask);
+        }
+        catch (err) {
+            result = {
+                success: false,
+                output: "",
+                error: err instanceof Error ? err.message : String(err),
+                exit_code: null,
+                elapsed_ms: 0,
+                stopped_reason: "error",
+            };
+        }
+        // Post-execution: check whether any files were actually modified via git diff --stat.
+        // This is a diagnostic annotation only — it does NOT fail the task.
+        if (result.success) {
+            try {
+                const diffStat = this.execFileSyncFn("git", ["diff", "--stat"], {
+                    cwd: process.cwd(),
+                    encoding: "utf-8",
+                });
+                result.filesChanged = diffStat.trim().length > 0;
+                if (!result.filesChanged) {
+                    if (DEBUG) {
+                        console.warn("[TaskLifecycle] Adapter reported success but no files were modified");
+                    }
+                    this.logger?.warn("[TaskLifecycle] Adapter reported success but no files were modified", { taskId: task.id });
+                }
+            }
+            catch {
+                // Not a git repo or git is unavailable — skip the check silently
+            }
+        }
+        // End session
+        const summary = result.success
+            ? `Task completed successfully. Output length: ${result.output.length}`
+            : `Task failed: ${result.stopped_reason}. Error: ${result.error ?? "unknown"}`;
+        this.sessionManager.endSession(session.id, summary);
+        // Update task status based on result
+        const now = new Date().toISOString();
+        let newStatus;
+        if (result.stopped_reason === "timeout") {
+            newStatus = "timed_out";
+        }
+        else if (result.stopped_reason === "error" || !result.success) {
+            newStatus = "error";
+        }
+        else {
+            newStatus = "completed";
+        }
+        const updatedTask = {
+            ...runningTask,
+            status: newStatus,
+            completed_at: now,
+            ...(newStatus === "timed_out" ? { timeout_at: now } : {}),
+        };
+        this.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, updatedTask);
+        return result;
+    }
+    // ─── 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)
+     */
+    async verifyTask(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 this.runMechanicalVerification(task);
+        // ─── Layer 2: LLM task reviewer (independent) ───
+        const l2Result = await this.runLLMReview(task, executionResult);
+        // ─── Layer 3: Executor self-report (reference only) ───
+        const executorReport = this.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 this.runLLMReview(task, executionResult);
+                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: l1Result.passed ? 0.9 : 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 = this.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,
+        });
+        // Persist verification result
+        this.stateManager.writeRaw(`verification/${task.id}/verification-result.json`, verificationResult);
+        return verificationResult;
+    }
+    // ─── handleVerdict ───
+    /**
+     * Handle a verification verdict (pass/partial/fail).
+     */
+    async handleVerdict(task, verificationResult) {
+        switch (verificationResult.verdict) {
+            case "pass": {
+                // Record success
+                this.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,
+                };
+                this.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, completedTask);
+                // Apply dimension_updates and update last_updated for the primary dimension.
+                const goalData = this.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") {
+                                dim.current_value = update.new_value;
+                            }
+                            // Update last_updated for the primary dimension
+                            if (dim.name === task.primary_dimension) {
+                                dim.last_updated = now;
+                            }
+                        }
+                        this.stateManager.writeRaw(`goals/${task.goal_id}/goal.json`, goal);
+                    }
+                }
+                // Update task history
+                this.appendTaskHistory(task.goal_id, completedTask);
+                // Notify portfolio manager of task completion
+                if (this.onTaskComplete && completedTask.strategy_id) {
+                    this.onTaskComplete(completedTask.strategy_id);
+                }
+                return { action: "completed", task: completedTask };
+            }
+            case "partial": {
+                // Check direction from evidence
+                const directionCorrect = this.isDirectionCorrect(verificationResult);
+                if (directionCorrect) {
+                    // Apply partial dimension_updates to goal state
+                    const goalDataPartial = this.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") {
+                                    dim.current_value = update.new_value;
+                                }
+                            }
+                            this.stateManager.writeRaw(`goals/${task.goal_id}/goal.json`, goal);
+                        }
+                    }
+                    this.appendTaskHistory(task.goal_id, task);
+                    return { action: "keep", task };
+                }
+                // Direction wrong — delegate to handleFailure
+                return this.handleFailure(task, verificationResult);
+            }
+            case "fail": {
+                return this.handleFailure(task, verificationResult);
+            }
+        }
+    }
+    // ─── handleFailure ───
+    /**
+     * Handle a task failure: increment failure count, record failure,
+     * decide keep/discard/escalate.
+     */
+    async handleFailure(task, verificationResult) {
+        // Increment consecutive_failure_count
+        const updatedTask = {
+            ...task,
+            consecutive_failure_count: task.consecutive_failure_count + 1,
+        };
+        // Record failure with TrustManager
+        this.trustManager.recordFailure(task.task_category);
+        // Persist updated task
+        this.stateManager.writeRaw(`tasks/${task.goal_id}/${task.id}.json`, updatedTask);
+        // Check escalation threshold
+        if (updatedTask.consecutive_failure_count >= 3) {
+            this.stallDetector.checkConsecutiveFailures(task.goal_id, task.primary_dimension, updatedTask.consecutive_failure_count);
+            this.appendTaskHistory(task.goal_id, updatedTask);
+            return { action: "escalate", task: updatedTask };
+        }
+        // Direction check
+        const directionCorrect = this.isDirectionCorrect(verificationResult);
+        if (directionCorrect) {
+            this.appendTaskHistory(task.goal_id, updatedTask);
+            return { action: "keep", task: updatedTask };
+        }
+        // Direction wrong
+        if (updatedTask.reversibility === "reversible") {
+            // Attempt revert
+            const revertSuccess = await this.attemptRevert(updatedTask);
+            if (revertSuccess) {
+                this.appendTaskHistory(task.goal_id, updatedTask);
+                return { action: "discard", task: updatedTask };
+            }
+            // Revert failed — set state_integrity to "uncertain" and escalate
+            this.setDimensionIntegrity(task.goal_id, task.primary_dimension, "uncertain");
+            this.appendTaskHistory(task.goal_id, updatedTask);
+            return { action: "escalate", task: updatedTask };
+        }
+        // irreversible or unknown → escalate
+        this.appendTaskHistory(task.goal_id, updatedTask);
+        return { action: "escalate", task: updatedTask };
+    }
+    // ─── runTaskCycle ───
+    /**
+     * Run a full task cycle: select → generate → approve → execute → verify → verdict.
+     */
+    async runTaskCycle(goalId, gapVector, driveContext, adapter, knowledgeContext, existingTasks, workspaceContext) {
+        // 1. Select target dimension
+        const targetDimension = this.selectTargetDimension(gapVector, driveContext);
+        // 2. Generate task (optionally with injected knowledge context)
+        const task = await this.generateTask(goalId, targetDimension, undefined, knowledgeContext, adapter.adapterType, existingTasks, workspaceContext);
+        // 3a. Ethics means check (reject → skip, flag → require approval, pass → proceed)
+        if (this.ethicsGate) {
+            const ethicsVerdict = await this.ethicsGate.checkMeans(task.id, task.work_description, task.approach);
+            if (ethicsVerdict.verdict === "reject") {
+                const rejectedResult = VerificationResultSchema.parse({
+                    task_id: task.id,
+                    verdict: "fail",
+                    confidence: 1.0,
+                    evidence: [
+                        {
+                            layer: "mechanical",
+                            description: `Ethics gate rejected task: ${ethicsVerdict.reasoning}`,
+                            confidence: 1.0,
+                        },
+                    ],
+                    dimension_updates: [],
+                    timestamp: new Date().toISOString(),
+                });
+                return { task, verificationResult: rejectedResult, action: "discard" };
+            }
+            if (ethicsVerdict.verdict === "flag") {
+                // Treat flag as requiring human approval via the existing approvalFn
+                const approved = await this.approvalFn(task);
+                if (!approved) {
+                    const flagDeniedResult = VerificationResultSchema.parse({
+                        task_id: task.id,
+                        verdict: "fail",
+                        confidence: 1.0,
+                        evidence: [
+                            {
+                                layer: "mechanical",
+                                description: `Ethics flag: approval denied. Reasoning: ${ethicsVerdict.reasoning}`,
+                                confidence: 1.0,
+                            },
+                        ],
+                        dimension_updates: [],
+                        timestamp: new Date().toISOString(),
+                    });
+                    return { task, verificationResult: flagDeniedResult, action: "approval_denied" };
+                }
+            }
+            // verdict === "pass" → fall through
+        }
+        // 3b. Capability check
+        // Skip for capability_acquisition tasks to prevent infinite delegation loops.
+        if (this.capabilityDetector && task.task_category !== "capability_acquisition") {
+            const gap = await this.capabilityDetector.detectDeficiency(task);
+            if (gap !== null) {
+                const capabilityResult = VerificationResultSchema.parse({
+                    task_id: task.id,
+                    verdict: "fail",
+                    confidence: 1.0,
+                    evidence: [
+                        {
+                            layer: "mechanical",
+                            description: `Capability deficiency: ${gap.missing_capability.name} — ${gap.reason}`,
+                            confidence: 1.0,
+                        },
+                    ],
+                    dimension_updates: [],
+                    timestamp: new Date().toISOString(),
+                });
+                // Determine acquisition method. Permissions always require human approval.
+                const acquisitionTask = this.capabilityDetector.planAcquisition(gap);
+                if (acquisitionTask.method === "permission_request") {
+                    // Permissions cannot be autonomously acquired — escalate to human.
+                    return { task, verificationResult: capabilityResult, action: "escalate" };
+                }
+                // For tool_creation and service_setup: mark as acquiring and delegate.
+                await this.capabilityDetector.setCapabilityStatus(gap.missing_capability.name, gap.missing_capability.type, "acquiring");
+                return {
+                    action: "capability_acquiring",
+                    task,
+                    verificationResult: capabilityResult,
+                    acquisition_task: acquisitionTask,
+                };
+            }
+        }
+        // 3c. Check irreversible approval
+        const approved = await this.checkIrreversibleApproval(task);
+        if (!approved) {
+            // Build a minimal verification result for the cycle result
+            const deniedResult = VerificationResultSchema.parse({
+                task_id: task.id,
+                verdict: "fail",
+                confidence: 1.0,
+                evidence: [
+                    {
+                        layer: "mechanical",
+                        description: "Approval denied by human",
+                        confidence: 1.0,
+                    },
+                ],
+                dimension_updates: [],
+                timestamp: new Date().toISOString(),
+            });
+            return {
+                task,
+                verificationResult: deniedResult,
+                action: "approval_denied",
+            };
+        }
+        // 4. Execute task
+        if (DEBUG)
+            console.log(`[DEBUG-TL] Executing task ${task.id} via adapter ${adapter.adapterType}`);
+        const executionResult = await this.executeTask(task, adapter);
+        if (DEBUG)
+            console.log(`[DEBUG-TL] Execution result: success=${executionResult.success}, stopped=${executionResult.stopped_reason}, error=${executionResult.error}, output=${executionResult.output?.substring(0, 200)}`);
+        // 4b. Post-execution health check (opt-in)
+        if (executionResult.success && this.healthCheckEnabled) {
+            const healthCheck = await this.runPostExecutionHealthCheck(adapter, task);
+            if (!healthCheck.healthy) {
+                console.warn(`[TaskLifecycle] Post-execution health check FAILED: ${healthCheck.output}`);
+                executionResult.success = false;
+                executionResult.output = (executionResult.output || "") +
+                    `\n\n[Health Check Failed]\n${healthCheck.output}`;
+            }
+        }
+        // Reload task from disk to get accurate status/started_at/completed_at set by executeTask
+        let taskForVerification = task;
+        try {
+            const raw = this.stateManager.readRaw(`tasks/${task.goal_id}/${task.id}.json`);
+            if (raw)
+                taskForVerification = TaskSchema.parse(raw);
+        }
+        catch { /* fall back to in-memory task */ }
+        // 5. Verify task
+        const verificationResult = await this.verifyTask(taskForVerification, executionResult);
+        if (DEBUG)
+            console.log(`[DEBUG-TL] Verification: verdict=${verificationResult.verdict}, evidence=${verificationResult.evidence.map(e => e.description).join('; ').substring(0, 300)}`);
+        // 6. Handle verdict
+        const verdictResult = await this.handleVerdict(taskForVerification, verificationResult);
+        return {
+            task: verdictResult.task,
+            verificationResult,
+            action: verdictResult.action,
+        };
+    }
+    // ─── Private Helpers ───
+    buildTaskGenerationPrompt(goalId, targetDimension, knowledgeContext, adapterType, existingTasks, workspaceContext) {
+        // Load goal context to enrich the prompt
+        const goal = this.stateManager.loadGoal(goalId);
+        const dim = goal?.dimensions.find((d) => d.name === targetDimension);
+        // Build goal context section
+        let goalSection;
+        if (goal) {
+            const titleLine = `Goal: ${goal.title}`;
+            const descLine = goal.description ? `Description: ${goal.description}` : "";
+            goalSection = [titleLine, descLine].filter(Boolean).join("\n");
+        }
+        else {
+            goalSection = `Goal ID: ${goalId}`;
+        }
+        // Build dimension context section
+        let dimensionSection;
+        if (dim) {
+            const currentVal = dim.current_value !== null && dim.current_value !== undefined
+                ? String(dim.current_value)
+                : "unknown";
+            const threshold = dim.threshold;
+            let targetDesc;
+            if (threshold.type === "min") {
+                targetDesc = `at least ${threshold.value}`;
+            }
+            else if (threshold.type === "max") {
+                targetDesc = `at most ${threshold.value}`;
+            }
+            else if (threshold.type === "range") {
+                targetDesc = `between ${threshold.low} and ${threshold.high}`;
+            }
+            else if (threshold.type === "present") {
+                targetDesc = "present (non-null)";
+            }
+            else {
+                targetDesc = `equal to ${threshold.value}`;
+            }
+            const gapDesc = (() => {
+                if (threshold.type === "min") {
+                    const val = typeof dim.current_value === "number" ? dim.current_value : null;
+                    if (val !== null)
+                        return `${threshold.value - val} below minimum`;
+                    return "current value unknown";
+                }
+                else if (threshold.type === "max") {
+                    const val = typeof dim.current_value === "number" ? dim.current_value : null;
+                    if (val !== null)
+                        return `${val - threshold.value} above maximum`;
+                    return "current value unknown";
+                }
+                else if (threshold.type === "present") {
+                    return dim.current_value == null ? "value is absent (needs to be set)" : "value is present";
+                }
+                return "gap exists";
+            })();
+            dimensionSection = `Dimension to improve: "${targetDimension}" (label: ${dim.label})
+
+Gap Analysis:
+- Current value: ${currentVal}
+- Target threshold: ${targetDesc}
+- Gap: ${gapDesc}`;
+        }
+        else {
+            dimensionSection = `Dimension to improve: "${targetDimension}"`;
+        }
+        // Build adapter context section
+        let adapterSection = "";
+        if (adapterType === "github_issue") {
+            adapterSection = `\nExecution context: This task will be executed via GitHub issue creation.\nIMPORTANT: The work_description should contain the issue title on the first line, followed by the issue body. Generate a SPECIFIC, actionable issue — not a vague review task.\n`;
+        }
+        else if (adapterType === "openai_codex_cli" || adapterType === "claude_code_cli") {
+            adapterSection = `\nExecution context: This task will be executed via the "${adapterType}" adapter (a CLI-based code agent).
+IMPORTANT constraints for success_criteria:
+- The agent runs in a sandbox and CANNOT perform git commit, git push, or merge operations.
+- Success criteria MUST focus on file creation/modification only (e.g., "file X exists with content Y").
+- Do NOT include "merged into repository", "committed", or "pushed" as success criteria.
+- The verification_method should check file existence or content (e.g., "test -f README.md").\n`;
+        }
+        else if (adapterType) {
+            adapterSection = `\nExecution context: This task will be executed via the "${adapterType}" adapter.\n`;
+        }
+        const knowledgeSection = knowledgeContext
+            ? `\nRelevant domain knowledge:\n${knowledgeContext}\n`
+            : "";
+        // Read package.json for project identity (best-effort, no throw)
+        let projectName = "";
+        let projectDescription = "";
+        try {
+            const pkgPath = _path.join(process.cwd(), "package.json");
+            if (_fs.existsSync(pkgPath)) {
+                const pkg = JSON.parse(_fs.readFileSync(pkgPath, "utf-8"));
+                projectName = pkg.name ?? "";
+                projectDescription = pkg.description ?? "";
+            }
+        }
+        catch {
+            // silently ignore — repo context is best-effort
+        }
+        const repoContextParts = [];
+        if (projectName)
+            repoContextParts.push(`Project name: ${projectName}`);
+        if (projectDescription)
+            repoContextParts.push(`Project description: ${projectDescription}`);
+        const repoSection = repoContextParts.length > 0
+            ? `\nRepository context:\n${repoContextParts.join("\n")}\n`
+            : "";
+        const existingTasksSection = existingTasks && existingTasks.length > 0
+            ? `\n=== Previously Generated Tasks (avoid duplication) ===\n${existingTasks.join("\n")}\nGenerate a task that addresses a DIFFERENT aspect of the goal than the existing tasks above.\n`
+            : "";
+        const workspaceSection = workspaceContext
+            ? `\n=== Current Workspace State ===\n${workspaceContext}\n`
+            : "\n=== Current Workspace State ===\nNo workspace context available.\n";
+        return `${goalSection}
+${dimensionSection}
+${repoSection}${adapterSection}${knowledgeSection}${workspaceSection}${existingTasksSection}
+IMPORTANT: Generate a task that is SPECIFIC to the actual project described above (goal title, description, and repository context). Do NOT suggest generic software improvements (e.g., user authentication, social media login, unrelated features) unless they are explicitly mentioned in the goal description. Base the task entirely on what the goal and project are actually about.
+
+Generate ONE specific, concrete, actionable task that will directly improve the "${targetDimension}" dimension toward its target. The task should produce a single measurable output achievable in a single work session. Do not generate vague review or triage tasks — generate a task with a precise, well-defined deliverable.
+
+IMPORTANT: The task's work_description MUST include:
+1. Target file path(s) to modify or create
+2. Specific changes (not "improve X" but "add section Y to file Z")
+3. Completion criteria that can be verified
+
+Return a JSON object with the following schema:
+{
+  "work_description": "string — what to do",
+  "rationale": "string — why this task matters",
+  "approach": "string — how to accomplish it",
+  "success_criteria": [
+    {
+      "description": "string — what success looks like",
+      "verification_method": "string — how to verify",
+      "is_blocking": true
+    }
+  ],
+  "scope_boundary": {
+    "in_scope": ["string — what is included"],
+    "out_of_scope": ["string — what is excluded"],
+    "blast_radius": "string — what could be affected"
+  },
+  "constraints": ["string — any constraints"],
+  "reversibility": "reversible" | "irreversible" | "unknown",
+  "estimated_duration": { "value": number, "unit": "minutes" | "hours" | "days" | "weeks" } | null
+}
+
+Respond with only the JSON object inside a markdown code block.`;
+    }
+    // ─── Verification Helpers ───
+    async runMechanicalVerification(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 (!this.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 = this.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 = this.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);
+            this.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 runLLMReview(task, executionResult) {
+        // Create review session
+        const reviewSession = this.sessionManager.createSession("task_review", task.goal_id, task.id);
+        // Build review context (excludes executor self-report for bias prevention)
+        const reviewContext = this.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 prompt = `Evaluate this task execution result against the success criteria.
+
+Task: ${task.work_description}
+Approach: ${task.approach}
+
+Success Criteria:
+${criteriaList}
+
+Execution Output (first 2000 chars):
+${executionResult.output.slice(0, 2000)}
+
+Execution Status: ${executionResult.stopped_reason}
+Execution Success: ${executionResult.success}
+
+Context: ${reviewContext.map((s) => s.content).join(" ")}
+
+Evaluate whether the task output satisfies the success criteria. Respond with JSON:
+{"verdict": "pass" | "partial" | "fail", "reasoning": "explanation", "criteria_met": number, "criteria_total": number}`;
+        const response = await this.llmClient.sendMessage([{ role: "user", content: prompt }], {
+            system: "You are an independent task reviewer. Evaluate task results objectively against success criteria. Do NOT consider the executor's self-assessment.",
+            max_tokens: 1024,
+        });
+        try {
+            const parsed = JSON.parse(response.content.replace(/```json\n?/g, "").replace(/```/g, "").trim());
+            const verdictStr = parsed.verdict ?? "fail";
+            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,
+            };
+            this.sessionManager.endSession(reviewSession.id, `LLM review: ${verdictStr}`);
+            return result;
+        }
+        catch {
+            this.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,
+            };
+        }
+    }
+    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] : [],
+        };
+    }
+    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 attemptRevert(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 = this.sessionManager.createSession("task_execution", task.goal_id, task.id);
+            const revertPrompt = `Revert the changes made by task "${task.work_description}". Undo all modifications within scope: ${task.scope_boundary.in_scope.join(", ")}.
+
+After completing the revert, respond with a JSON object:
+{"success": true/false, "reason": "explanation of what was done or why it failed"}`;
+            const response = await this.llmClient.sendMessage([{ role: "user", content: revertPrompt }], { system: "You are reverting a failed task. Undo all changes. Respond with JSON: {\"success\": boolean, \"reason\": string}", max_tokens: 512 });
+            this.sessionManager.endSession(revertSession.id, response.content);
+            // Parse structured JSON response
+            try {
+                const parsed = this.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;
+        }
+    }
+    setDimensionIntegrity(goalId, dimensionName, integrity) {
+        // Attempt to update the dimension's state_integrity flag
+        // Read the goal, find the dimension, update integrity
+        const goalData = this.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;
+                    }
+                }
+                this.stateManager.writeRaw(`goals/${goalId}/goal.json`, goal);
+            }
+        }
+    }
+    appendTaskHistory(goalId, task) {
+        const historyPath = `tasks/${goalId}/task-history.json`;
+        const existing = this.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
+            ? this.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,
+        });
+        this.stateManager.writeRaw(historyPath, history);
+    }
+    durationToMs(duration) {
+        const multipliers = {
+            minutes: 60 * 1000,
+            hours: 60 * 60 * 1000,
+            days: 24 * 60 * 60 * 1000,
+            weeks: 7 * 24 * 60 * 60 * 1000,
+        };
+        return duration.value * (multipliers[duration.unit] ?? 60 * 60 * 1000);
+    }
+    // ─── Post-Execution Health Check ───
+    /**
+     * Run build and test checks after successful task execution to verify
+     * the codebase remains healthy. Opt-in via healthCheckEnabled constructor option.
+     */
+    async runPostExecutionHealthCheck(_adapter, _task) {
+        // Run build check
+        try {
+            const buildResult = await this.runShellCommand(["npm", "run", "build"], {
+                timeout: 60000,
+                cwd: process.cwd(),
+            });
+            if (!buildResult.success) {
+                return {
+                    healthy: false,
+                    output: `Build failed: ${buildResult.stderr || buildResult.stdout}`,
+                };
+            }
+        }
+        catch (err) {
+            return { healthy: false, output: `Build check error: ${err}` };
+        }
+        // Run quick test check (just verify tests still pass)
+        try {
+            const testResult = await this.runShellCommand(["npx", "vitest", "run", "--reporter=dot"], { timeout: 120000, cwd: process.cwd() });
+            if (!testResult.success) {
+                return {
+                    healthy: false,
+                    output: `Tests failed: ${testResult.stderr || testResult.stdout}`,
+                };
+            }
+        }
+        catch (err) {
+            return { healthy: false, output: `Test check error: ${err}` };
+        }
+        return { healthy: true, output: "Build and tests passed" };
+    }
+    /**
+     * Run a shell command safely using execFile (not exec) to avoid shell injection.
+     */
+    async runShellCommand(argv, options) {
+        const { execFile } = await import("child_process");
+        const { promisify } = await import("util");
+        const execFileAsync = promisify(execFile);
+        try {
+            const { stdout, stderr } = await execFileAsync(argv[0], argv.slice(1), {
+                timeout: options.timeout,
+                cwd: options.cwd,
+            });
+            return { success: true, stdout, stderr };
+        }
+        catch (err) {
+            if (typeof err === "object" && err !== null && "stdout" in err) {
+                const e = err;
+                return { success: false, stdout: e.stdout || "", stderr: e.stderr || "" };
+            }
+            return { success: false, stdout: "", stderr: String(err) };
+        }
+    }
+}
+//# sourceMappingURL=task-lifecycle.js.map