patchwarden 0.6.4 → 1.5.0

package/dist/test/unit/handoff-export.test.js

@@ -0,0 +1,263 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, existsSync, readFileSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
+import { generateHandoff, exportHandoff } from "../../goal/handoffExport.js";
+// ── Helpers ───────────────────────────────────────────────────────
+function makeSubgoal(overrides) {
+    return {
+        title: "Subgoal " + overrides.id,
+        status: "ready",
+        depends_on: [],
+        task_ids: [],
+        ...overrides,
+    };
+}
+function makeGoalStatus(subgoals, overrides = {}) {
+    const now = new Date().toISOString();
+    return {
+        goal_id: "goal_test_001",
+        title: "Test Goal",
+        status: "active",
+        repo_path: "/repo/test",
+        created_at: now,
+        updated_at: now,
+        subgoals,
+        ...overrides,
+    };
+}
+// ── Tests ─────────────────────────────────────────────────────────
+describe("handoffExport", () => {
+    describe("generateHandoff", () => {
+        it("空 subgoals → 文档包含所有章节", () => {
+            const goal = makeGoalStatus([]);
+            const md = generateHandoff("goal_test_001", goal);
+            assert.ok(md.includes("# Goal Session Handoff"));
+            assert.ok(md.includes("## 当前 Goal"));
+            assert.ok(md.includes("## 版本目标"));
+            assert.ok(md.includes("## 已完成子目标"));
+            assert.ok(md.includes("## 未完成子目标"));
+            assert.ok(md.includes("## 已拒绝子目标"));
+            assert.ok(md.includes("## 最近一次 diff 摘要"));
+            assert.ok(md.includes("## 最近一次测试结果"));
+            assert.ok(md.includes("## 当前阻塞点"));
+            assert.ok(md.includes("## 下一步建议"));
+            assert.ok(md.includes("## 风险提醒"));
+            assert.ok(md.includes("## 接手说明"));
+            assert.ok(md.includes("Generated:"));
+        });
+        it("空 subgoals → 已完成/未完成显示无", () => {
+            const goal = makeGoalStatus([]);
+            const md = generateHandoff("goal_test_001", goal);
+            const completedSection = md.split("## 已完成子目标")[1].split("##")[0];
+            assert.ok(completedSection.includes("无"));
+            const incompleteSection = md.split("## 未完成子目标")[1].split("##")[0];
+            assert.ok(incompleteSection.includes("无"));
+        });
+        it("有 accepted subgoal → 出现在已完成子目标", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({
+                    id: "subgoal-001",
+                    title: "Implement feature A",
+                    status: "accepted",
+                    accepted_at: "2026-01-01T00:00:00.000Z",
+                }),
+            ]);
+            const md = generateHandoff("goal_test_001", goal);
+            const completedSection = md.split("## 已完成子目标")[1].split("##")[0];
+            assert.ok(completedSection.includes("subgoal-001"));
+            assert.ok(completedSection.includes("Implement feature A"));
+            assert.ok(completedSection.includes("2026-01-01T00:00:00.000Z"));
+        });
+        it("有 running subgoal → 出现在未完成子目标和风险提醒", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({
+                    id: "subgoal-001",
+                    title: "WIP task",
+                    status: "running",
+                }),
+            ]);
+            const md = generateHandoff("goal_test_001", goal);
+            const incompleteSection = md.split("## 未完成子目标")[1].split("##")[0];
+            assert.ok(incompleteSection.includes("subgoal-001"));
+            assert.ok(incompleteSection.includes("running"));
+            const riskSection = md.split("## 风险提醒")[1].split("##")[0];
+            assert.ok(riskSection.includes("subgoal-001"));
+            assert.ok(riskSection.includes("running"));
+        });
+        it("有 rejected subgoal → 出现在已拒绝子目标", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({
+                    id: "subgoal-001",
+                    title: "Failed task",
+                    status: "rejected",
+                    rejected_reason: "Tests failed",
+                }),
+            ]);
+            const md = generateHandoff("goal_test_001", goal);
+            const rejectedSection = md.split("## 已拒绝子目标")[1].split("##")[0];
+            assert.ok(rejectedSection.includes("subgoal-001"));
+            assert.ok(rejectedSection.includes("Failed task"));
+            assert.ok(rejectedSection.includes("Tests failed"));
+        });
+        it("无 rejected subgoal → 已拒绝子目标显示无", () => {
+            const goal = makeGoalStatus([]);
+            const md = generateHandoff("goal_test_001", goal);
+            const rejectedSection = md.split("## 已拒绝子目标")[1].split("##")[0];
+            assert.ok(rejectedSection.includes("无"));
+        });
+        it("有 needs_fix subgoal → 出现在当前阻塞点和风险提醒", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({
+                    id: "subgoal-001",
+                    title: "Needs fix task",
+                    status: "needs_fix",
+                }),
+            ]);
+            const md = generateHandoff("goal_test_001", goal);
+            const blockerSection = md.split("## 当前阻塞点")[1].split("##")[0];
+            assert.ok(blockerSection.includes("subgoal-001"));
+            assert.ok(blockerSection.includes("Needs fix task"));
+            const riskSection = md.split("## 风险提醒")[1].split("##")[0];
+            assert.ok(riskSection.includes("subgoal-001"));
+            assert.ok(riskSection.includes("needs_fix"));
+        });
+        it("有 recentDiff → 出现在最近一次 diff 摘要", () => {
+            const goal = makeGoalStatus([]);
+            const diff = "diff --git a/src/foo.ts b/src/foo.ts\n+console.log('hello')";
+            const md = generateHandoff("goal_test_001", goal, diff);
+            const diffSection = md.split("## 最近一次 diff 摘要")[1].split("##")[0];
+            assert.ok(diffSection.includes("src/foo.ts"));
+            assert.ok(diffSection.includes("console.log"));
+        });
+        it("无 recentDiff → 显示暂无", () => {
+            const goal = makeGoalStatus([]);
+            const md = generateHandoff("goal_test_001", goal);
+            const diffSection = md.split("## 最近一次 diff 摘要")[1].split("##")[0];
+            assert.ok(diffSection.includes("暂无"));
+        });
+        it("有 recentTestResult → 出现在最近一次测试结果", () => {
+            const goal = makeGoalStatus([]);
+            const testResult = "PASS: 42 tests passed, 0 failed";
+            const md = generateHandoff("goal_test_001", goal, undefined, testResult);
+            const testSection = md.split("## 最近一次测试结果")[1].split("##")[0];
+            assert.ok(testSection.includes("42 tests passed"));
+        });
+        it("无 recentTestResult → 显示暂无", () => {
+            const goal = makeGoalStatus([]);
+            const md = generateHandoff("goal_test_001", goal);
+            const testSection = md.split("## 最近一次测试结果")[1].split("##")[0];
+            assert.ok(testSection.includes("暂无"));
+        });
+        it("接手说明包含 goalId", () => {
+            const goal = makeGoalStatus([]);
+            const md = generateHandoff("goal_handoff_999", goal);
+            const handoffSection = md.split("## 接手说明")[1];
+            assert.ok(handoffSection.includes("goal_handoff_999"));
+            assert.ok(handoffSection.includes("read_goal"));
+            assert.ok(handoffSection.includes("suggest_next_subgoal"));
+        });
+        it("当前 Goal 章节包含 goal_id/title/status/repo_path", () => {
+            const goal = makeGoalStatus([], {
+                goal_id: "goal_abc",
+                title: "My Custom Goal",
+                status: "active",
+                repo_path: "/custom/repo",
+            });
+            const md = generateHandoff("goal_abc", goal);
+            const goalSection = md.split("## 当前 Goal")[1].split("##")[0];
+            assert.ok(goalSection.includes("goal_abc"));
+            assert.ok(goalSection.includes("My Custom Goal"));
+            assert.ok(goalSection.includes("active"));
+            assert.ok(goalSection.includes("/custom/repo"));
+        });
+        it("有 ready subgoal → 下一步建议包含该 subgoal", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", title: "Ready task", depends_on: [] }),
+            ]);
+            const md = generateHandoff("goal_test_001", goal);
+            const suggestSection = md.split("## 下一步建议")[1].split("##")[0];
+            assert.ok(suggestSection.includes("subgoal-001"));
+            assert.ok(suggestSection.includes("Ready task"));
+        });
+        it("未完成子目标显示 depends_on", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "A", status: "accepted", accepted_at: "2026-01-01T00:00:00.000Z" }),
+                makeSubgoal({ id: "B", title: "Depends on A", status: "ready", depends_on: ["A"] }),
+            ]);
+            const md = generateHandoff("goal_test_001", goal);
+            const incompleteSection = md.split("## 未完成子目标")[1].split("##")[0];
+            assert.ok(incompleteSection.includes("B"));
+            assert.ok(incompleteSection.includes("depends_on: A"));
+        });
+    });
+    describe("exportHandoff", () => {
+        let tempDir;
+        beforeEach(() => {
+            tempDir = mkdtempSync(join(tmpdir(), "pw-handoff-"));
+        });
+        afterEach(() => {
+            rmSync(tempDir, { recursive: true, force: true });
+        });
+        it("写入 handoff.md 文件到 .patchwarden/goals/{goalId}/", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", title: "Task A", depends_on: [] }),
+            ]);
+            const result = exportHandoff("goal_export_001", goal, tempDir);
+            const expectedPath = resolve(tempDir, ".patchwarden", "goals", "goal_export_001", "handoff.md");
+            assert.equal(result.handoff_path, expectedPath);
+            assert.ok(existsSync(expectedPath));
+            const fileContent = readFileSync(expectedPath, "utf-8");
+            assert.ok(fileContent.includes("# Goal Session Handoff"));
+            assert.ok(fileContent.includes("goal_export_001"));
+        });
+        it("返回的 handoff_path 是绝对路径", () => {
+            const goal = makeGoalStatus([]);
+            const result = exportHandoff("goal_export_002", goal, tempDir);
+            assert.ok(result.handoff_path.includes(tempDir));
+            assert.ok(result.handoff_path.endsWith("handoff.md"));
+        });
+        it("content_preview 不超过 500 字符（加省略号）", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", title: "A".repeat(200), depends_on: [] }),
+                makeSubgoal({ id: "subgoal-002", title: "B".repeat(200), depends_on: [] }),
+                makeSubgoal({ id: "subgoal-003", title: "C".repeat(200), depends_on: [] }),
+            ]);
+            const result = exportHandoff("goal_export_003", goal, tempDir);
+            assert.ok(result.content_preview.length > 0);
+            assert.ok(result.content_preview.endsWith("..."));
+            assert.ok(result.content_preview.length <= 503); // 500 + "..."
+        });
+        it("content_preview 是文档前 500 字符的截取", () => {
+            const goal = makeGoalStatus([]);
+            const result = exportHandoff("goal_export_004", goal, tempDir);
+            const fileContent = readFileSync(result.handoff_path, "utf-8");
+            if (fileContent.length > 500) {
+                assert.equal(result.content_preview, fileContent.slice(0, 500) + "...");
+            }
+            else {
+                assert.equal(result.content_preview, fileContent);
+            }
+        });
+        it("文件内容与 generateHandoff 一致", () => {
+            const goal = makeGoalStatus([
+                makeSubgoal({ id: "subgoal-001", title: "Verify content", depends_on: [] }),
+            ]);
+            const expected = generateHandoff("goal_export_005", goal);
+            const result = exportHandoff("goal_export_005", goal, tempDir);
+            const fileContent = readFileSync(result.handoff_path, "utf-8");
+            // 排除 Generated 时间戳行（两次调用可能跨越毫秒边界）
+            const stripGenerated = (s) => s.replace(/^Generated: .*$/m, "Generated: <ts>");
+            assert.equal(stripGenerated(fileContent), stripGenerated(expected));
+        });
+        it("创建多层目录结构", () => {
+            const goal = makeGoalStatus([]);
+            const result = exportHandoff("goal_deep_001", goal, tempDir);
+            const goalDir = resolve(tempDir, ".patchwarden", "goals", "goal_deep_001");
+            const stat = statSync(goalDir);
+            assert.ok(stat.isDirectory());
+            assert.ok(existsSync(result.handoff_path));
+        });
+    });
+});

