patchwarden 1.5.0 → 1.6.1

package/dist/test/unit/watcher-status.test.js

@@ -1,169 +0,0 @@
-import { describe, it, beforeEach, afterEach } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { tmpdir } from "node:os";
-import { readWatcherStatus, getWatcherHeartbeatPath } from "../../watcherStatus.js";
-function makeConfig(workspaceRoot) {
-    return {
-        workspaceRoot,
-        plansDir: ".patchwarden/plans",
-        tasksDir: ".patchwarden/tasks",
-        assessmentsDir: ".patchwarden/assessments",
-        assessmentTtlSeconds: 3600,
-        agents: { codex: { command: "codex", args: ["exec", "{prompt}"] } },
-        allowedTestCommands: ["npm test"],
-        repoAllowedTestCommands: {},
-        maxReadFileBytes: 200_000,
-        defaultTaskTimeoutSeconds: 900,
-        maxTaskTimeoutSeconds: 3600,
-        watcherStaleSeconds: 30,
-        directSessionsDir: ".patchwarden/direct-sessions",
-        directSessionTtlSeconds: 3600,
-        directMaxPatchBytes: 200_000,
-        directMaxFileBytes: 500_000,
-    };
-}
-describe("readWatcherStatus — watcher stale fallback", () => {
-    let tempDir;
-    let config;
-    beforeEach(() => {
-        tempDir = mkdtempSync(join(tmpdir(), "pw-watcher-test-"));
-        config = makeConfig(tempDir);
-        mkdirSync(join(tempDir, ".patchwarden", "tasks"), { recursive: true });
-    });
-    afterEach(() => {
-        rmSync(tempDir, { recursive: true, force: true });
-    });
-    it("returns missing when no heartbeat and no running task", () => {
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "missing");
-        assert.equal(result.available, false);
-        assert.equal(result.activity, null);
-    });
-    it("returns healthy when watcher heartbeat is fresh", () => {
-        const heartbeatPath = getWatcherHeartbeatPath(config);
-        mkdirSync(dirname(heartbeatPath), { recursive: true });
-        writeFileSync(heartbeatPath, JSON.stringify({
-            status: "running",
-            pid: process.pid,
-            last_heartbeat_at: new Date().toISOString(),
-        }), "utf-8");
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "healthy");
-        assert.equal(result.available, true);
-        assert.equal(result.activity, null);
-    });
-    it("returns stale when watcher heartbeat is old and no running task", () => {
-        const heartbeatPath = getWatcherHeartbeatPath(config);
-        mkdirSync(dirname(heartbeatPath), { recursive: true });
-        const oldTime = new Date(Date.now() - 120_000).toISOString();
-        writeFileSync(heartbeatPath, JSON.stringify({
-            status: "running",
-            pid: process.pid,
-            last_heartbeat_at: oldTime,
-        }), "utf-8");
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "stale");
-        assert.equal(result.available, false);
-        assert.equal(result.activity, null);
-    });
-    it("returns healthy when watcher heartbeat is stale but a running task has fresh heartbeat", () => {
-        // Write stale watcher heartbeat
-        const heartbeatPath = getWatcherHeartbeatPath(config);
-        mkdirSync(dirname(heartbeatPath), { recursive: true });
-        const oldTime = new Date(Date.now() - 120_000).toISOString();
-        writeFileSync(heartbeatPath, JSON.stringify({
-            status: "running",
-            pid: process.pid,
-            last_heartbeat_at: oldTime,
-        }), "utf-8");
-        // Create a running task with fresh heartbeat
-        const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-001");
-        mkdirSync(taskDir, { recursive: true });
-        writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-            status: "running",
-            task_id: "test-task-001",
-        }), "utf-8");
-        writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-            phase: "executing_agent",
-            last_heartbeat_at: new Date().toISOString(),
-            current_command: "codex exec",
-        }), "utf-8");
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "healthy");
-        assert.equal(result.available, true);
-        assert.ok(result.activity);
-        assert.match(result.activity, /test-task-001/);
-    });
-    it("returns healthy when watcher heartbeat is missing but a running task has fresh heartbeat", () => {
-        // No watcher heartbeat file at all
-        // Create a running task with fresh heartbeat
-        const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-002");
-        mkdirSync(taskDir, { recursive: true });
-        writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-            status: "running",
-            task_id: "test-task-002",
-        }), "utf-8");
-        writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-            phase: "running_tests",
-            last_heartbeat_at: new Date().toISOString(),
-            current_command: "npm test",
-        }), "utf-8");
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "healthy");
-        assert.equal(result.available, true);
-        assert.ok(result.activity);
-        assert.match(result.activity, /test-task-002/);
-    });
-    it("returns stale when both watcher heartbeat and task heartbeat are old", () => {
-        const heartbeatPath = getWatcherHeartbeatPath(config);
-        mkdirSync(dirname(heartbeatPath), { recursive: true });
-        const oldTime = new Date(Date.now() - 120_000).toISOString();
-        writeFileSync(heartbeatPath, JSON.stringify({
-            status: "running",
-            pid: process.pid,
-            last_heartbeat_at: oldTime,
-        }), "utf-8");
-        const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-003");
-        mkdirSync(taskDir, { recursive: true });
-        writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-            status: "running",
-            task_id: "test-task-003",
-        }), "utf-8");
-        writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-            phase: "executing_agent",
-            last_heartbeat_at: oldTime,
-            current_command: "codex exec",
-        }), "utf-8");
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "stale");
-        assert.equal(result.available, false);
-        assert.equal(result.activity, null);
-    });
-    it("does not fall back to non-running tasks", () => {
-        const heartbeatPath = getWatcherHeartbeatPath(config);
-        mkdirSync(dirname(heartbeatPath), { recursive: true });
-        const oldTime = new Date(Date.now() - 120_000).toISOString();
-        writeFileSync(heartbeatPath, JSON.stringify({
-            status: "running",
-            pid: process.pid,
-            last_heartbeat_at: oldTime,
-        }), "utf-8");
-        // Done task with fresh heartbeat should not trigger fallback
-        const taskDir = join(tempDir, ".patchwarden", "tasks", "test-task-004");
-        mkdirSync(taskDir, { recursive: true });
-        writeFileSync(join(taskDir, "status.json"), JSON.stringify({
-            status: "done",
-            task_id: "test-task-004",
-        }), "utf-8");
-        writeFileSync(join(taskDir, "runtime.json"), JSON.stringify({
-            phase: "completed",
-            last_heartbeat_at: new Date().toISOString(),
-            current_command: null,
-        }), "utf-8");
-        const result = readWatcherStatus(config, Date.now());
-        assert.equal(result.status, "stale");
-        assert.equal(result.available, false);
-    });
-});

