patchwarden 1.1.0 → 1.5.1

package/dist/test/unit/spec-kit-import.test.js

@@ -0,0 +1,341 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createGoal, readGoalStatus } from "../../goal/goalStore.js";
+import { importSpecKitTasks, parseSpecKitJson, } from "../../goal/specKitImport.js";
+import { PatchWardenError } from "../../errors.js";
+// ── Helpers ───────────────────────────────────────────────────────
+let tempDir;
+let goalId;
+beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), "pw-speckit-"));
+    const result = createGoal("repo", "Spec Kit Test Goal", "desc", tempDir);
+    goalId = result.goal_id;
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+function makeStandardInput() {
+    return {
+        spec: "feature-auth",
+        tasks: [
+            {
+                id: "T1",
+                desc: "Set up database schema",
+                files: ["src/db/schema.ts"],
+            },
+            {
+                id: "T2",
+                desc: "Implement auth service",
+                files: ["src/auth/service.ts", "src/auth/types.ts"],
+            },
+            {
+                id: "T3",
+                desc: "Write integration tests",
+                files: ["test/auth.test.ts"],
+            },
+        ],
+    };
+}
+// ── Tests ─────────────────────────────────────────────────────────
+describe("specKitImport", () => {
+    describe("parseSpecKitJson", () => {
+        it("解析合法 JSON 返回 SpecKitInput", () => {
+            const json = JSON.stringify({
+                spec: "my-spec",
+                tasks: [
+                    { id: "T1", desc: "Task one", files: ["a.ts"] },
+                    { id: "T2", desc: "Task two", depends_on: ["T1"] },
+                ],
+                acceptance: ["T1 passes", "T2 passes"],
+            });
+            const input = parseSpecKitJson(json);
+            assert.equal(input.spec, "my-spec");
+            assert.equal(input.tasks.length, 2);
+            assert.equal(input.tasks[0].id, "T1");
+            assert.equal(input.tasks[0].desc, "Task one");
+            assert.deepEqual(input.tasks[0].files, ["a.ts"]);
+            assert.deepEqual(input.tasks[1].depends_on, ["T1"]);
+            assert.deepEqual(input.acceptance, ["T1 passes", "T2 passes"]);
+        });
+        it("缺 spec 字段抛出错误", () => {
+            const json = JSON.stringify({ tasks: [] });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("spec 为空字符串抛出错误", () => {
+            const json = JSON.stringify({ spec: "", tasks: [] });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("缺 tasks 字段抛出错误", () => {
+            const json = JSON.stringify({ spec: "my-spec" });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("tasks 不是数组抛出错误", () => {
+            const json = JSON.stringify({ spec: "my-spec", tasks: "not-an-array" });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("task 缺 id 抛出错误", () => {
+            const json = JSON.stringify({
+                spec: "my-spec",
+                tasks: [{ desc: "no id" }],
+            });
+            assert.throws(() => parseSpecKitJson(json), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+        });
+        it("无效 JSON 文本抛出错误", () => {
+            assert.throws(() => parseSpecKitJson("{ not valid json"), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_json");
+                return true;
+            });
+        });
+    });
+    describe("importSpecKitTasks — 标准导入", () => {
+        it("3 个无依赖 task → created_count=3, existing_count=0", () => {
+            const input = makeStandardInput();
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 3);
+            assert.equal(result.existing_count, 0);
+            assert.equal(result.subgoal_ids.length, 3);
+            assert.equal(result.spec_name, "feature-auth");
+            assert.equal(result.goal_id, goalId);
+        });
+        it("每个 subgoal 的 title = task.desc", () => {
+            const input = makeStandardInput();
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+            assert.equal(status.subgoals[0].title, "Set up database schema");
+            assert.equal(status.subgoals[1].title, "Implement auth service");
+            assert.equal(status.subgoals[2].title, "Write integration tests");
+        });
+        it("每个 subgoal 的 external_ref = task.id", () => {
+            const input = makeStandardInput();
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals[0].external_ref, "T1");
+            assert.equal(status.subgoals[1].external_ref, "T2");
+            assert.equal(status.subgoals[2].external_ref, "T3");
+        });
+        it("task.files 映射到 scope_hints", () => {
+            const input = makeStandardInput();
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.deepEqual(status.subgoals[0].scope_hints, ["src/db/schema.ts"]);
+            assert.deepEqual(status.subgoals[1].scope_hints, [
+                "src/auth/service.ts",
+                "src/auth/types.ts",
+            ]);
+            assert.deepEqual(status.subgoals[2].scope_hints, ["test/auth.test.ts"]);
+        });
+        it("subgoal_ids 对应新创建的 subgoal id", () => {
+            const input = makeStandardInput();
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.deepEqual(result.subgoal_ids, ["subgoal-001", "subgoal-002", "subgoal-003"]);
+        });
+    });
+    describe("importSpecKitTasks — 依赖关系导入", () => {
+        it("T2 depends_on T1 → T2 的 depends_on 含 T1 的 subgoal_id（非 external_ref）", () => {
+            const input = {
+                spec: "feature-deps",
+                tasks: [
+                    { id: "T1", desc: "Foundation task" },
+                    { id: "T2", desc: "Dependent task", depends_on: ["T1"] },
+                ],
+            };
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 2);
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 2);
+            const t1Subgoal = status.subgoals[0];
+            const t2Subgoal = status.subgoals[1];
+            assert.equal(t1Subgoal.external_ref, "T1");
+            assert.equal(t2Subgoal.external_ref, "T2");
+            // T2 depends_on 应包含 T1 的 subgoal_id，而非 external_ref
+            assert.ok(t2Subgoal.depends_on.includes(t1Subgoal.id));
+            assert.ok(!t2Subgoal.depends_on.includes("T1"));
+        });
+        it("多级依赖 T3 → T2 → T1 全部正确解析", () => {
+            const input = {
+                spec: "multi-level",
+                tasks: [
+                    { id: "T1", desc: "Level 1" },
+                    { id: "T2", desc: "Level 2", depends_on: ["T1"] },
+                    { id: "T3", desc: "Level 3", depends_on: ["T2"] },
+                ],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+            assert.deepEqual(status.subgoals[0].depends_on, []);
+            assert.deepEqual(status.subgoals[1].depends_on, ["subgoal-001"]);
+            assert.deepEqual(status.subgoals[2].depends_on, ["subgoal-002"]);
+        });
+        it("依赖不存在的 task → 忽略该依赖并继续创建", () => {
+            const input = {
+                spec: "missing-dep",
+                tasks: [
+                    { id: "T1", desc: "Task with missing dep", depends_on: ["NONEXISTENT"] },
+                ],
+            };
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 1);
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 1);
+            assert.deepEqual(status.subgoals[0].depends_on, []);
+        });
+    });
+    describe("importSpecKitTasks — 验收标准映射", () => {
+        it("input.acceptance 写入 GoalStatus.acceptance_criteria", () => {
+            const input = {
+                spec: "feature-acceptance",
+                tasks: [{ id: "T1", desc: "Task one" }],
+                acceptance: ["T1 passes", "T2 passes"],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.deepEqual(status.acceptance_criteria, ["T1 passes", "T2 passes"]);
+        });
+        it("无 acceptance → GoalStatus.acceptance_criteria 不存在", () => {
+            const input = {
+                spec: "no-acceptance",
+                tasks: [{ id: "T1", desc: "Task one" }],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.acceptance_criteria, undefined);
+        });
+        it("空 acceptance 数组 → GoalStatus.acceptance_criteria 不存在", () => {
+            const input = {
+                spec: "empty-acceptance",
+                tasks: [{ id: "T1", desc: "Task one" }],
+                acceptance: [],
+            };
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.acceptance_criteria, undefined);
+        });
+    });
+    describe("importSpecKitTasks — 幂等去重", () => {
+        it("重复导入相同 JSON → 第二次 created_count=0, existing_count=3", () => {
+            const input = makeStandardInput();
+            // 第一次导入
+            const result1 = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result1.created_count, 3);
+            assert.equal(result1.existing_count, 0);
+            // 第二次导入相同 JSON
+            const result2 = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result2.created_count, 0);
+            assert.equal(result2.existing_count, 3);
+            assert.deepEqual(result2.subgoal_ids, []);
+        });
+        it("重复导入后 subgoal 总数仍为 3", () => {
+            const input = makeStandardInput();
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+        });
+        it("部分新 task 导入：只创建新增的", () => {
+            // 第一次导入 T1, T2
+            const input1 = {
+                spec: "partial",
+                tasks: [
+                    { id: "T1", desc: "Task one" },
+                    { id: "T2", desc: "Task two" },
+                ],
+            };
+            const result1 = importSpecKitTasks(goalId, input1, { workspaceRoot: tempDir });
+            assert.equal(result1.created_count, 2);
+            // 第二次导入 T1, T2, T3（T1/T2 已存在）
+            const input2 = {
+                spec: "partial",
+                tasks: [
+                    { id: "T1", desc: "Task one" },
+                    { id: "T2", desc: "Task two" },
+                    { id: "T3", desc: "Task three" },
+                ],
+            };
+            const result2 = importSpecKitTasks(goalId, input2, { workspaceRoot: tempDir });
+            assert.equal(result2.created_count, 1);
+            assert.equal(result2.existing_count, 2);
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 3);
+        });
+    });
+    describe("importSpecKitTasks — 无效输入", () => {
+        it("spec 为空 → 抛出错误且不创建 subgoal", () => {
+            const input = { spec: "", tasks: [] };
+            assert.throws(() => importSpecKitTasks(goalId, input, { workspaceRoot: tempDir }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 0);
+        });
+        it("tasks 不是数组 → 抛出错误且不创建 subgoal", () => {
+            const input = { spec: "test", tasks: "not-array" };
+            assert.throws(() => importSpecKitTasks(goalId, input, { workspaceRoot: tempDir }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 0);
+        });
+        it("tasks 缺失 → 抛出错误且不创建 subgoal", () => {
+            const input = { spec: "test" };
+            assert.throws(() => importSpecKitTasks(goalId, input, { workspaceRoot: tempDir }), (err) => {
+                assert.ok(err instanceof PatchWardenError);
+                assert.equal(err.reason, "invalid_spec_kit_input");
+                return true;
+            });
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 0);
+        });
+    });
+    describe("importSpecKitTasks — JSON 文本端到端", () => {
+        it("parseSpecKitJson + importSpecKitTasks 完整流程", () => {
+            const json = JSON.stringify({
+                spec: "e2e-spec",
+                tasks: [
+                    { id: "T1", desc: "First task", files: ["a.ts"] },
+                    { id: "T2", desc: "Second task", depends_on: ["T1"] },
+                ],
+                acceptance: ["All tests pass"],
+            });
+            const input = parseSpecKitJson(json);
+            const result = importSpecKitTasks(goalId, input, { workspaceRoot: tempDir });
+            assert.equal(result.created_count, 2);
+            assert.equal(result.spec_name, "e2e-spec");
+            const status = readGoalStatus(goalId, tempDir);
+            assert.equal(status.subgoals.length, 2);
+            assert.equal(status.subgoals[0].external_ref, "T1");
+            assert.equal(status.subgoals[1].external_ref, "T2");
+            assert.deepEqual(status.subgoals[1].depends_on, ["subgoal-001"]);
+            assert.deepEqual(status.acceptance_criteria, ["All tests pass"]);
+        });
+    });
+});

package/dist/test/unit/wait-for-task.test.d.ts

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

package/dist/test/unit/wait-for-task.test.js

@@ -0,0 +1,144 @@
+import { describe, it, beforeEach, afterEach } from "node:test";
+import { strict as assert } from "node:assert";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { reloadConfig } from "../../config.js";
+import { waitForTask } from "../../tools/waitForTask.js";
+let tempDir;
+let tasksDir;
+let prevConfigEnv;
+function writeConfig() {
+    const configPath = join(tempDir, "patchwarden.config.json");
+    writeFileSync(configPath, JSON.stringify({
+        workspaceRoot: tempDir,
+        tasksDir: ".patchwarden/tasks",
+        plansDir: ".patchwarden/plans",
+        assessmentsDir: ".patchwarden/assessments",
+        directSessionsDir: ".patchwarden/direct-sessions",
+        agents: { codex: { command: "codex", args: ["exec", "{prompt}"] } },
+        allowedTestCommands: ["npm test"],
+    }), "utf-8");
+    prevConfigEnv = process.env.PATCHWARDEN_CONFIG;
+    process.env.PATCHWARDEN_CONFIG = configPath;
+    reloadConfig();
+}
+function writeTaskStatus(taskId, status) {
+    const taskDir = join(tasksDir, taskId);
+    mkdirSync(taskDir, { recursive: true });
+    writeFileSync(join(taskDir, "status.json"), JSON.stringify(status, null, 2), "utf-8");
+    return taskDir;
+}
+function baseStatus(taskId, overrides = {}) {
+    return {
+        task_id: taskId,
+        plan_id: "plan-001",
+        agent: "codex",
+        workspace_root: tempDir,
+        repo_path: "repo",
+        resolved_repo_path: join(tempDir, "repo"),
+        created_at: "2026-07-12T10:00:00Z",
+        started_at: "2026-07-12T10:00:05Z",
+        finished_at: "2026-07-12T10:05:00Z",
+        updated_at: "2026-07-12T10:05:00Z",
+        timeout_seconds: 900,
+        error: null,
+        ...overrides,
+    };
+}
+describe("waitForTask", () => {
+    beforeEach(() => {
+        tempDir = mkdtempSync(join(tmpdir(), "pw-waitfortask-"));
+        tasksDir = join(tempDir, ".patchwarden", "tasks");
+        mkdirSync(tasksDir, { recursive: true });
+        writeConfig();
+    });
+    afterEach(() => {
+        if (prevConfigEnv === undefined)
+            delete process.env.PATCHWARDEN_CONFIG;
+        else
+            process.env.PATCHWARDEN_CONFIG = prevConfigEnv;
+        reloadConfig();
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    // ── already terminal: done ──
+    it("returns immediately when task is already done", async () => {
+        writeTaskStatus("task-done-001", baseStatus("task-done-001", {
+            status: "done",
+            phase: "completed",
+            verify_status: "passed",
+        }));
+        const result = await waitForTask("task-done-001", 5);
+        assert.equal(result.task_id, "task-done-001");
+        assert.equal(result.status, "done");
+        assert.equal(result.terminal, true);
+        assert.equal(result.timed_out, false);
+        assert.equal(result.continuation_required, false);
+        // terminal → includes compact summary, next tool is audit_task
+        assert.ok(result.summary);
+        assert.equal(result.next_tool_call.name, "audit_task");
+        assert.equal(result.progress_summary, undefined);
+    });
+    // ── already terminal: failed ──
+    it("returns immediately when task is already failed", async () => {
+        writeTaskStatus("task-failed-001", baseStatus("task-failed-001", {
+            status: "failed",
+            phase: "failed",
+            error: "Agent exited with code 1",
+        }));
+        const result = await waitForTask("task-failed-001", 5);
+        assert.equal(result.terminal, true);
+        assert.equal(result.status, "failed");
+        assert.equal(result.timed_out, false);
+        assert.equal(result.continuation_required, false);
+        assert.ok(result.summary);
+        assert.equal(result.next_tool_call.name, "audit_task");
+    });
+    // ── running + timeout → continuation_required ──
+    it("returns continuation_required when running task times out", async () => {
+        writeTaskStatus("task-running-001", baseStatus("task-running-001", {
+            status: "running",
+            phase: "executing_agent",
+            finished_at: undefined,
+        }));
+        const result = await waitForTask("task-running-001", 1);
+        assert.equal(result.task_id, "task-running-001");
+        assert.equal(result.status, "running");
+        assert.equal(result.terminal, false);
+        assert.equal(result.timed_out, true);
+        assert.equal(result.continuation_required, true);
+        // non-terminal → includes progress_summary, next tool is wait_for_task
+        assert.ok(result.progress_summary);
+        assert.equal(result.next_tool_call.name, "wait_for_task");
+        assert.equal(result.summary, undefined);
+        // waited approximately 1 second
+        assert.ok(result.waited_ms >= 900 && result.waited_ms <= 3000);
+    });
+    // ── canceled (terminal) ──
+    it("returns terminal result for canceled task", async () => {
+        writeTaskStatus("task-canceled-001", baseStatus("task-canceled-001", {
+            status: "canceled",
+            phase: "canceled",
+        }));
+        const result = await waitForTask("task-canceled-001", 5);
+        assert.equal(result.terminal, true);
+        assert.equal(result.status, "canceled");
+        assert.equal(result.timed_out, false);
+        assert.equal(result.continuation_required, false);
+        assert.ok(result.summary);
+        assert.equal(result.next_tool_call.name, "audit_task");
+    });
+    // ── task not found ──
+    it("throws when task does not exist", async () => {
+        await assert.rejects(() => waitForTask("non-existent-task", 1), /(File not found|Task not found)/);
+    });
+    // ── invalid wait_seconds ──
+    it("throws when wait_seconds is out of range", async () => {
+        writeTaskStatus("task-validate-001", baseStatus("task-validate-001", {
+            status: "done",
+            phase: "completed",
+        }));
+        await assert.rejects(() => waitForTask("task-validate-001", 0), /wait_seconds must be an integer from 1 to 30/);
+        await assert.rejects(() => waitForTask("task-validate-001", 31), /wait_seconds must be an integer from 1 to 30/);
+    });
+});

package/dist/tools/auditTask.d.ts

@@ -32,97 +32,42 @@ export interface AuditTaskOutput {
     manual_verification_items: string[];
     recommended_next_actions: string[];
 }
+import type { ChangedFile } from "../runner/changeCapture.js";
 /**
  * Check 1: forbidden_scope_violation (fail level).
  * Returns null when no forbidden patterns are configured (skip).
  * Returns pass when changed files do not match any forbidden pattern.
  * Returns fail when any changed file path (or old_path) matches a forbidden glob.
  */
-export declare function checkForbiddenScope(changedFiles: any, forbidden: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkForbiddenScope(changedFiles: ChangedFile[], forbidden: string[] | null): AuditCheck | null;
 /**
  * Check 2: done_evidence_missing (warn level).
  * Returns null when no done_evidence list is configured (skip).
  * Returns pass when all listed files exist in the task directory.
  * Returns warn when any listed file is missing.
  */
-export declare function checkDoneEvidenceMissing(taskDir: any, doneEvidence: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkDoneEvidenceMissing(taskDir: string, doneEvidence: string[] | null): AuditCheck | null;
 /**
  * Check 3: readme_changelog_sync (warn level).
  * Returns null when no code files (by extension) were changed (skip).
  * Returns pass when README.md or CHANGELOG.md (basename, case-insensitive) is also changed.
  * Returns warn when code changed but neither documentation file was updated.
  */
-export declare function checkReadmeChangelogSync(changedFiles: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkReadmeChangelogSync(changedFiles: ChangedFile[]): AuditCheck | null;
 /**
  * Check 4: package_manifest_consistency (warn level).
  * Returns null when package.json is not among changed files (skip).
  * Returns pass when package.json parses as JSON and has non-empty name and version strings.
  * Returns warn otherwise.
  */
-export declare function checkPackageManifestConsistency(changedFiles: any, repoPathSafe: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
+export declare function checkPackageManifestConsistency(changedFiles: ChangedFile[], repoPathSafe: string): AuditCheck | null;
 /**
  * Check 5: sensitive_path_access (fail level).
  * Returns null when there are no changed files (skip).
  * Returns pass when no changed file path (or old_path) is sensitive.
  * Returns fail when any changed file path is flagged by isSensitivePath.
  */
-export declare function checkSensitivePathAccess(changedFiles: any): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
-export declare function checkUnrecordedCommandExecution(testLogContent: string | null, resultMdContent: string | null, verifyCommands: string[], testCommand: string | null, repoPath?: string | null): {
-    name: string;
-    result: string;
-    detail: string;
-} | null;
-export declare function auditTask(taskId: any): {
-    task_id: any;
-    verdict: string;
-    acceptance: {
-        verdict: import("../goal/acceptanceEngine.js").AcceptanceVerdict;
-        status: string;
-        reason: string;
-        reasons: string[];
-        required_evidence: string[];
-        next_suggested_task: string;
-        fail_checks: import("../goal/acceptanceEngine.js").AcceptanceCheck[];
-        warn_checks: import("../goal/acceptanceEngine.js").AcceptanceCheck[];
-    };
-    summary: string;
-    checks: {
-        name: string;
-        result: string;
-        detail: string;
-    }[];
-    risks: {
-        severity: string;
-        description: string;
-    }[];
-    confirmed_failures: {
-        name: string;
-        result: string;
-        detail: string;
-    }[];
-    possible_false_positives: any[];
-    manual_verification_required: boolean;
-    manual_verification_items: any[];
-    recommended_next_actions: string[];
-};
+export declare function checkSensitivePathAccess(changedFiles: ChangedFile[]): AuditCheck | null;
+export declare function checkUnrecordedCommandExecution(testLogContent: string | null, resultMdContent: string | null, verifyCommands: string[], testCommand: string | null, repoPath?: string | null): AuditCheck | null;
+export declare function auditTask(taskId: string): AuditTaskOutput;
 export {};

package/dist/tools/auditTask.js

@@ -1,4 +1,3 @@
-// @ts-nocheck
 import { readFileSync, existsSync, writeFileSync, readdirSync, statSync } from "node:fs";
 import { join, resolve, relative, basename, sep, isAbsolute } from "node:path";
 import { getTasksDir, getConfig } from "../config.js";
@@ -288,9 +287,10 @@ function readPackageScripts(repoPath) {
     try {
         guardSensitivePath(pkgJsonPath);
         const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-        if (!parsed.scripts || typeof parsed.scripts !== "object" || Array.isArray(parsed.scripts))
+        const scripts = parsed.scripts;
+        if (!scripts || typeof scripts !== "object" || Array.isArray(scripts))
             return {};
-        return Object.fromEntries(Object.entries(parsed.scripts).filter(([, value]) => typeof value === "string"));
+        return Object.fromEntries(Object.entries(scripts).filter(([, value]) => typeof value === "string"));
     }
     catch {
         return {};
@@ -370,8 +370,8 @@ function findHighRiskCommandEvidence(text) {
     return [...new Set(found)];
 }
 export function checkUnrecordedCommandExecution(testLogContent, resultMdContent, verifyCommands, testCommand, repoPath = null) {
-    const hasLog = testLogContent && testLogContent.length > 0;
-    const hasResult = resultMdContent && resultMdContent.length > 0;
+    const hasLog = !!testLogContent && testLogContent.length > 0;
+    const hasResult = !!resultMdContent && resultMdContent.length > 0;
     if (!hasLog && !hasResult)
         return null;
     const combined = `${testLogContent || ""}\n${resultMdContent || ""}`;
@@ -381,9 +381,9 @@ export function checkUnrecordedCommandExecution(testLogContent, resultMdContent,
     }
     const whitelist = buildCommandWhitelist(verifyCommands, testCommand, repoPath);
     const discovered = [];
-    if (hasLog)
+    if (hasLog && testLogContent)
         discovered.push(...extractCommands(testLogContent));
-    if (hasResult)
+    if (hasResult && resultMdContent)
         discovered.push(...extractCommands(resultMdContent));
     const unrecorded = new Set();
     for (const cmd of discovered) {
@@ -804,7 +804,11 @@ export function auditTask(taskId) {
                 return null;
             try {
                 const v = JSON.parse(readFileSync(verifyJsonFile, "utf-8"));
-                return v.status === "passed" ? "passed" : v.status === "failed" ? "failed" : "skipped";
+                if (v.status === "passed")
+                    return "passed";
+                if (v.status === "failed")
+                    return "failed";
+                return "skipped";
             }
             catch {
                 return null;

package/dist/tools/createDirectSession.d.ts

@@ -11,4 +11,4 @@ export interface CreateDirectSessionOutput {
     expires_at: string;
     next_action: string;
 }
-export declare function createDirectSession(input: CreateDirectSessionInput): CreateDirectSessionOutput;
+export declare function createDirectSession(input: CreateDirectSessionInput): Promise<CreateDirectSessionOutput>;

package/dist/tools/createDirectSession.js

@@ -6,7 +6,7 @@ import { guardRuntimeSelfModification } from "../security/runtimeGuard.js";
 import { captureRepoSnapshot } from "../runner/changeCapture.js";
 import { createDirectSession as createDirectSessionRecord, } from "../direct/directSessionStore.js";
 // ── Tool implementation ────────────────────────────────────────────
-export function createDirectSession(input) {
+export async function createDirectSession(input) {
     const config = getConfig();
     // ── Validate repo_path ───────────────────────────────────────────
     if (!input.repo_path || input.repo_path.trim() === "") {
@@ -33,7 +33,7 @@ export function createDirectSession(input) {
     // ── Runtime self-modification protection ─────────────────────────
     guardRuntimeSelfModification(resolvedRepoPath);
     // ── Capture repo snapshot ────────────────────────────────────────
-    const snapshot = captureRepoSnapshot(resolvedRepoPath);
+    const snapshot = await captureRepoSnapshot(resolvedRepoPath);
     // ── Create session record ────────────────────────────────────────
     const session = createDirectSessionRecord({
         repo_path: input.repo_path,