soloforge 1.5.0 → 2.0.0

package/dist/engine/task_context.js

@@ -1,983 +0,0 @@
-import fs from "node:fs/promises";
-import fss from "node:fs";
-import path from "node:path";
-import crypto from "node:crypto";
-import { validateTransition } from "./artifact_contract_registry.js";
-import { scanTextSensitivity, redactSensitiveText } from "./privacy_secret_contract.js";
-import { AuditPool } from "./audit_pool.js";
-import { DiffOwnershipStore } from "./diff_ownership_store.js";
-import { ScopeLeaseStore } from "./scope_lease.js";
-import { ConflictGate } from "./conflict_gate.js";
-import { evaluateStateGuard } from "./enforcement_guard.js";
-import { evaluateNoFalseCompletion, recordCepIntegration } from "./core_experience_principle.js";
-import { debug } from "./logger.js";
-import { migrateTaskContext } from "./legacy_type_migration.js";
-/**
- * 任务上下文管理器 — 管理任务的完整生命周期状态持久化。
- *
- * 核心职责:
- * - 创建/加载/保存任务上下文（JSON 文件存储）
- * - 管理状态机转换（classifying → expanding → executing → verifying → learning → done）
- * - 追踪执行结果（变更文件、失败记录）
- * - 修复循环追踪（能力 3: 自动修复尝试计数和复发检测）
- * - 返工历史追踪（能力 6: 返工次数阈值检查和阶段指令计算）
- * - 任务清理（过期任务和超量任务淘汰）
- *
- * 状态转换遵循 VALID_TRANSITIONS 严格定义的合法路径。
- */
-const MAX_TASK_AGE_DAYS = 30;
-const MAX_TASKS = 100;
-const MAX_REWORK = 3;
-// 状态转换表: 定义每个状态允许的合法后继状态
-const VALID_TRANSITIONS = {
-    classifying: ["expanding", "done", "failed"],
-    expanding: ["executing", "clarifying", "failed"],
-    clarifying: ["expanding", "failed"],
-    executing: ["verifying", "retrying", "reworking", "failed"],
-    verifying: ["learning", "retrying", "reworking", "done", "failed"],
-    retrying: ["executing", "reworking", "failed"],
-    reworking: ["expanding", "executing", "failed"],
-    learning: ["done", "retrying", "reworking", "failed"],
-    done: [],
-    failed: ["expanding"],
-};
-/**
- * 任务上下文管理器 — 负责任务状态的创建、持久化、查询和生命周期管理。
- * 状态文件存储在 stateDir 目录下，每个任务一个 JSON 文件。
- * 使用 "current-task.json" 指针文件标记当前活跃任务。
- */
-export class TaskContextManager {
-    stateDir;
-    auditPool;
-    diffOwnership;
-    scopeLease;
-    conflictGate;
-    constructor(stateDir) {
-        this.stateDir = stateDir;
-        fss.mkdirSync(stateDir, { recursive: true });
-        this.auditPool = new AuditPool(stateDir);
-        this.diffOwnership = new DiffOwnershipStore(stateDir);
-        this.scopeLease = new ScopeLeaseStore(stateDir);
-        this.conflictGate = new ConflictGate(this.diffOwnership, this.scopeLease);
-    }
-    /** 获取状态存储目录路径 */
-    getStateDir() {
-        return this.stateDir;
-    }
-    /** 获取审计池实例 */
-    getAuditPool() {
-        return this.auditPool;
-    }
-    /** 获取 Diff 归属追踪实例 */
-    getDiffOwnership() {
-        return this.diffOwnership;
-    }
-    /** 获取 Scope Lease 实例 */
-    getScopeLease() {
-        return this.scopeLease;
-    }
-    /** 获取冲突合并门实例 */
-    getConflictGate() {
-        return this.conflictGate;
-    }
-    /**
-     * 创建新任务上下文，生成唯一 ID 并持久化到磁盘。
-     * @param intent - 用户意图文本
-     * @param productProfile - 产品类型标识
-     * @returns 新创建的任务上下文
-     */
-    async create(intent, productProfile) {
-        const taskId = `task-${crypto.randomUUID().slice(0, 8)}`;
-        const ctx = {
-            task_id: taskId,
-            created_at: new Date().toISOString(),
-            updated_at: new Date().toISOString(),
-            intent,
-            product_profile: productProfile,
-            status: "classifying",
-        };
-        // 隐私门禁: 扫描用户意图中的密钥/凭证信息
-        const intentLabels = scanTextSensitivity(intent, "intent");
-        const secretLabels = intentLabels.filter((l) => l.label === "secret" || l.label === "credential");
-        if (secretLabels.length > 0) {
-            throw new Error(`TaskContext.create 阻断: 用户意图包含禁止级别的敏感信息 (${secretLabels.map((l) => l.label).join(", ")}), 不允许保存`);
-        }
-        // PII/客户/生产数据: 保存前对意图进行脱敏处理
-        const piiLabels = intentLabels.filter((l) => l.label === "pii" || l.label === "customer_data" || l.label === "production_data");
-        if (piiLabels.length > 0) {
-            const redacted = redactSensitiveText(intent, "intent");
-            ctx.intent = redacted.redacted;
-            ctx.sensitivity_labels = intentLabels;
-            ctx.redaction_records = redacted.records;
-        }
-        await this.save(ctx);
-        await this.writeCurrentPointer(taskId);
-        debug("任务上下文", "创建任务 " + taskId);
-        return ctx;
-    }
-    /**
-     * 从磁盘加载任务上下文。
-     * @param taskId - 任务 ID
-     * @returns 任务上下文对象，不存在或解析失败时返回 null
-     */
-    async load(taskId) {
-        const filePath = this.taskFilePath(taskId);
-        try {
-            const data = await fs.readFile(filePath, "utf-8");
-            const raw = JSON.parse(data);
-            return migrateTaskContext(raw);
-        }
-        catch (e) {
-            debug("任务上下文", "加载任务文件失败(预期行为: 文件不存在或解析错误) —", taskId, e);
-            return null;
-        }
-    }
-    /**
-     * 持久化任务上下文到磁盘（先写临时文件再 rename，保证原子性）。
-     * @param ctx - 任务上下文对象
-     */
-    async save(ctx) {
-        // problem-17: 保存前校验 StateFact 分区合规性
-        const { validateStateFactPartition } = await import("./state_fact_classifier.js");
-        const violations = validateStateFactPartition(ctx);
-        const hardFails = violations.filter(v => v.severity === "hard_fail");
-        if (hardFails.length > 0) {
-            const msgs = hardFails.map(v => v.message_zh).join("; ");
-            throw new Error(`StateFact 分区违规: ${msgs}`);
-        }
-        const filePath = this.taskFilePath(ctx.task_id);
-        ctx.updated_at = new Date().toISOString();
-        // 原子写入: 使用任务级唯一 tmp 文件名，避免并发写同一个 .tmp
-        const tmpPath = `${filePath}.${ctx.task_id}.tmp`;
-        try {
-            await fs.writeFile(tmpPath, JSON.stringify(ctx, null, 2));
-            await fs.rename(tmpPath, filePath);
-        }
-        catch (e) {
-            await fs.unlink(tmpPath).catch(() => { });
-            throw e;
-        }
-    }
-    /**
-     * 更新任务状态，严格校验状态转换合法性。
-     * @param taskId - 任务 ID
-     * @param status - 目标状态
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     * @throws 非法状态转换时抛出 Error
-     */
-    async updateStatus(taskId, status, existingCtx) {
-        const ctx = existingCtx ?? await this.load(taskId);
-        if (!ctx)
-            return null;
-        if (!VALID_TRANSITIONS[ctx.status].includes(status)) {
-            throw new Error(`无效状态转换: ${ctx.status} → ${status}`);
-        }
-        // 状态护栏 — 阻断 failed/blocked/requires_human → done
-        if (["failed", "blocked", "requires_human"].includes(ctx.status) && status === "done") {
-            const guardFindings = evaluateStateGuard(ctx.status, "completed", "task_context_contract");
-            if (guardFindings.length > 0 && guardFindings[0].blocked) {
-                throw new Error(`状态护栏阻断: ${guardFindings[0].reason_zh}`);
-            }
-        }
-        // 事实前置条件校验：防止无数据伪推进
-        if (ctx.status === "classifying" && status === "expanding") {
-            if (!ctx.classification) {
-                throw new Error(`事实缺失: classifying → expanding 需要 classification`);
-            }
-        }
-        if (ctx.status === "expanding" && status === "executing") {
-            if (!ctx.expansion) {
-                throw new Error(`事实缺失: expanding → executing 需要 expansion`);
-            }
-        }
-        if (ctx.status === "executing" && status === "verifying") {
-            const hasChangedFiles = ctx.execution && ctx.execution.changed_files.length > 0;
-            const hasFailureHistory = ctx.execution && ctx.execution.failure_history.length > 0;
-            const hasNoChangeArtifact = ctx.execution?.no_change_artifact === true;
-            if (!hasChangedFiles && !hasFailureHistory && !hasNoChangeArtifact) {
-                throw new Error(`事实缺失: executing → verifying 需要 execution evidence (changed_files / failure_history / no_change_artifact)`);
-            }
-        }
-        if (ctx.status === "verifying" && (status === "learning" || status === "done")) {
-            if (!ctx.verification && !ctx.skip_verification_reason) {
-                throw new Error(`事实缺失: verifying → ${status} 需要 verification（或显式 skip_verification_reason）`);
-            }
-        }
-        if (ctx.status === "failed" && status === "expanding") {
-            if (!ctx.classification) {
-                throw new Error(`事实缺失: failed → expanding 需要 classification`);
-            }
-        }
-        const prevStatus = ctx.status;
-        ctx.status = status;
-        await this.save(ctx);
-        debug("任务上下文", "任务 " + taskId + " 状态转换 " + prevStatus + " → " + status);
-        if (status === "executing") {
-            // CAP-011: 进入执行阶段时自动从膨胀范围捕获 baseline
-            const scopePaths = ctx.expansion?.scope?.allowed_paths;
-            if (scopePaths && scopePaths.length > 0) {
-                this.diffOwnership.captureBaselineFromScope(taskId, scopePaths);
-                this.scopeLease.acquire(taskId, scopePaths);
-            }
-        }
-        if (status === "done" || status === "failed") {
-            if (status === "done") {
-                this.auditPool.append({
-                    task_id: ctx.task_id,
-                    risk: (ctx.classification?.risk ?? "low"),
-                    changed_files: ctx.execution?.changed_files ?? [],
-                    evidence: ctx.classification?.strategy ?? "",
-                    capability_refs: [],
-                    created_at: new Date().toISOString(),
-                });
-            }
-            // CAP-011: 终态时清理 Diff 归属和 Scope Lease
-            this.diffOwnership.clearTask(taskId);
-            this.scopeLease.release(taskId);
-            await this.clearCurrentPointerIfMatches(taskId);
-        }
-        return ctx;
-    }
-    /**
-     * 设置任务的分类结果。
-     * @param taskId - 任务 ID
-     * @param result - 分类结果
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setClassification(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.classification = result;
-        // 持久化 route_decision 到顶层字段，确保后续阶段可直接访问
-        if (result.route_decision) {
-            ctx.route_decision = result.route_decision;
-        }
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 设置任务的意图膨胀结果。
-     * @param taskId - 任务 ID
-     * @param result - 膨胀结果
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setExpansion(taskId, result, existingCtx) {
-        const ctx = existingCtx ?? await this.load(taskId);
-        if (!ctx)
-            return null;
-        const allLabels = [];
-        // 辅助函数: 扫描文本字段并收集标签
-        const scanField = (text, ref) => {
-            const labels = scanTextSensitivity(text, ref);
-            allLabels.push(...labels);
-            return labels;
-        };
-        // 辅助函数: 检测到密钥/凭证时阻断保存
-        const blockOnForbidden = (labels, ref) => {
-            const forbidden = labels.filter((l) => l.label === "secret" || l.label === "credential");
-            if (forbidden.length > 0) {
-                throw new Error(`TaskContext.setExpansion 阻断: 膨胀结果包含禁止级别的敏感信息 (${forbidden.map((l) => l.label).join(", ")}), 不允许保存`);
-            }
-        };
-        // 辅助函数: 对文本字段进行脱敏，替换为 [摘要] 前缀
-        const summarizeField = (text) => {
-            const labels = scanTextSensitivity(text, "summarize");
-            const needsRedact = labels.some((l) => l.label === "pii" || l.label === "customer_data" || l.label === "production_data");
-            if (!needsRedact)
-                return text;
-            const detected = labels.map((l) => l.label).join(",");
-            return `[摘要]检测到${detected}敏感内容，已脱敏`;
-        };
-        // 1. 扫描 prompt
-        const promptLabels = scanField(result.prompt, "expansion_prompt");
-        blockOnForbidden(promptLabels, "expansion_prompt");
-        // 若 prompt 包含 PII/客户/生产数据则脱敏
-        const promptSensitive = promptLabels.filter((l) => l.label === "pii" || l.label === "customer_data" || l.label === "production_data");
-        const promptRedactionRecords = [];
-        if (promptSensitive.length > 0) {
-            const redactedPrompt = `[摘要]检测到${promptSensitive.map((l) => l.label).join(",")}敏感内容，已脱敏`;
-            result = { ...result, prompt: redactedPrompt };
-            promptRedactionRecords.push({
-                source_ref: "expansion_prompt",
-                redaction_type: "pii_mask",
-                after_hash: redactedPrompt,
-                fields_redacted: promptSensitive.map((l) => l.label),
-            });
-        }
-        // 2. 扫描 ingestion_evidences 的 source_ref
-        if (result.ingestion_evidences?.length) {
-            for (const ev of result.ingestion_evidences) {
-                if (ev.source_ref) {
-                    const evLabels = scanField(ev.source_ref, "ingestion_evidence_source_ref");
-                    blockOnForbidden(evLabels, "ingestion_evidence_source_ref");
-                }
-            }
-        }
-        // 3. 清理 output_artifact_record 字段
-        if (result.output_artifact_record) {
-            const oar = result.output_artifact_record;
-            if (oar.path) {
-                oar.path = summarizeField(oar.path);
-            }
-            if (oar.source_material_refs?.length) {
-                oar.source_material_refs = oar.source_material_refs.map((ref) => summarizeField(ref));
-            }
-        }
-        // 4. 清理 prompt_injection_plan 的 evidence_refs
-        if (result.prompt_injection_plan?.evidence_refs?.length) {
-            result.prompt_injection_plan.evidence_refs =
-                result.prompt_injection_plan.evidence_refs.map((ref) => summarizeField(ref));
-        }
-        // 5. 清理 privacy_findings 字段
-        if (result.privacy_findings?.length) {
-            result.privacy_findings = result.privacy_findings.map((pf) => ({
-                ...pf,
-                source_ref: summarizeField(pf.source_ref ?? ""),
-                rule: summarizeField(pf.rule ?? ""),
-                message: summarizeField(pf.message ?? ""),
-            }));
-        }
-        ctx.expansion = result;
-        // 持久化 workflow_trace 到顶层字段，确保后续阶段可直接访问
-        if (result.workflow_trace) {
-            ctx.workflow_trace = result.workflow_trace;
-        }
-        ctx.ingestion_evidences = result.ingestion_evidences?.length ? result.ingestion_evidences : undefined;
-        // 合并 sensitivity_labels
-        if (result.sensitivity_labels && result.sensitivity_labels.length > 0) {
-            const existingLabels = ctx.sensitivity_labels ?? [];
-            const all = [...existingLabels, ...result.sensitivity_labels, ...allLabels];
-            ctx.sensitivity_labels = [...new Map(all.map((l) => [`${l.label}:${l.source_ref}`, l])).values()];
-        }
-        else if (allLabels.length > 0) {
-            const existingLabels = ctx.sensitivity_labels ?? [];
-            ctx.sensitivity_labels = [...existingLabels, ...allLabels];
-        }
-        // 合并 redaction_records（本地 prompt + result 自带的）
-        const existingRecords = ctx.redaction_records ?? [];
-        const resultRecords = result.redaction_records ?? [];
-        const allRecords = [...existingRecords, ...resultRecords, ...promptRedactionRecords];
-        ctx.redaction_records = allRecords.length > 0 ? allRecords : undefined;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 记录执行结果: 变更文件列表和可选的失败记录。
-     * 变更文件自动去重合并，失败记录追加到历史。
-     * @param taskId - 任务 ID
-     * @param changedFiles - 变更文件路径列表
-     * @param failure - 可选的失败记录
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setExecution(taskId, changedFiles, failure) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        if (!ctx.execution) {
-            ctx.execution = {
-                changed_files: [],
-                attempt_count: 0,
-                max_attempts: 3,
-                failure_history: [],
-            };
-        }
-        ctx.execution.changed_files = [
-            ...new Set([...ctx.execution.changed_files, ...changedFiles]),
-        ];
-        if (failure) {
-            ctx.execution.attempt_count++;
-            ctx.execution.failure_history.push(failure);
-        }
-        // CAP-011: 记录任务写入用于 Diff 归属追踪（建议性）
-        for (const f of changedFiles) {
-            this.diffOwnership.recordWrite(taskId, f);
-        }
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 设置任务的验证结果。
-     * @param taskId - 任务 ID
-     * @param result - 验证结果
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setVerification(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.verification = result;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 获取当前活跃任务（通过 current-task.json 指针定位）。
-     * @returns 当前任务上下文，无活跃任务或读取失败时返回 null
-     */
-    async getCurrentTask() {
-        try {
-            const data = await fs.readFile(this.pointerPath, "utf-8");
-            const { task_id } = JSON.parse(data);
-            const ctx = await this.load(task_id);
-            if (!ctx) {
-                await this.clearCurrentPointerIfMatches(task_id);
-                return null;
-            }
-            if (ctx.status === "done" || ctx.status === "failed") {
-                await this.clearCurrentPointerIfMatches(task_id);
-                return null;
-            }
-            return ctx;
-        }
-        catch (e) {
-            debug("任务上下文", "获取当前任务失败(预期行为: 指针文件不存在或解析错误) —", e);
-            return null;
-        }
-    }
-    /**
-     * 取消/关闭任务，将未完成任务标记为 failed；终态任务执行幂等清理。
-     * @param taskId - 任务 ID
-     * @returns 是否取消/关闭成功
-     */
-    async cancel(taskId) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return false;
-        if (ctx.status === "done" || ctx.status === "failed") {
-            this.diffOwnership.clearTask(taskId);
-            this.scopeLease.release(taskId);
-            await this.clearCurrentPointerIfMatches(taskId);
-            debug("任务上下文", "已关闭终态任务 " + taskId);
-            return true;
-        }
-        // 通过 VALID_TRANSITIONS 校验取消是否合法
-        const allowed = VALID_TRANSITIONS[ctx.status];
-        if (!allowed || !allowed.includes("failed")) {
-            debug("任务上下文", `无法从 ${ctx.status} 取消到 failed`);
-            return false;
-        }
-        ctx.status = "failed";
-        await this.save(ctx);
-        // CAP-011: 取消任务时清理 Diff 归属和 Scope Lease
-        this.diffOwnership.clearTask(taskId);
-        this.scopeLease.release(taskId);
-        await this.clearCurrentPointerIfMatches(taskId);
-        debug("任务上下文", "已取消任务 " + taskId);
-        return true;
-    }
-    /**
-     * 将失败任务恢复到 expanding 状态以重试 sf_expand。
-     * 通过 updateStatus 走正式状态转换，确保事实前置条件和副作用被正确处理。
-     */
-    async retryExpand(taskId) {
-        const ctx = await this.load(taskId);
-        if (!ctx || ctx.status !== "failed")
-            return false;
-        if (!ctx.classification)
-            return false;
-        try {
-            const updated = await this.updateStatus(taskId, "expanding");
-            if (!updated)
-                return false;
-            await this.writeCurrentPointer(taskId);
-            debug("任务上下文", "已恢复任务到 expanding: " + taskId);
-            return true;
-        }
-        catch (e) {
-            debug("任务上下文", "恢复任务失败: " + (e instanceof Error ? e.message : String(e)));
-            return false;
-        }
-    }
-    /**
-     * 判断任务是否可恢复（非 done / failed / classifying 状态均可恢复）。
-     * @param ctx - 任务上下文
-     * @returns 是否可恢复
-     */
-    isResumable(ctx) {
-        return !["done", "failed", "classifying"].includes(ctx.status);
-    }
-    /**
-     * 根据当前状态生成恢复提示信息。
-     * @param ctx - 任务上下文
-     * @returns 恢复提示文本
-     */
-    getResumeHint(ctx) {
-        const hints = {
-            expanding: "意图膨胀未完成，需重新执行 sf_expand",
-            executing: "代码执行中断，需重新执行代码修改",
-            verifying: "验证未完成，需调用 sf_verify",
-            retrying: "重试中断，需继续修复",
-            learning: "自进化未完成，需调用 sf_learn",
-            reworking: "返工中，需回溯到上游阶段重新执行",
-        };
-        return hints[ctx.status] || "未知状态";
-    }
-    /**
-     * 列出最近的任务（按创建时间降序排列）。
-     * @param limit - 返回数量上限，默认 10
-     * @returns 任务摘要列表
-     */
-    async listRecent(limit = 10) {
-        const files = await fs.readdir(this.stateDir);
-        const taskFiles = files.filter((f) => f.startsWith("task-") && f.endsWith(".json"));
-        const tasks = await Promise.all(taskFiles.map(async (f) => {
-            const data = await fs.readFile(path.join(this.stateDir, f), "utf-8");
-            const ctx = JSON.parse(data);
-            return {
-                task_id: ctx.task_id,
-                intent: ctx.intent,
-                status: ctx.status,
-                created_at: ctx.created_at,
-            };
-        }));
-        return tasks
-            .sort((a, b) => b.created_at.localeCompare(a.created_at))
-            .slice(0, limit);
-    }
-    /**
-     * 自动终结陈旧的非终态任务。
-     * executing/verifying/learning 超过 30 分钟、其他非终态超过 60 分钟自动转为 failed。
-     * @returns 被终结的任务 ID 列表
-     */
-    async autoFailStale() {
-        const STALE_MS_EXECUTING = 30 * 60 * 1000; // 30 分钟
-        const STALE_MS_OTHER = 60 * 60 * 1000; // 60 分钟
-        const TERMINAL = new Set(["done", "failed"]);
-        const now = Date.now();
-        const failed = [];
-        const files = await fs.readdir(this.stateDir);
-        const taskFiles = files.filter((f) => f.startsWith("task-") && f.endsWith(".json"));
-        for (const f of taskFiles) {
-            try {
-                const filePath = path.join(this.stateDir, f);
-                const content = await fs.readFile(filePath, "utf-8");
-                const ctx = JSON.parse(content);
-                if (!ctx.task_id || !ctx.status || TERMINAL.has(ctx.status))
-                    continue;
-                const ageMs = new Date(ctx.created_at).getTime();
-                const elapsed = now - ageMs;
-                const isStale = ctx.status === "executing" || ctx.status === "verifying" || ctx.status === "learning"
-                    ? elapsed > STALE_MS_EXECUTING
-                    : elapsed > STALE_MS_OTHER;
-                if (isStale) {
-                    const prevStatus = ctx.status;
-                    try {
-                        await this.updateStatus(ctx.task_id, "failed");
-                        failed.push(ctx.task_id);
-                        debug("任务上下文", `自动终结陈旧任务 ${ctx.task_id} (${prevStatus}, ${Math.round(elapsed / 60000)}min)`);
-                    }
-                    catch {
-                        // 状态转换不合法时跳过（如已终态）
-                    }
-                }
-            }
-            catch {
-                // 跳过不可读文件
-            }
-        }
-        return failed;
-    }
-    /**
-     * 清理过期和超量任务: 使用 retention_policy 驱动清理决策。
-     * @param dryRun - 默认 true，仅评估不删除
-     * @returns 清理评估结果
-     */
-    async cleanup(dryRun = true) {
-        const { evaluateCleanup, checkForbiddenContent } = await import("./retention_policy.js");
-        const files = await fs.readdir(this.stateDir);
-        const taskFiles = files.filter((f) => f.startsWith("task-") && f.endsWith(".json"));
-        const now = Date.now();
-        const allForbiddenHits = [];
-        const allTasks = [];
-        for (const f of taskFiles) {
-            try {
-                const filePath = path.join(this.stateDir, f);
-                const content = await fs.readFile(filePath, "utf-8");
-                const ctx = JSON.parse(content);
-                // 检查禁止内容: task_context 不得包含 raw_prompt/chain_of_thought/secret 等
-                const forbiddenHits = checkForbiddenContent("task_context", content);
-                if (forbiddenHits.length > 0) {
-                    allForbiddenHits.push(`${ctx.task_id ?? f}: ${forbiddenHits.join(", ")}`);
-                }
-                const createdAt = ctx.created_at ? new Date(ctx.created_at).getTime() : now;
-                const stat = await fs.stat(filePath);
-                const earliestTime = Math.min(createdAt, stat.mtimeMs);
-                const ageDays = Math.max(0, (now - earliestTime) / (24 * 60 * 60 * 1000));
-                const isReferenced = !["done", "failed"].includes(ctx.status ?? "");
-                if (ctx.task_id && ctx.created_at && ctx.status) {
-                    allTasks.push({ task_id: ctx.task_id, created_at: ctx.created_at, status: ctx.status, file: filePath, age_days: ageDays });
-                }
-                else if (ageDays > MAX_TASK_AGE_DAYS) {
-                    // 无法解析的过期文件
-                    allTasks.push({ task_id: f, created_at: "", status: "done", file: filePath, age_days: ageDays });
-                }
-            }
-            catch {
-                // 跳过不可读文件
-            }
-        }
-        // 使用 retention policy 评估清理候选
-        const records = allTasks.map(t => ({ id: t.task_id, age_days: t.age_days, is_referenced: !["done", "failed"].includes(t.status) }));
-        const result = evaluateCleanup("task_context", records, dryRun);
-        let removed = 0;
-        if (!dryRun && result.cleanup_candidates.length > 0) {
-            for (const taskId of result.cleanup_candidates) {
-                const task = allTasks.find(t => t.task_id === taskId);
-                if (task) {
-                    try {
-                        await fs.unlink(task.file);
-                        removed++;
-                    }
-                    catch {
-                        // 文件已被删除
-                    }
-                }
-            }
-        }
-        return {
-            removed: dryRun ? 0 : removed,
-            protected: result.protected_records,
-            forbidden_content_hits: allForbiddenHits,
-            dry_run: result.dry_run,
-        };
-    }
-    /**
-     * 设置任务计划结果。
-     * @param taskId - 任务 ID
-     * @param result - 计划结果
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setPlanning(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.planning = result;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 设置代码审查结果，并基于审查发现计算阶段指令（能力 6）。
-     * @param taskId - 任务 ID
-     * @param result - 代码审查结果
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setCodeReview(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.code_review = result;
-        // 能力 6: 基于审查结果计算阶段指令
-        ctx.phase_directive = computePhaseDirective(ctx);
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 设置交付结果。
-     * @param taskId - 任务 ID
-     * @param result - 交付结果
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setDelivery(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.delivery = result;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 设置工具调用追踪和违规记录。
-     */
-    async setToolTrace(taskId, trace, violations) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.last_tool_trace = trace;
-        if (violations && violations.length > 0) {
-            ctx.invocation_violations = violations;
-        }
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 持久化 Plan Proposal Gate 评估结果。
-     */
-    async setPlanProposalGate(taskId, gate, existingCtx) {
-        const ctx = existingCtx ?? await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.plan_proposal_gate = gate;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 持久化 Plan Proposal Evidence。
-     */
-    async setPlanProposalEvidence(taskId, evidence) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.plan_proposal_evidence = evidence;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 在执行动作前检查 Plan Gate。
-     */
-    checkPlanGateBeforeWrite(ctx) {
-        const gate = ctx.plan_proposal_gate;
-        if (!gate) {
-            return { allowed: false, reason_zh: "执行前缺少 Plan Proposal Gate 评估结果" };
-        }
-        if (!gate.passed) {
-            return { allowed: false, reason_zh: `Plan Gate 未通过: ${gate.reason_zh}` };
-        }
-        if (gate.blocked_actions.length > 0) {
-            return { allowed: false, reason_zh: `以下动作被 Plan Gate 阻断: ${gate.blocked_actions.join(", ")}` };
-        }
-        return { allowed: true, reason_zh: "Plan Gate 通过" };
-    }
-    /**
-     * 设置任务产物输出。
-     * @param taskId - 任务 ID
-     * @param artifact - 产物输出对象
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async setArtifact(taskId, artifact, existingCtx) {
-        const ctx = existingCtx ?? await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.artifact_output = artifact;
-        await this.save(ctx);
-        return ctx;
-    }
-    /**
-     * 更新产物状态并追加 evidence_ref。
-     * 仅在当前 artifact_output 存在时生效。
-     */
-    async updateArtifactStatus(taskId, params) {
-        // 向后兼容: 接受裸字符串状态
-        const p = typeof params === "string"
-            ? { status: params }
-            : params;
-        const ctx = await this.load(taskId);
-        if (!ctx || !ctx.artifact_output)
-            return null;
-        const artifact = ctx.artifact_output;
-        // 通过生命周期规则验证状态转换
-        const findings = validateTransition(artifact, p.status, p.hasVerification ?? false, p.hasAcceptance ?? false);
-        const hardFails = findings.filter(f => f.severity === "hard_fail");
-        if (hardFails.length > 0) {
-            const err = new Error(`updateArtifactStatus blocked: ${hardFails.map(f => f.message).join("; ")}`);
-            err.findings = findings;
-            throw err;
-        }
-        artifact.status = p.status;
-        if (p.evidenceRef) {
-            artifact.evidence_refs = [...(artifact.evidence_refs ?? []), p.evidenceRef];
-        }
-        await this.save(ctx);
-        return ctx;
-    }
-    // ── 能力 3: 修复循环追踪 ──
-    /**
-     * 更新修复循环状态（能力 3）: 递增尝试次数，记录失败阶段和自动修复能力。
-     * 同时统计同一阶段的复发次数。
-     * @param taskId - 任务 ID
-     * @param failurePhase - 发生失败的阶段名称
-     * @param autoRepairable - 是否可自动修复
-     * @param escalationReason - 可选的升级原因
-     * @returns 更新后的任务上下文，任务不存在或无执行记录时返回 null
-     */
-    async updateRepairLoop(taskId, failurePhase, autoRepairable, escalationReason) {
-        const ctx = await this.load(taskId);
-        if (!ctx || !ctx.execution)
-            return null;
-        if (!ctx.execution.repair_loop) {
-            ctx.execution.repair_loop = {
-                attempt: 0,
-                max_attempts: 3,
-                phase_origin: failurePhase,
-                auto_repairable: true,
-                recurrence_count: 0,
-            };
-        }
-        ctx.execution.repair_loop.attempt++;
-        ctx.execution.repair_loop.phase_origin = failurePhase;
-        ctx.execution.repair_loop.auto_repairable = autoRepairable;
-        ctx.execution.repair_loop.escalation_reason = escalationReason;
-        // 复发计数
-        const samePhaseFailures = ctx.execution.failure_history.filter((f) => f.phase === failurePhase);
-        ctx.execution.repair_loop.recurrence_count = samePhaseFailures.length;
-        await this.save(ctx);
-        return ctx;
-    }
-    // ── 问题六十：证据驱动门禁结果写回 ──
-    /** 证据驱动门禁结果写入 payload */
-    async setEvidenceGroundingResult(taskId, payload) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        if (payload.evidence_matrix)
-            ctx.evidence_matrix = payload.evidence_matrix;
-        if (payload.evidence_gate_result)
-            ctx.evidence_gate_result = payload.evidence_gate_result;
-        if (payload.unsupported_claims)
-            ctx.unsupported_claims = payload.unsupported_claims;
-        if (payload.conflict_resolutions)
-            ctx.conflict_resolutions = payload.conflict_resolutions;
-        await this.save(ctx);
-        return ctx;
-    }
-    // ── 能力 6: 返工历史追踪 ──
-    /**
-     * 记录返工事件（能力 6）: 追踪从哪个阶段回退到哪个阶段及原因。
-     * 超过 MAX_REWORK 阈值时自动设置阶段指令为「停止升级」。
-     * @param taskId - 任务 ID
-     * @param fromPhase - 源阶段
-     * @param toPhase - 目标阶段
-     * @param reason - 返工原因
-     * @returns 更新后的任务上下文，任务不存在时返回 null
-     */
-    async recordRework(taskId, fromPhase, toPhase, reason) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        if (!ctx.rework_history)
-            ctx.rework_history = [];
-        // 返工阈值检查
-        const reworkCount = ctx.rework_history.length;
-        if (reworkCount >= MAX_REWORK) {
-            ctx.phase_directive = "停止升级";
-            await this.save(ctx);
-            return ctx;
-        }
-        ctx.rework_history.push({
-            from_phase: fromPhase,
-            to_phase: toPhase,
-            reason,
-            timestamp: new Date().toISOString(),
-        });
-        await this.save(ctx);
-        return ctx;
-    }
-    // ── 终态清理 ──
-    /**
-     * 清除当前任务指针（仅当指向指定任务时）。
-     * 损坏的指针文件也会被清除。
-     */
-    async clearCurrentPointerIfMatches(taskId) {
-        try {
-            const data = await fs.readFile(this.pointerPath, "utf-8");
-            const { task_id } = JSON.parse(data);
-            if (task_id === taskId) {
-                await fs.unlink(this.pointerPath).catch(() => { });
-            }
-        }
-        catch (e) {
-            // 文件不存在或解析失败 → 删除损坏的指针
-            debug("任务上下文", "清除当前任务指针失败(预期行为: 指针文件不存在或解析错误) —", e);
-            await fs.unlink(this.pointerPath).catch(() => { });
-        }
-    }
-    // ── 内部方法 ──
-    /** 生成任务状态文件的完整路径 */
-    taskFilePath(taskId) {
-        return path.join(this.stateDir, `${taskId}.json`);
-    }
-    /** 当前任务指针文件路径 */
-    get pointerPath() {
-        return path.join(this.stateDir, "current-task.json");
-    }
-    /**
-     * 写入当前任务指针文件。
-     * @param taskId - 任务 ID
-     */
-    async writeCurrentPointer(taskId) {
-        // 确保 stateDir 存在
-        await fs.mkdir(this.stateDir, { recursive: true });
-        // 原子写入：使用任务级唯一 tmp 文件名，避免并发写同一个 .tmp
-        const tmpPath = `${this.pointerPath}.${taskId}.tmp`;
-        try {
-            await fs.writeFile(tmpPath, JSON.stringify({ task_id: taskId }));
-            await fs.rename(tmpPath, this.pointerPath);
-        }
-        catch (e) {
-            // 清理残留 tmp 文件，避免 ENOTEMPTY
-            await fs.unlink(tmpPath).catch(() => { });
-            throw e;
-        }
-    }
-}
-// ── 能力 6: 阶段指令计算 ──
-/**
- * 基于代码审查结果和修复循环状态计算阶段指令（能力 6）。
- * 决策优先级: 审查通过 →「完成」> critical 发现需返工 > 返工超限 →「停止升级」> 不可自动修复 →「回退并标注」> 其他 →「推进下一阶段」。
- * @param ctx - 任务上下文
- * @returns 阶段指令
- */
-export function computePhaseDirective(ctx) {
-    debug("task_context", "computePhaseDirective() 开始执行");
-    // 审查通过 → 完成
-    if (ctx.code_review && ctx.code_review.findings.length === 0) {
-        return "完成";
-    }
-    // 有 critical 发现 → 需要修复后重验证
-    if (ctx.code_review) {
-        const criticalCount = ctx.code_review.findings.filter((f) => f.severity === "critical").length;
-        if (criticalCount > 0) {
-            // 检查返工历史
-            const reworkCount = ctx.rework_history?.length ?? 0;
-            if (reworkCount >= MAX_REWORK) {
-                return "停止升级";
-            }
-            // CEP: 回退 决策点
-            const cepRepairResult = evaluateNoFalseCompletion({
-                verification_passed: false, build_passed: false,
-                browser_acceptance_passed: false, guard_passed: true,
-                evidence_sufficient: false, current_status: ctx.status,
-            });
-            recordCepIntegration("回退", {
-                passed: cepRepairResult.decision === "回退",
-                violations: cepRepairResult.decision === "blocked" ? [{
-                        principle: "auto_repair_no_fake_completion", severity: "blocking",
-                        reason_zh: cepRepairResult.reason_zh, evidence_refs: [], required_action: "回退",
-                    }] : [],
-            });
-            return "回退";
-        }
-    }
-    //： 主链路集成检查失败 → 需要修复后重验证
-    if (ctx.verification?.main_path_integration && !ctx.verification.main_path_integration.passed) {
-        const reworkCount = ctx.rework_history?.length ?? 0;
-        if (reworkCount >= MAX_REWORK) {
-            return "停止升级";
-        }
-        // CEP: 回退 决策点（主链路集成失败）
-        const cepRepairResult2 = evaluateNoFalseCompletion({
-            verification_passed: false, build_passed: true,
-            browser_acceptance_passed: true, guard_passed: true,
-            evidence_sufficient: false, current_status: ctx.status,
-        });
-        recordCepIntegration("回退", {
-            passed: cepRepairResult2.decision === "回退",
-            violations: cepRepairResult2.decision === "blocked" ? [{
-                    principle: "auto_repair_no_fake_completion", severity: "blocking",
-                    reason_zh: cepRepairResult2.reason_zh, evidence_refs: [], required_action: "回退",
-                }] : [],
-        });
-        return "回退";
-    }
-    // 验证失败 → 根据修复循环状态决定
-    if (ctx.execution?.repair_loop) {
-        const loop = ctx.execution.repair_loop;
-        if (!loop.auto_repairable) {
-            return "回退并标注";
-        }
-        if (loop.attempt >= loop.max_attempts) {
-            return "回退并标注";
-        }
-    }
-    return "推进下一阶段";
-}
-//# sourceMappingURL=task_context.js.map