package/dist/test/unit/worktree-manager.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/test/unit/worktree-manager.test.js

@@ -1,176 +0,0 @@
-import { describe, it, before, after } from "node:test";
-import { strict as assert } from "node:assert";
-import { mkdtempSync, rmSync, writeFileSync, readFileSync, existsSync, readdirSync, unlinkSync, } from "node:fs";
-import { join } from "node:path";
-import { tmpdir } from "node:os";
-import { execSync } from "node:child_process";
-import { createWorktree, mergeWorktree, discardWorktree, readWorktreeStatus, getWorktreesDir, } from "../../goal/worktreeManager.js";
-import { PatchWardenError } from "../../errors.js";
-// ── Test fixtures ─────────────────────────────────────────────────
-/**
- * 在 dir 创建一个真实的 git 仓库：git init + 配置 user + 初始 commit。
- * createWorktree 要求 workspaceRoot 是一个至少有一个 commit 的 git 仓库。
- */
-function initGitRepo(dir) {
-    execSync("git init", { cwd: dir, stdio: "ignore" });
-    execSync('git config user.email "test@patchwarden.local"', { cwd: dir, stdio: "ignore" });
-    execSync('git config user.name "PatchWarden Test"', { cwd: dir, stdio: "ignore" });
-    execSync('git config commit.gpgsign false', { cwd: dir, stdio: "ignore" });
-    writeFileSync(join(dir, "README.md"), "init\n", "utf-8");
-    execSync("git add README.md", { cwd: dir, stdio: "ignore" });
-    execSync("git commit -m init", { cwd: dir, stdio: "ignore" });
-}
-function gitBranchList(cwd) {
-    return execSync("git branch --list", { cwd, stdio: ["pipe", "pipe", "ignore"] }).toString("utf-8");
-}
-function assertPatchWardenError(fn, reason) {
-    try {
-        fn();
-        assert.fail(`expected PatchWardenError("${reason}") to be thrown`);
-    }
-    catch (err) {
-        assert.ok(err instanceof PatchWardenError, `expected PatchWardenError, got: ${err}`);
-        assert.equal(err.reason, reason);
-    }
-}
-// ── Tests ─────────────────────────────────────────────────────────
-describe("worktreeManager", () => {
-    let workspaceRoot;
-    before(() => {
-        workspaceRoot = mkdtempSync(join(tmpdir(), "pw-wt-"));
-        initGitRepo(workspaceRoot);
-    });
-    after(() => {
-        rmSync(workspaceRoot, { recursive: true, force: true });
-    });
-    // ── 1. createWorktree 成功 ──
-    it("createWorktree creates an active worktree with valid status.json", () => {
-        const result = createWorktree("goal_20260101_demo", "subgoal-001", workspaceRoot);
-        assert.ok(result.worktreeId.startsWith("wt_"), `worktreeId should start with "wt_", got: ${result.worktreeId}`);
-        assert.ok(result.branch.startsWith("pw-goal_20260101_demo-subgoal-001"), `branch should be pw-<goal>-<subgoal>, got: ${result.branch}`);
-        assert.ok(existsSync(result.worktreePath), "worktreePath should exist");
-        const statusFile = join(result.worktreePath, "worktree_status.json");
-        assert.ok(existsSync(statusFile), "worktree_status.json should exist");
-        // 原子写：不应残留 .tmp 文件
-        assert.ok(!existsSync(statusFile + ".tmp"), "status.json.tmp should not remain after atomic write");
-        // JSON 合法且字段正确
-        const status = JSON.parse(readFileSync(statusFile, "utf-8"));
-        assert.equal(status.worktree_id, result.worktreeId);
-        assert.equal(status.goal_id, "goal_20260101_demo");
-        assert.equal(status.subgoal_id, "subgoal-001");
-        assert.equal(status.status, "active");
-        assert.equal(status.branch, result.branch);
-        assert.equal(status.path, result.worktreePath);
-        assert.ok(typeof status.created_at === "string" && status.created_at.length > 0);
-        // worktree 内应检出主仓库的文件（README.md）
-        assert.ok(existsSync(join(result.worktreePath, "README.md")), "worktree should check out README.md");
-        // branch 应在 git 中存在
-        assert.ok(gitBranchList(workspaceRoot).includes(result.branch), "branch should exist in git");
-        // readWorktreeStatus 应返回一致的状态
-        const readBack = readWorktreeStatus(result.worktreeId, workspaceRoot);
-        assert.ok(readBack !== null);
-        assert.equal(readBack.status, "active");
-    });
-    // ── 2. createWorktree git 命令失败清理 ──
-    it("createWorktree cleans up and throws when git fails (non-git workspaceRoot)", () => {
-        const nonGitDir = mkdtempSync(join(tmpdir(), "pw-wt-nogit-"));
-        try {
-            // 非 git 目录 → git worktree add 失败
-            assertPatchWardenError(() => createWorktree("goal_x", "subgoal-001", nonGitDir), "worktree_create_failed");
-            // 不应残留任何 worktree 目录
-            const worktreesDir = getWorktreesDir(nonGitDir);
-            if (existsSync(worktreesDir)) {
-                // 若 _workspacetrees 被创建，应为空（无半成品 worktree）
-                const entries = readdirSync(worktreesDir);
-                assert.equal(entries.length, 0, "no leftover worktree directories should remain after failure");
-            }
-        }
-        finally {
-            rmSync(nonGitDir, { recursive: true, force: true });
-        }
-    });
-    // ── 3. mergeWorktree 成功 ──
-    it("mergeWorktree merges the branch back and marks status merged", () => {
-        const created = createWorktree("goal_merge", "subgoal-001", workspaceRoot);
-        // 在 worktree 中产生一个新 commit，使 merge 有实际内容
-        writeFileSync(join(created.worktreePath, "feature.txt"), "merged feature\n", "utf-8");
-        execSync("git add feature.txt", { cwd: created.worktreePath, stdio: "ignore" });
-        execSync("git commit -m feature", { cwd: created.worktreePath, stdio: "ignore" });
-        const result = mergeWorktree(created.worktreeId, workspaceRoot);
-        assert.equal(result.status, "merged");
-        // 主工作区应出现 feature.txt（fast-forward 合并）
-        assert.ok(existsSync(join(workspaceRoot, "feature.txt")), "feature.txt should appear in main workspace after merge");
-        // status 应更新为 merged，merged_at 非空
-        const status = readWorktreeStatus(created.worktreeId, workspaceRoot);
-        assert.ok(status !== null);
-        assert.equal(status.status, "merged");
-        assert.ok(typeof status.merged_at === "string" && status.merged_at.length > 0, "merged_at should be set");
-    });
-    // ── 4. discardWorktree 成功 ──
-    it("discardWorktree removes worktree, deletes branch, and archives status", () => {
-        const created = createWorktree("goal_discard", "subgoal-001", workspaceRoot);
-        const branch = created.branch;
-        const worktreePath = created.worktreePath;
-        const result = discardWorktree(created.worktreeId, workspaceRoot);
-        assert.equal(result.status, "discarded");
-        // worktree 目录应被移除
-        assert.ok(!existsSync(worktreePath), "worktree directory should be removed after discard");
-        // 临时 branch 应被删除
-        assert.ok(!gitBranchList(workspaceRoot).includes(branch), "temporary branch should be deleted after discard");
-        // 归档文件应存在且 status="discarded"
-        const archiveFile = join(workspaceRoot, ".patchwarden", "worktree-archive", `${created.worktreeId}.json`);
-        assert.ok(existsSync(archiveFile), "archived status file should exist");
-        const archived = JSON.parse(readFileSync(archiveFile, "utf-8"));
-        assert.equal(archived.status, "discarded");
-        assert.ok(typeof archived.discarded_at === "string" && archived.discarded_at.length > 0, "discarded_at should be set");
-        assert.equal(archived.worktree_id, created.worktreeId);
-    });
-    // ── 5. 路径逃逸拦截 ──
-    it("blocks path escape via worktreeId containing ..", () => {
-        // worktreeId 在 read/merge/discard 中由调用方提供，构造逃逸路径
-        assertPatchWardenError(() => readWorktreeStatus("../../../outside", workspaceRoot), "workspace_path_escape");
-        assertPatchWardenError(() => mergeWorktree("../../../outside", workspaceRoot), "workspace_path_escape");
-        assertPatchWardenError(() => discardWorktree("../../../outside", workspaceRoot), "workspace_path_escape");
-    });
-    // ── 6. 敏感路径拦截 ──
-    it("blocks sensitive worktreeId via guardSensitivePath", () => {
-        // "credentials" 命中 sensitiveGuard 的敏感模式
-        assertPatchWardenError(() => readWorktreeStatus("credentials", workspaceRoot), "sensitive_path_blocked");
-        assertPatchWardenError(() => mergeWorktree("credentials", workspaceRoot), "sensitive_path_blocked");
-        assertPatchWardenError(() => discardWorktree("credentials", workspaceRoot), "sensitive_path_blocked");
-    });
-    // ── 7. readWorktreeStatus 返回 null 当 status 不存在 ──
-    it("readWorktreeStatus returns null when status file does not exist", () => {
-        // 创建一个 worktree 目录但不含 status 文件
-        const created = createWorktree("goal_missing", "subgoal-001", workspaceRoot);
-        // 手动删除 status 文件模拟缺失
-        unlinkSync(join(created.worktreePath, "worktree_status.json"));
-        assert.equal(readWorktreeStatus(created.worktreeId, workspaceRoot), null);
-        // 清理：删除该 worktree（避免污染后续测试）
-        try {
-            execSync(`git worktree remove --force "${created.worktreePath}"`, { cwd: workspaceRoot, stdio: "ignore" });
-        }
-        catch { /* ignore */ }
-        try {
-            execSync(`git branch -D ${created.branch}`, { cwd: workspaceRoot, stdio: "ignore" });
-        }
-        catch { /* ignore */ }
-    });
-    // ── 8. 非法状态转换：merge/discard 已 merged 的 worktree 抛错 ──
-    it("rejects merge/discard on non-active worktree", () => {
-        // 复用 #3 已 merged 的 worktree（goal_merge/subgoal-001）
-        // 先找到它的 worktreeId：扫描 _workspacetrees 目录
-        const worktreesDir = getWorktreesDir(workspaceRoot);
-        let mergedId = null;
-        for (const entry of readdirSync(worktreesDir)) {
-            const s = readWorktreeStatus(entry, workspaceRoot);
-            if (s && s.status === "merged" && s.goal_id === "goal_merge") {
-                mergedId = entry;
-                break;
-            }
-        }
-        assert.ok(mergedId !== null, "should find the merged worktree from the merge test");
-        assertPatchWardenError(() => mergeWorktree(mergedId, workspaceRoot), "invalid_worktree_state");
-        assertPatchWardenError(() => discardWorktree(mergedId, workspaceRoot), "invalid_worktree_state");
-    });
-});