package/dist/test/unit/invoke-discovered-tool.test.d.ts

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

package/dist/test/unit/invoke-discovered-tool.test.js

@@ -0,0 +1,167 @@
+import { describe, it, beforeEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { invokeDiscoveredTool, } from "../../tools/invokeDiscoveredTool.js";
+import { issueToken, clearAllTokens } from "../../security/discoveryTokenStore.js";
+import { computeSchemaDigest } from "../../tools/toolRegistry.js";
+// ── Helpers ───────────────────────────────────────────────────────
+function makeToolDef(name) {
+    return {
+        name,
+        description: `Mock ${name} tool`,
+        inputSchema: { type: "object", properties: {} },
+    };
+}
+const MOCK_TOOLS = [
+    "safe_status",
+    "get_diff",
+    "save_plan",
+    "invoke_discovered_tool",
+    "__test_credential_tool",
+].map(makeToolDef);
+function makeContext(overrides = {}) {
+    return {
+        tools: MOCK_TOOLS,
+        profile: "full",
+        dispatch: async () => ({ ok: true }),
+        ...overrides,
+    };
+}
+function issueTokenFor(toolName, risk) {
+    return issueToken({
+        toolName,
+        risk,
+        query: "test query",
+        schemaDigest: computeSchemaDigest({}),
+        profile: "full",
+    });
+}
+function makeInput(overrides = {}) {
+    return {
+        toolName: "safe_status",
+        arguments: {},
+        discoveryToken: "",
+        ...overrides,
+    };
+}
+// ── Tests ─────────────────────────────────────────────────────────
+describe("invokeDiscoveredTool", () => {
+    beforeEach(() => {
+        clearAllTokens();
+    });
+    describe("合法调用", () => {
+        it("readonly 工具 + 有效 token + dispatch 成功 → ok=true", async () => {
+            const token = issueTokenFor("safe_status", "readonly");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "safe_status",
+                arguments: { task_id: "t-1" },
+                discoveryToken: token,
+            }), makeContext({
+                dispatch: async () => ({ status: "pending" }),
+            }));
+            assert.equal(result.ok, true);
+            assert.ok(result.result, "result should be present");
+            assert.deepEqual(result.result, { status: "pending" });
+            assert.equal(result.invocation_log_written, true);
+            assert.equal(result.error, undefined);
+        });
+    });
+    describe("token 校验", () => {
+        it("token 不存在 → ok=false, reason=token_not_found", async () => {
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "safe_status",
+                arguments: {},
+                discoveryToken: "tok",
+            }), makeContext());
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "token_not_found");
+            assert.equal(result.invocation_log_written, true);
+        });
+        it("token toolName 不匹配 → ok=false, reason=token_tool_mismatch", async () => {
+            const token = issueTokenFor("safe_status", "readonly");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "get_diff",
+                arguments: { task_id: "t-1" },
+                discoveryToken: token,
+            }), makeContext());
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "token_tool_mismatch");
+        });
+    });
+    describe("toolMeta 查找", () => {
+        it("工具未注册 → ok=false, reason=tool_not_registered", async () => {
+            const token = issueTokenFor("safe_status", "readonly");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "safe_status",
+                arguments: {},
+                discoveryToken: token,
+            }), makeContext({
+                tools: [makeToolDef("get_diff")],
+            }));
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "tool_not_registered");
+        });
+    });
+    describe("防递归", () => {
+        it("toolName=invoke_discovered_tool → ok=false, reason=recursive_invocation_blocked", async () => {
+            const token = issueTokenFor("invoke_discovered_tool", "command");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "invoke_discovered_tool",
+                arguments: {},
+                discoveryToken: token,
+            }), makeContext());
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "recursive_invocation_blocked");
+        });
+    });
+    describe("守卫校验", () => {
+        it("credential_sensitive 工具 → ok=false, reason=credential_sensitive_blocked", async () => {
+            const token = issueTokenFor("__test_credential_tool", "credential_sensitive");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "__test_credential_tool",
+                arguments: {},
+                discoveryToken: token,
+            }), makeContext());
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "credential_sensitive_blocked");
+        });
+        it("workspace_write 缺 assessmentId → ok=false, reason=assessment_required", async () => {
+            const token = issueTokenFor("save_plan", "workspace_write");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "save_plan",
+                arguments: {},
+                discoveryToken: token,
+            }), makeContext());
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "assessment_required");
+        });
+    });
+    describe("dispatch", () => {
+        it("dispatch 抛错 → ok=false, reason=dispatch_error", async () => {
+            const token = issueTokenFor("safe_status", "readonly");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "safe_status",
+                arguments: {},
+                discoveryToken: token,
+            }), makeContext({
+                dispatch: async () => {
+                    throw new Error("boom");
+                },
+            }));
+            assert.equal(result.ok, false);
+            assert.equal(result.error?.reason, "dispatch_error");
+            assert.ok(result.error?.message.includes("boom"), `expected message to contain "boom", got "${result.error?.message}"`);
+        });
+        it("成功调用 → invocation_log_written=true", async () => {
+            const token = issueTokenFor("safe_status", "readonly");
+            const result = await invokeDiscoveredTool(makeInput({
+                toolName: "safe_status",
+                arguments: { task_id: "t-log" },
+                discoveryToken: token,
+            }), makeContext({
+                dispatch: async () => ({ status: "done" }),
+            }));
+            assert.equal(result.ok, true);
+            assert.equal(result.invocation_log_written, true);
+        });
+    });
+});

