soloforge 1.1.36 → 1.1.38

package/dist/engine/pipeline/task_context/manager.js

@@ -23,11 +23,57 @@ import { DiffOwnershipStore } from "../diff_ownership_store.js";
 import { ScopeLeaseStore } from "../scope_lease.js";
 import { ConflictGate } from "../conflict_gate.js";
 import { debug } from "../../core/logger.js";
-import { migrateTaskContext } from "../../workflow/legacy_type_migration.js";
-import { VALID_TRANSITIONS } from "./constants.js";
+import { VALID_TRANSITIONS, MAX_TASKS } from "./constants.js";
 import { validateAndUpdateStatus } from "./status_transitions.js";
-import { createSetterMethods } from "./manager_setters.js";
+import { createSetterMethods, maybeApplyRollbackDirective } from "./manager_setters.js";
+import { computePhaseDirective } from "./phase_directive.js";
 import { errorMessage, safeJsonParse } from "../../core/helpers.js";
+/**
+ * 迁移旧版 TaskContext 格式。
+ * 原地修改并返回，不创建新对象。
+ */
+function migrateTaskContext(ctx) {
+    // schema_version 缺失视为 1（旧任务文件）
+    const currentVersion = ctx.schema_version ?? 1;
+    if (!ctx.schema_version) {
+        ctx.schema_version = currentVersion;
+    }
+    // 迁移阶段指令
+    if (ctx.phase_directive) {
+        const PHASE_DIRECTIVE_MIGRATION = {
+            continue_current: "门禁阻断",
+            advance_next: "推进下一阶段",
+            repair_reverify: "回退",
+            rework_upstream: "回退并标注",
+            stop_escalate: "停止升级",
+            completed: "完成",
+        };
+        const migrated = PHASE_DIRECTIVE_MIGRATION[ctx.phase_directive] ?? ctx.phase_directive;
+        if (migrated !== ctx.phase_directive) {
+            ctx.phase_directive = migrated;
+        }
+    }
+    // 迁移修复重验指令中的 contract_id 如果包含旧机制ID
+    if (ctx.repair_reverify_directive) {
+        const MECHANISM_ID_MIGRATION = {
+            "mc-knowledge-injection-boundary": "模板引擎",
+            "mc-intent-router": "命令路由",
+            "mc-intent-expander": "意图扩展器",
+            "mc-verifier": "验证器",
+            "mc-task-context-lifecycle": "任务上下文生命周期",
+            "mc-core-engineering-principles": "核心工程原则",
+            "mc-classifier": "意图路由器",
+            "mc-knowledge-matching": "模板引擎",
+            "mc-workspace-resumer": "任务上下文生命周期",
+        };
+        const dir = ctx.repair_reverify_directive;
+        const migratedContractId = MECHANISM_ID_MIGRATION[dir.contract_id] ?? dir.contract_id;
+        if (migratedContractId !== dir.contract_id) {
+            dir.contract_id = migratedContractId;
+        }
+    }
+    return ctx;
+}
 export class TaskContextManager {
     stateDir;
     auditPool;
@@ -37,6 +83,34 @@ export class TaskContextManager {
     templatesDir;
     systemType;
     _setters;
+    /**
+     * P0-B1: Per-task mutex — 防止并发 load-modify-save 静默丢失数据。
+     * 每个 task-id 对应一个 promise chain，串行化该任务的所有写入操作。
+     */
+    _taskLocks = new Map();
+    /** P0-B1: 在 per-task 锁内执行 fn，保证 load-modify-save 原子性 */
+    async withTaskLock(taskId, fn) {
+        const prev = this._taskLocks.get(taskId) ?? Promise.resolve();
+        let release;
+        const next = new Promise((r) => { release = r; });
+        this._taskLocks.set(taskId, prev.then(() => next, () => next));
+        try {
+            await prev;
+        }
+        catch {
+            // 前一个锁出错不应阻塞当前操作
+        }
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+            // 清理：如果 next 已 settled 且没有后续等待者，删除 map 项
+            if (this._taskLocks.get(taskId) === prev.then(() => next, () => next)) {
+                this._taskLocks.delete(taskId);
+            }
+        }
+    }
     constructor(stateDir, options) {
         this.stateDir = stateDir;
         fss.mkdirSync(stateDir, { recursive: true });
@@ -46,7 +120,8 @@ export class TaskContextManager {
         this.conflictGate = new ConflictGate(this.diffOwnership, this.scopeLease);
         this.templatesDir = options?.templatesDir;
         this.systemType = options?.systemType;
-        this._setters = createSetterMethods(this.load.bind(this), this.save.bind(this));
+        // P0-B1: setters 通过 withTaskLock 串行化 load-modify-save
+        this._setters = createSetterMethods(this.load.bind(this), this.save.bind(this), this.withTaskLock.bind(this));
     }
     /** 获取状态存储目录路径 */
     getStateDir() {
@@ -72,6 +147,18 @@ export class TaskContextManager {
      * 创建新任务上下文，生成唯一 ID 并持久化到磁盘。
      */
     async create(intent, productProfile) {
+        // P3-C: 创建前强制 MAX_TASKS 上限 — 旧任务超额时先清理最旧的非终态任务，避免磁盘膨胀
+        try {
+            const files = await fs.readdir(this.stateDir);
+            const taskFiles = files.filter((f) => f.startsWith("task-") && f.endsWith(".json"));
+            if (taskFiles.length >= MAX_TASKS) {
+                debug("任务上下文", `任务数 ${taskFiles.length} 已达 MAX_TASKS=${MAX_TASKS}，触发自动清理`);
+                await this.cleanup(false);
+            }
+        }
+        catch {
+            // 读取目录失败不阻断创建
+        }
         const taskId = `task-${crypto.randomUUID().slice(0, 8)}`;
         const ctx = {
             task_id: taskId,
@@ -146,124 +233,142 @@ export class TaskContextManager {
      * 更新任务状态，严格校验状态转换合法性。
      */
     async updateStatus(taskId, status, existingCtx) {
-        const ctx = existingCtx ?? await this.load(taskId);
-        if (!ctx)
-            return null;
-        // 委托给提取的验证和转换函数
-        validateAndUpdateStatus(ctx, status, this.templatesDir, this.systemType);
-        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);
+        return this.withTaskLock(taskId, async () => {
+            const ctx = existingCtx ?? await this.load(taskId);
+            if (!ctx)
+                return null;
+            // 委托给提取的验证和转换函数
+            validateAndUpdateStatus(ctx, status, this.templatesDir, this.systemType);
+            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(),
-                });
+            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);
             }
-            // CAP-011: 终态时清理 Diff 归属和 Scope Lease
-            this.diffOwnership.clearTask(taskId);
-            this.scopeLease.release(taskId);
-            await this.clearCurrentPointerIfMatches(taskId);
-        }
-        return ctx;
+            return ctx;
+        });
     }
     /**
      * 设置任务的分类结果。
      */
     async setClassification(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.classification = result;
-        if (result.route_decision) {
-            ctx.route_decision = result.route_decision;
-        }
-        await this.save(ctx);
-        return ctx;
+        return this.withTaskLock(taskId, async () => {
+            const ctx = await this.load(taskId);
+            if (!ctx)
+                return null;
+            ctx.classification = result;
+            // 并行写入 pipeline_state（管线状态机优先数据源）
+            if (result.pipeline_state) {
+                ctx.pipeline_state = result.pipeline_state;
+            }
+            // 并行写入 task_stage（管线状态机优先数据源，stage-native 路径）
+            if (result.task_stage) {
+                ctx.task_stage = result.task_stage;
+            }
+            await this.save(ctx);
+            return ctx;
+        });
     }
     /**
      * 设置任务的意图膨胀结果。
      */
     async setExpansion(taskId, result, existingCtx) {
-        const ctx = existingCtx ?? await this.load(taskId);
-        if (!ctx)
-            return null;
-        // 使用提取的隐私扫描函数处理膨胀结果
-        const { result: scannedResult, allLabels, promptRedactionRecords } = scanExpansionForPrivacy(result);
-        result = scannedResult;
-        ctx.expansion = result;
-        if (result.workflow_trace) {
-            ctx.workflow_trace = result.workflow_trace;
-        }
-        ctx.ingestion_evidences = result.ingestion_evidences?.length ? result.ingestion_evidences : undefined;
-        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];
-        }
-        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;
+        return this.withTaskLock(taskId, async () => {
+            const ctx = existingCtx ?? await this.load(taskId);
+            if (!ctx)
+                return null;
+            // 使用提取的隐私扫描函数处理膨胀结果
+            const { result: scannedResult, allLabels, promptRedactionRecords } = scanExpansionForPrivacy(result);
+            result = scannedResult;
+            ctx.expansion = result;
+            if (result.workflow_trace) {
+                ctx.workflow_trace = result.workflow_trace;
+            }
+            ctx.ingestion_evidences = result.ingestion_evidences?.length ? result.ingestion_evidences : undefined;
+            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];
+            }
+            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;
+        });
     }
     /**
      * 记录执行结果: 变更文件列表和可选的失败记录。
      */
     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);