package/dist/tools/applyPatch.js

@@ -1,41 +0,0 @@
-import { getConfig } from "../config.js";
-import { readDirectSession, appendDirectSessionOperation, } from "../direct/directSessionStore.js";
-import { guardDirectSessionActive, guardDirectWritePath, guardDirectPatchSize, } from "../direct/directGuards.js";
-import { applyPatchOperations, validateExpectedSha256, computeFileSha256, } from "../direct/directPatch.js";
-export function applyPatch(input) {
-    const config = getConfig();
-    // 1. Read session and guard active (not expired, not finalized)
-    const session = readDirectSession(input.session_id);
-    guardDirectSessionActive(session);
-    // 2. Guard write path (inside repo, not sensitive, not binary,
-    //    not node_modules/release/dist)
-    const resolvedPath = guardDirectWritePath(input.path, session.resolved_repo_path, config.workspaceRoot);
-    // 3. Calculate patch size and guard against directMaxPatchBytes
-    const patchBytes = JSON.stringify(input.operations).length;
-    guardDirectPatchSize(patchBytes);
-    // 4. Validate expected_sha256 matches current file hash
-    const beforeSha256 = validateExpectedSha256(resolvedPath, input.expected_sha256);
-    // 5. Apply patch operations
-    const patchResult = applyPatchOperations(resolvedPath, input.operations);
-    // Re-read the file from disk to compute the authoritative after_sha256
-    const afterSha256 = computeFileSha256(resolvedPath);
-    // 6. Append operation record to session
-    appendDirectSessionOperation(input.session_id, {
-        index: session.operations.length,
-        timestamp: new Date().toISOString(),
-        path: input.path,
-        before_sha256: beforeSha256,
-        after_sha256: afterSha256,
-        operations_applied: patchResult.operations_applied,
-        bytes_changed: patchResult.bytes_changed,
-    });
-    // 7. Return result
-    return {
-        path: input.path,
-        before_sha256: beforeSha256,
-        after_sha256: afterSha256,
-        operations_applied: patchResult.operations_applied,
-        bytes_changed: patchResult.bytes_changed,
-        next_action: "Call run_verification to test the changes, or apply_patch for more edits.",
-    };
-}