package/dist/test/unit/logging.test.js

@@ -1,6 +1,9 @@
 import { describe, it, beforeEach, afterEach } from "node:test";
 import { strict as assert } from "node:assert";
-import { Logger, logUnhandledError, installGlobalHandlers } from "../../logging.js";
+import { mkdtempSync, rmSync, readFileSync, existsSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { Logger, logUnhandledError, installGlobalHandlers, computeArgumentsDigest, logToolInvocation, } from "../../logging.js";
 // ── Test helpers ──────────────────────────────────────────────────
 /**
  * Capture everything written to stderr during `fn` and return it as an
@@ -140,9 +143,10 @@ describe("Logger — verbose mode (PATCHWARDEN_VERBOSE_LOG)", () => {
     it("does not log args by default (verbose mode off)", () => {
         delete process.env.PATCHWARDEN_VERBOSE_LOG;
         const log = new Logger();
+        const fakeToken = "sk_" + "FAKE_TOKEN_VALUE_123456";
         const sensitiveArgs = {
             prompt: "fix the bug",
-            token: "ghp_" + "a".repeat(20),
+            token: fakeToken,
         };
         const entries = captureJson(() => {
             log.audit("createTask", true, 100, undefined, "task-003", sensitiveArgs);
@@ -153,14 +157,15 @@ describe("Logger — verbose mode (PATCHWARDEN_VERBOSE_LOG)", () => {
         assert.equal(entry.args, undefined);
         // The raw token must not appear anywhere in the serialized entry
         const raw = JSON.stringify(entry);
-        assert.ok(!raw.includes("ghp_"), "raw token must not leak into log output");
+        assert.ok(!raw.includes(fakeToken), "raw token must not leak into log output");
     });
     it("logs sanitized args when PATCHWARDEN_VERBOSE_LOG=true", () => {
         process.env.PATCHWARDEN_VERBOSE_LOG = "true";
         const log = new Logger();
+        const fakeToken = "sk_" + "FAKE_TOKEN_VALUE_123456";
         const sensitiveArgs = {
             prompt: "fix the bug",
-            token: "ghp_" + "a".repeat(20),
+            token: fakeToken,
         };
         const entries = captureJson(() => {
             log.audit("createTask", true, 100, undefined, "task-004", sensitiveArgs);
@@ -171,7 +176,7 @@ describe("Logger — verbose mode (PATCHWARDEN_VERBOSE_LOG)", () => {
         assert.ok(entry.args !== undefined, "args should be logged in verbose mode");
         const argsStr = String(entry.args);
         assert.ok(argsStr.includes("[REDACTED TOKEN]"), "sensitive token must be redacted");
-        assert.ok(!argsStr.includes("ghp_"), "raw token must not appear in args");
+        assert.ok(!argsStr.includes(fakeToken), "raw token must not appear in args");
         // non-sensitive content is preserved
         assert.ok(argsStr.includes("fix the bug"), "non-sensitive args content is preserved");
     });
@@ -273,3 +278,120 @@ describe("installGlobalHandlers", () => {
         }
     });
 });
+// ── computeArgumentsDigest ───────────────────────────────────────
+describe("computeArgumentsDigest", () => {
+    it("returns the same digest for identical arguments (stability)", () => {
+        const args = { b: 2, a: 1, nested: { y: "yes", x: [1, 2] } };
+        const d1 = computeArgumentsDigest(args);
+        const d2 = computeArgumentsDigest(args);
+        assert.equal(d1, d2);
+    });
+    it("returns the same digest regardless of key order (stable serialization)", () => {
+        const d1 = computeArgumentsDigest({ a: 1, b: 2 });
+        const d2 = computeArgumentsDigest({ b: 2, a: 1 });
+        assert.equal(d1, d2);
+    });
+    it("returns different digests for different arguments", () => {
+        const d1 = computeArgumentsDigest({ a: 1 });
+        const d2 = computeArgumentsDigest({ a: 2 });
+        assert.notEqual(d1, d2);
+    });
+    it("returns a 'sha256:' prefixed digest", () => {
+        const digest = computeArgumentsDigest({ foo: "bar" });
+        assert.ok(digest.startsWith("sha256:"), `digest should start with "sha256:", got: ${digest}`);
+        // full format: sha256: + 64 lowercase hex chars
+        assert.match(digest, /^sha256:[a-f0-9]{64}$/);
+    });
+    it("does not leak raw argument values into the digest string", () => {
+        const fakeToken = "tok-value";
+        const sensitiveArgs = { token: fakeToken, prompt: "hello-world" };
+        const digest = computeArgumentsDigest(sensitiveArgs);
+        assert.ok(!digest.includes(fakeToken), "digest must not leak raw token value");
+        assert.ok(!digest.includes("hello-world"), "digest must not leak raw prompt value");
+    });
+});
+// ── logToolInvocation ────────────────────────────────────────────
+describe("logToolInvocation", () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "pw-invlog-"));
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    function sampleEntry(overrides = {}) {
+        return {
+            timestamp: new Date().toISOString(),
+            toolName: "read_workspace_file",
+            discoveryToken: "tok",
+            risk: "workspace_read_sensitive",
+            profile: "full",
+            arguments_digest: "sha256:" + "0".repeat(64),
+            result: "ok",
+            duration_ms: 42,
+            ...overrides,
+        };
+    }
+    it("writes an entry to invocation.log inside the provided logsDir", () => {
+        const logsDir = join(tempDir, ".patchwarden", "logs");
+        const entry = sampleEntry();
+        logToolInvocation(entry, { logsDir });
+        const logPath = join(logsDir, "invocation.log");
+        assert.ok(existsSync(logPath), "invocation.log should be created");
+        const content = readFileSync(logPath, "utf-8");
+        const lines = content.trim().split("\n");
+        assert.equal(lines.length, 1, "exactly one JSON line should be written");
+        const parsed = JSON.parse(lines[0]);
+        assert.equal(parsed.toolName, "read_workspace_file");
+        assert.equal(parsed.discoveryToken, "tok");
+        assert.equal(parsed.risk, "workspace_read_sensitive");
+        assert.equal(parsed.profile, "full");
+        assert.equal(parsed.result, "ok");
+        assert.equal(parsed.duration_ms, 42);
+        assert.match(parsed.arguments_digest, /^sha256:[a-f0-9]{64}$/);
+        assert.ok(!Number.isNaN(Date.parse(parsed.timestamp)));
+    });
+    it("appends multiple entries as JSON Lines", () => {
+        const logsDir = join(tempDir, "logs");
+        logToolInvocation(sampleEntry({ duration_ms: 1 }), { logsDir });
+        logToolInvocation(sampleEntry({ duration_ms: 2, result: "error", error_code: "blocked" }), { logsDir });
+        const content = readFileSync(join(logsDir, "invocation.log"), "utf-8");
+        const lines = content.trim().split("\n");
+        assert.equal(lines.length, 2);
+        const first = JSON.parse(lines[0]);
+        const second = JSON.parse(lines[1]);
+        assert.equal(first.duration_ms, 1);
+        assert.equal(first.result, "ok");
+        assert.equal(second.duration_ms, 2);
+        assert.equal(second.result, "error");
+        assert.equal(second.error_code, "blocked");
+    });
+    it("includes allowedScope and error_code when provided", () => {
+        const logsDir = join(tempDir, "logs");
+        logToolInvocation(sampleEntry({
+            allowedScope: ["src/", "docs/"],
+            result: "error",
+            error_code: "scope_violation",
+        }), { logsDir });
+        const parsed = JSON.parse(readFileSync(join(logsDir, "invocation.log"), "utf-8").trim());
+        assert.deepEqual(parsed.allowedScope, ["src/", "docs/"]);
+        assert.equal(parsed.error_code, "scope_violation");
+    });
+    it("omits error_code and allowedScope when not provided", () => {
+        const logsDir = join(tempDir, "logs");
+        logToolInvocation(sampleEntry(), { logsDir });
+        const parsed = JSON.parse(readFileSync(join(logsDir, "invocation.log"), "utf-8").trim());
+        assert.equal(parsed.error_code, undefined);
+        assert.equal(parsed.allowedScope, undefined);
+    });
+    it("does not throw when the log directory cannot be created", () => {
+        // Create a file, then attempt to use a path beneath it as logsDir.
+        // mkdirSync will fail with ENOTDIR because the parent is a file.
+        const blockingFile = join(tempDir, "blocker");
+        writeFileSync(blockingFile, "x", "utf-8");
+        const impossibleLogsDir = join(blockingFile, "subdir");
+        assert.doesNotThrow(() => {
+            logToolInvocation(sampleEntry(), { logsDir: impossibleLogsDir });
+        });
+    });
+});

package/dist/test/unit/post-task-cleanup.test.d.ts

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

package/dist/test/unit/post-task-cleanup.test.js

@@ -0,0 +1,48 @@
+import { describe, it } from "node:test";
+import { strict as assert } from "node:assert";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { runPostTaskCleanup } from "../../runner/postTaskCleanup.js";
+describe("postTaskCleanup", () => {
+    it("removes untracked low-risk artifacts and skips tracked or excluded paths", () => {
+        const root = mkdtempSync(join(tmpdir(), "pw-cleanup-"));
+        try {
+            execFileSync("git", ["init"], { cwd: root, stdio: "ignore" });
+            execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: root, stdio: "ignore" });
+            execFileSync("git", ["config", "user.name", "PatchWarden Test"], { cwd: root, stdio: "ignore" });
+            mkdirSync(join(root, "tracked", "__pycache__"), { recursive: true });
+            writeFileSync(join(root, "tracked", "__pycache__", "keep.pyc"), "tracked", "utf-8");
+            execFileSync("git", ["add", "."], { cwd: root, stdio: "ignore" });
+            execFileSync("git", ["commit", "-m", "init"], { cwd: root, stdio: "ignore" });
+            mkdirSync(join(root, "backend", "__pycache__"), { recursive: true });
+            mkdirSync(join(root, ".venv", "__pycache__"), { recursive: true });
+            mkdirSync(join(root, ".patchwarden", "tasks", "old-task", "__pycache__"), { recursive: true });
+            mkdirSync(join(root, "node_modules", "pkg", "__pycache__"), { recursive: true });
+            mkdirSync(join(root, "docs", "__pycache__"), { recursive: true });
+            writeFileSync(join(root, "backend", "__pycache__", "drop.pyc"), "drop", "utf-8");
+            writeFileSync(join(root, ".venv", "__pycache__", "skip.pyc"), "skip", "utf-8");
+            writeFileSync(join(root, ".patchwarden", "tasks", "old-task", "__pycache__", "skip.pyc"), "skip", "utf-8");
+            writeFileSync(join(root, "node_modules", "pkg", "__pycache__", "skip.pyc"), "skip", "utf-8");
+            writeFileSync(join(root, "docs", "__pycache__", "skip.pyc"), "skip", "utf-8");
+            const taskDir = join(root, ".patchwarden", "tasks", "task-1");
+            mkdirSync(taskDir, { recursive: true });
+            const report = runPostTaskCleanup(root, taskDir);
+            assert.ok(report.removed.some((entry) => entry.path === "backend/__pycache__"));
+            assert.ok(report.skipped.some((entry) => entry.path === "tracked/__pycache__" && entry.skip_reason === "tracked_by_git"));
+            assert.equal(report.source_files_touched, 0);
+            assert.ok(!existsSync(join(root, "backend", "__pycache__")));
+            assert.ok(existsSync(join(root, "tracked", "__pycache__", "keep.pyc")));
+            assert.ok(existsSync(join(root, ".venv", "__pycache__", "skip.pyc")));
+            assert.ok(existsSync(join(root, ".patchwarden", "tasks", "old-task", "__pycache__", "skip.pyc")));
+            assert.ok(existsSync(join(root, "node_modules", "pkg", "__pycache__", "skip.pyc")));
+            assert.ok(existsSync(join(root, "docs", "__pycache__", "skip.pyc")));
+            const written = JSON.parse(readFileSync(join(taskDir, "post-task-cleanup.json"), "utf-8"));
+            assert.equal(written.enabled, true);
+        }
+        finally {
+            rmSync(root, { recursive: true, force: true });
+        }
+    });
+});

package/dist/test/unit/project-policy-release-mode.test.d.ts

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