-        }
-        for (const f of changedFiles) {
-            this.diffOwnership.recordWrite(taskId, f);
-        }
-        await this.save(ctx);
-        return ctx;
+        return this.withTaskLock(taskId, async () => {
+            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);
+            }
+            for (const f of changedFiles) {
+                this.diffOwnership.recordWrite(taskId, f);
+            }
+            await this.save(ctx);
+            return ctx;
+        });
     }
     /**
      * 设置任务的验证结果。
      */
     async setVerification(taskId, result) {
-        const ctx = await this.load(taskId);
-        if (!ctx)
-            return null;
-        ctx.verification = result;
-        await this.save(ctx);
-        return ctx;
+        return this.withTaskLock(taskId, async () => {
+            const ctx = await this.load(taskId);
+            if (!ctx)
+                return null;
+            ctx.verification = result;
+            // P2-B1: 主链路集成失败可能触发回退 — 同步计算 phase_directive 并填充 rollback_directive
+            ctx.phase_directive = computePhaseDirective(ctx);
+            await maybeApplyRollbackDirective(ctx);
+            await this.save(ctx);
+            return ctx;
+        });
     }
     /**
      * 获取当前活跃任务。
@@ -309,6 +414,17 @@ export class TaskContextManager {
             debug("任务上下文", `无法从 ${ctx.status} 取消到 failed`);
             return false;
         }
+        // P1-B4: 记录已写入的产物文件清单到 ctx，便于后续选择性清理
+        const artifactPaths = [];
+        if (ctx.artifact_output?.path)
+            artifactPaths.push(ctx.artifact_output.path);
+        if (ctx.execution?.changed_files && ctx.execution.changed_files.length > 0) {
+            artifactPaths.push(...ctx.execution.changed_files);
+        }
+        if (artifactPaths.length > 0) {
+            ctx.cancelled_artifact_files = artifactPaths;
+            debug("任务上下文", `任务 ${taskId} 取消时记录 ${artifactPaths.length} 个产物文件待清理`);
+        }
         ctx.status = "failed";
         await this.save(ctx);
         this.diffOwnership.clearTask(taskId);
@@ -318,7 +434,98 @@ export class TaskContextManager {
         return true;
     }
     /**
-     * 将失败任务恢复到 expanding 状态以重试 sf_expand。
+     * P1-B4: 清理已取消任务的产物文件。
+     * 用户通过 sf_pipeline_status action=cleanup_cancelled_artifacts 触发，避免误删。
+     */
+    async cleanupCancelledArtifacts(taskId) {
+        const ctx = await this.load(taskId);
+        if (!ctx || ctx.status !== "failed") {
+            return { cleaned: [], missing: [] };
+        }
+        const files = ctx.cancelled_artifact_files ?? [];
+        const cleaned = [];
+        const missing = [];
+        for (const f of files) {
+            try {
+                await fs.unlink(f);
+                cleaned.push(f);
+            }
+            catch {
+                missing.push(f);
+            }
+        }
+        // 清理完毕后清除记录
+        ctx.cancelled_artifact_files = undefined;
+        await this.save(ctx);
+        debug("任务上下文", `清理任务 ${taskId} 产物文件 — 清理 ${cleaned.length}，缺失 ${missing.length}`);
+        return { cleaned, missing };
+    }
+    /**
+     * P2-B2: 在变更前记录业务源码 baseline（文件 sha256）。
+     * sf_gate_check 验证失败时，可通过 rollbackFilesFromBaseline 恢复到本快照。
+     */
+    async recordFileBaseline(taskId, files) {
+        const crypto = await import("node:crypto");
+        const snapshots = [];
+        for (const f of files) {
+            try {
+                const content = await fs.readFile(f);
+                const hash = crypto.createHash("sha256").update(content).digest("hex");
+                snapshots.push({ path: f, sha256: hash });
+            }
+            catch {
+                // 文件不存在则跳过 — baseline 只记录可读取的文件
+            }
+        }
+        return this.withTaskLock(taskId, async () => {
+            const ctx = await this.load(taskId);
+            if (!ctx)
+                return false;
+            ctx.file_baseline = {
+                recorded_at: new Date().toISOString(),
+                files: snapshots,
+            };
+            await this.save(ctx);
+            debug("任务上下文", `记录文件 baseline — 任务 ${taskId} 文件数 ${snapshots.length}`);
+            return true;
+        });
+    }
+    /**
+     * P2-B2: 从 baseline 恢复文件内容。
+     * 失败时返回 missing 列表，已成功恢复的文件不回滚。
+     */
+    async rollbackFilesFromBaseline(taskId) {
+        const ctx = await this.load(taskId);
+        if (!ctx?.file_baseline || ctx.file_baseline.files.length === 0) {
+            return { restored: [], missing: [], no_baseline: true };
+        }
+        // 注意: baseline 只存了 sha256，未存内容 — 此处只能"标记为待恢复"并给出提示。
+        // 完整恢复需要外部 git checkpoint 或 file backup 配合（P2-B3）。
+        // 当前实现: 检测哪些文件相对 baseline 发生了变化，输出指导信息。
+        const crypto = await import("node:crypto");
+        const restored = [];
+        const missing = [];
+        for (const snap of ctx.file_baseline.files) {
+            try {
+                const content = await fs.readFile(snap.path);
+                const currentHash = crypto.createHash("sha256").update(content).digest("hex");
+                if (currentHash !== snap.sha256) {
+                    // 文件已变更 — 提示用户手动 git checkout <path> 恢复
+                    missing.push(`${snap.path} (baseline=${snap.sha256.slice(0, 8)}.., current=${currentHash.slice(0, 8)}..)`);
+                }
+                else {
+                    restored.push(snap.path);
+                }
+            }
+            catch {
+                missing.push(`${snap.path} (文件已删除)`);
+            }
+        }
+        debug("任务上下文", `baseline 回滚检查 — 任务 ${taskId} 未变更 ${restored.length}，需恢复 ${missing.length}`);
+        return { restored, missing, no_baseline: false };
+    }
+    /**
+     * 将失败任务恢复到 expanding 状态以重试 sf_stage_execute。
      */
     async retryExpand(taskId) {
         const ctx = await this.load(taskId);
@@ -356,11 +563,11 @@ export class TaskContextManager {
      */
     getResumeHint(ctx) {
         const hints = {
-            expanding: "意图膨胀未完成，需重新执行 sf_expand",
+            expanding: "阶段执行未完成，需重新执行 sf_stage_execute",
             executing: "代码执行中断，需重新执行代码修改",
-            verifying: "验证未完成，需调用 sf_verify",
+            verifying: "验证未完成，需调用 sf_gate_check",
             retrying: "重试中断，需继续修复",
-            learning: "自进化未完成，需调用 sf_learn",
+            learning: "阶段推进未完成，需调用 sf_stage_advance",
             reworking: "返工中，需回溯到上游阶段重新执行",
         };
         return hints[ctx.status] || "未知状态";
@@ -369,19 +576,39 @@ export class TaskContextManager {
      * 列出最近的任务。
      */
     async listRecent(limit = 10) {
+        // P2-E: 性能优化 — 用 mtime 排序，仅读取 limit 数量的文件，避免全扫 O(n) 文件 IO
         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 = safeJsonParse(data);
-            if (!ctx)
+        // 按 mtime 降序排列（最新在前）
+        const filesWithMtime = await Promise.all(taskFiles.map(async (f) => {
+            const filePath = path.join(this.stateDir, f);
+            try {
+                const stat = await fs.stat(filePath);
+                return { file: filePath, mtime: stat.mtimeMs };
+            }
+            catch {
+                return { file: filePath, mtime: 0 };
+            }
+        }));
+        filesWithMtime.sort((a, b) => b.mtime - a.mtime);
+        // 仅读取前 limit*2 个文件（多读一些容错，过滤解析失败后仍能返回 limit 个）
+        const candidates = filesWithMtime.slice(0, Math.max(limit * 2, limit + 5));
+        const tasks = await Promise.all(candidates.map(async (entry) => {
+            try {
+                const data = await fs.readFile(entry.file, "utf-8");
+                const ctx = safeJsonParse(data);
+                if (!ctx)
+                    return null;
+                return {
+                    task_id: ctx.task_id,
+                    intent: ctx.intent,
+                    status: ctx.status,
+                    created_at: ctx.created_at,
+                };
+            }
+            catch {
                 return null;
-            return {
-                task_id: ctx.task_id,
-                intent: ctx.intent,
-                status: ctx.status,
-                created_at: ctx.created_at,
-            };
+            }
         }));
         return tasks.filter((t) => t !== null)
             .sort((a, b) => b.created_at.localeCompare(a.created_at))
@@ -467,6 +694,13 @@ export class TaskContextManager {
     async setArtifact(taskId, artifact, existingCtx) {
         return this._setters.setArtifact(taskId, artifact, existingCtx);
     }
+    /**
+     * P1-B3: 扩展阶段事务化持久化。
+     * 单次锁内合并 expansion/artifact/status/plan_proposal_gate 四项变更，失败时回滚到事务前快照。
+     */
+    async applyExpansionTransaction(taskId, ops) {
+        return this._setters.applyExpansionTransaction(taskId, ops);
+    }
     /** 更新产物状态并追加 evidence_ref */
     async updateArtifactStatus(taskId, params) {
         return this._setters.updateArtifactStatus(taskId, params);