package/dist/tools/cancelTask.d.ts

@@ -1,30 +0,0 @@
-export declare function cancelTask(taskId: string): {
-    task_id: string;
-    previous_status: string;
-    new_status: string;
-    message: string;
-    cancel_requested?: undefined;
-    force_kill_requested?: undefined;
-} | {
-    task_id: string;
-    previous_status: string;
-    new_status: string;
-    cancel_requested: boolean;
-    force_kill_requested: boolean;
-    message: string;
-};
-export declare function requestTaskTermination(taskId: string, force: boolean): {
-    task_id: string;
-    previous_status: string;
-    new_status: string;
-    message: string;
-    cancel_requested?: undefined;
-    force_kill_requested?: undefined;
-} | {
-    task_id: string;
-    previous_status: string;
-    new_status: string;
-    cancel_requested: boolean;
-    force_kill_requested: boolean;
-    message: string;
-};

package/dist/tools/cancelTask.js

@@ -1,64 +0,0 @@
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { join } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { writeTaskProgress } from "../taskProgress.js";
-export function cancelTask(taskId) {
-    return requestTaskTermination(taskId, false);
-}
-export function requestTaskTermination(taskId, force) {
-    const config = getConfig();
-    const taskDir = join(getTasksDir(config), taskId);
-    const statusFile = join(taskDir, "status.json");
-    guardReadPath(statusFile, config.workspaceRoot, config.tasksDir);
-    if (!existsSync(statusFile))
-        throw new Error(`Task not found: "${taskId}"`);
-    const data = JSON.parse(readFileSync(statusFile, "utf-8"));
-    const currentStatus = data.status;
-    if (["done", "done_by_agent", "failed", "failed_verification", "failed_scope_violation", "failed_policy_violation", "canceled"].includes(currentStatus)) {
-        return {
-            task_id: taskId,
-            previous_status: currentStatus,
-            new_status: currentStatus,
-            message: `Task is already ${currentStatus}. No action taken.`,
-        };
-    }
-    const now = new Date().toISOString();
-    if (currentStatus === "pending") {
-        data.status = "canceled";
-        data.phase = "canceled";
-        data.canceled_at = now;
-        data.cancel_reason = force ? "Killed before execution by user request." : "Canceled by user request.";
-        data.updated_at = now;
-        writeFileSync(statusFile, JSON.stringify(data, null, 2), "utf-8");
-        writeTaskProgress(taskDir, "canceled", { note: data.cancel_reason, heartbeatAt: now });
-        return {
-            task_id: taskId,
-            previous_status: "pending",
-            new_status: "canceled",
-            message: "Pending task canceled. It will not be executed by watcher.",
-        };
-    }
-    data.cancel_requested = true;
-    data.cancel_requested_at = now;
-    data.force_kill_requested = force;
-    if (force)
-        data.kill_requested_at = now;
-    data.phase = force ? "terminating" : "canceling";
-    data.updated_at = now;
-    writeFileSync(statusFile, JSON.stringify(data, null, 2), "utf-8");
-    writeTaskProgress(taskDir, data.phase, {
-        note: force ? "Immediate termination requested." : "Graceful cancellation requested.",
-        heartbeatAt: now,
-    });
-    return {
-        task_id: taskId,
-        previous_status: "running",
-        new_status: "running",
-        cancel_requested: true,
-        force_kill_requested: force,
-        message: force
-            ? "Kill requested. The runner that owns the child process will terminate it."
-            : "Cancel requested. The runner will stop the child process safely.",
-    };
-}

package/dist/tools/evidencePack.js

@@ -1,168 +0,0 @@
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { getConfig } from "../config.js";
-import { guardReadPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { redactSensitiveValue } from "../security/contentRedaction.js";
-import { getProjectPolicySummary } from "../policy/projectPolicy.js";
-import { getTaskLineage } from "./taskLineage.js";
-import { getLastToolCatalogSnapshot } from "./toolCatalog.js";
-import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
-import { PatchWardenError } from "../errors.js";
-export function exportTaskEvidencePack(input) {
-    const lineageId = normalizeLineageId(input.lineage_id);
-    const maxItems = normalizeMaxItems(input.max_items);
-    const config = getConfig();
-    const lineage = getTaskLineage(lineageId, { max_items: maxItems });
-    const packDir = resolve(config.workspaceRoot, ".patchwarden", "evidence-packs", lineageId);
-    guardWorkspacePath(packDir, config.workspaceRoot);
-    mkdirSync(packDir, { recursive: true });
-    const policySummary = readPolicySummary(lineage.repo_path);
-    const catalog = safeCatalog();
-    const generatedAt = new Date().toISOString();
-    const safePack = redactSensitiveValue({
-        evidence_pack_id: `evidence_${lineageId}`,
-        lineage_id: lineageId,
-        generated_at: generatedAt,
-        path: packDir,
-        files: {
-            json: join(packDir, "evidence.json"),
-            markdown: join(packDir, "EVIDENCE.md"),
-        },
-        lineage,
-        policy: {
-            valid: policySummary.valid,
-            issue_count: policySummary.issues.length,
-            release_readiness: policySummary.release_readiness,
-        },
-        catalog,
-        omitted: ["stdout", "stderr", "diff", "verification command logs", "full artifact markdown", "sensitive file contents"],
-        next_action: buildNextAction(lineage),
-        bounded: true,
-    }).value;
-    writeFileSync(safePack.files.json, JSON.stringify(safePack, null, 2) + "\n", "utf-8");
-    writeFileSync(safePack.files.markdown, buildEvidenceMarkdown(safePack), "utf-8");
-    return safePack;
-}
-export function listEvidencePacks(options = {}) {
-    const maxItems = normalizeMaxItems(options.max_items);
-    const config = getConfig();
-    const root = resolve(config.workspaceRoot, ".patchwarden", "evidence-packs");
-    guardWorkspacePath(root, config.workspaceRoot);
-    if (!existsSync(root))
-        return { evidence_packs: [], total: 0, truncated: false };
-    const packs = readdirSync(root, { withFileTypes: true })
-        .filter((entry) => entry.isDirectory())
-        .map((entry) => readEvidencePack(entry.name))
-        .filter((entry) => entry !== null)
-        .sort((a, b) => b.generated_at.localeCompare(a.generated_at));
-    return {
-        evidence_packs: packs.slice(0, maxItems),
-        total: packs.length,
-        truncated: packs.length > maxItems,
-    };
-}
-export function readEvidencePack(lineageId) {
-    const safeLineageId = normalizeLineageId(lineageId);
-    const config = getConfig();
-    const filePath = resolve(config.workspaceRoot, ".patchwarden", "evidence-packs", safeLineageId, "evidence.json");
-    guardReadPath(filePath, config.workspaceRoot, ".patchwarden/evidence-packs");
-    if (!existsSync(filePath))
-        return null;
-    const raw = readFileSync(filePath, "utf-8").replace(/^\uFEFF/, "");
-    return redactSensitiveValue(JSON.parse(raw)).value;
-}
-function normalizeLineageId(value) {
-    const lineageId = String(value || "").trim();
-    if (!/^[A-Za-z0-9_-]+$/.test(lineageId)) {
-        throw new PatchWardenError("invalid_lineage_id", "lineage_id may contain only letters, numbers, underscores, and hyphens.", "Pass a lineage_id returned by run_task_loop.", true, { lineage_id: lineageId });
-    }
-    return lineageId;
-}
-function normalizeMaxItems(value) {
-    if (value === undefined)
-        return 12;
-    if (!Number.isInteger(value) || value < 1 || value > 50) {
-        throw new Error("max_items must be an integer from 1 to 50.");
-    }
-    return value;
-}
-function readPolicySummary(repoPath) {
-    try {
-        const policy = getProjectPolicySummary(repoPath || ".");
-        return {
-            valid: Boolean(policy.valid),
-            issues: Array.isArray(policy.issues) ? policy.issues : [],
-            release_readiness: policy.release_readiness || null,
-        };
-    }
-    catch (err) {
-        return {
-            valid: false,
-            issues: [{ code: "policy_unavailable", message: err instanceof Error ? err.message : String(err) }],
-            release_readiness: null,
-        };
-    }
-}
-function safeCatalog() {
-    try {
-        const catalog = getLastToolCatalogSnapshot();
-        if (!catalog)
-            throw new Error("catalog snapshot unavailable");
-        return {
-            server_version: catalog.server_version,
-            schema_epoch: catalog.schema_epoch,
-            tool_profile: catalog.tool_profile,
-            tool_count: catalog.tool_count,
-            tool_manifest_sha256: catalog.tool_manifest_sha256,
-        };
-    }
-    catch {
-        return {
-            server_version: PATCHWARDEN_VERSION,
-            schema_epoch: TOOL_SCHEMA_EPOCH,
-            tool_profile: null,
-            tool_count: null,
-            tool_manifest_sha256: null,
-        };
-    }
-}
-function buildNextAction(lineage) {
-    if (lineage.stop_reason === "success")
-        return "Use this evidence pack for review or release readiness.";
-    return lineage.next_action || "Review lineage before exporting release evidence.";
-}
-function buildEvidenceMarkdown(pack) {
-    const direct = pack.lineage.tasks.direct_sessions
-        .map((entry) => `- ${entry.session_id}: status=${entry.status || "unknown"}, audit=${entry.audit_decision || "unknown"}`)
-        .join("\n");
-    const rounds = pack.lineage.rounds
-        .map((round) => `- ${round.role} ${round.task_id}: status=${round.status}, verification=${round.verification_status}, audit=${round.audit_verdict}`)
-        .join("\n");
-    return [
-        "# PatchWarden Evidence Pack",
-        "",
-        `- Evidence pack: ${pack.evidence_pack_id}`,
-        `- Lineage: ${pack.lineage_id}`,
-        `- Generated: ${pack.generated_at}`,
-        `- Final status: ${pack.lineage.final_status}`,
-        `- Stop reason: ${pack.lineage.stop_reason}`,
-        `- Worktree: ${pack.lineage.worktree.isolation_mode} (${pack.lineage.worktree.status})`,
-        `- Tool manifest: ${pack.catalog.tool_manifest_sha256 || "unavailable"}`,
-        "",
-        "## Verification Rounds",
-        rounds || "- None.",
-        "",
-        "## Direct Evidence",
-        direct || "- None.",
-        "",
-        "## Policy And Release",
-        `- Policy valid: ${pack.policy.valid}`,
-        `- Policy issue count: ${pack.policy.issue_count}`,
-        "",
-        "## Omitted",
-        ...pack.omitted.map((item) => `- ${item}`),
-        "",
-        `Next action: ${pack.next_action}`,
-        "",
-    ].join("\n");
-}