patchwarden 1.5.0 → 1.6.1

package/src/tools/{auditSession.ts → diagnostics/auditSession.ts}

@@ -1,8 +1,8 @@
 import {
   auditDirectSession,
   type DirectSessionAuditOutput,
-} from "../direct/directAudit.js";
-import { updateDirectSession } from "../direct/directSessionStore.js";
+} from "../../direct/directAudit.js";
+import { updateDirectSession } from "../../direct/directSessionStore.js";
 
 // ── Types ──────────────────────────────────────────────────────────
 

package/src/tools/{auditTask.ts → diagnostics/auditTask.ts}

@@ -1,5 +1,3 @@
-// @ts-nocheck
-
 interface AuditCheck {
   name: string;
   result: "pass" | "warn" | "fail";
@@ -33,13 +31,56 @@ export interface AuditTaskOutput {
   manual_verification_items: string[];
   recommended_next_actions: string[];
 }
-import { readFileSync, existsSync, writeFileSync, readdirSync, statSync } from "node:fs";
+import { readFileSync, existsSync, opendirSync, statSync } from "node:fs";
 import { join, resolve, relative, basename, sep, isAbsolute } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { guardSensitivePath, isSensitivePath } from "../security/sensitiveGuard.js";
-import { evaluateAcceptance } from "../goal/acceptanceEngine.js";
-import { renderAcceptanceMarkdown } from "../goal/acceptanceTemplate.js";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath, guardWorkspacePath } from "../../security/pathGuard.js";
+import { guardSensitivePath, isSensitivePath } from "../../security/sensitiveGuard.js";
+import { evaluateAcceptance } from "../../goal/acceptanceEngine.js";
+import { renderAcceptanceMarkdown } from "../../goal/acceptanceTemplate.js";
+import type { ChangedFile } from "../../runner/changeCapture.js";
+import { atomicWriteFileSync } from "../../utils/atomicFile.js";
+import { mutateTaskStatus } from "../../runner/taskStatusStore.js";
+import {
+  readTextFilePrefixSync,
+  readTextFileTailLinesSync,
+} from "../../utils/boundedFile.js";
+
+interface ExtractedCommand {
+  type: "npm-run" | "npm-bare" | "node" | "npx" | "python";
+  name: string;
+}
+
+interface TaskStatusData {
+  status?: string;
+  resolved_repo_path?: string;
+  repo_path?: string;
+  new_out_of_scope_changes?: Array<{ path: string; change: string }>;
+  out_of_scope_changes?: Array<{ path: string; change: string }>;
+  test_command?: string;
+  verify_commands?: string[];
+  forbidden?: string[];
+  done_evidence?: string[];
+  scope?: string[];
+  verification?: string[];
+  goal?: string;
+  artifact_status?: string;
+  acceptance_status?: string;
+  updated_at?: string;
+}
+
+interface ChangedFilesEvidence {
+  changed_files?: ChangedFile[];
+  artifact_hygiene?: {
+    counts?: {
+      tracked_build_artifacts?: number | string;
+      ignored_untracked_artifacts?: number | string;
+      runtime_generated_files?: number | string;
+      suspicious_changes?: number | string;
+    };
+  };
+}
+
 // Release claim patterns — anything that claims remote publish/release/deploy
 const RELEASE_PATTERNS = [
     /npm\s+package\s+version\s+published/i,
@@ -51,8 +92,12 @@ const RELEASE_PATTERNS = [
     /npm\s+publish\s+completed/i,
     /deploy(ed|ment)?\s+(to|on)\s+(npm|registry|github)/i,
 ];
-function scanForReleaseClaims(text) {
-    const found = [];
+const MAX_AUDIT_DOC_FILES = 200;
+const MAX_AUDIT_DOC_FILE_BYTES = 512 * 1024;
+const MAX_AUDIT_DOC_TOTAL_BYTES = 4 * 1024 * 1024;
+const MAX_AUDIT_EVIDENCE_BYTES = 1024 * 1024;
+function scanForReleaseClaims(text: string): string[] {
+    const found: string[] = [];
     for (const pattern of RELEASE_PATTERNS) {
         const match = text.match(pattern);
         if (match)
@@ -60,24 +105,50 @@ function scanForReleaseClaims(text) {
     }
     return found;
 }
-function findMdFiles(dir, maxDepth = 3) {
-    const results = [];
-    if (!existsSync(dir) || maxDepth <= 0)
-        return results;
-    try {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const e of entries) {
-            const full = join(dir, e.name);
-            if (e.isDirectory() && !e.name.startsWith(".") && e.name !== "node_modules") {
-                results.push(...findMdFiles(full, maxDepth - 1));
-            }
-            else if (e.isFile() && e.name.endsWith(".md")) {
-                results.push(full);
+function findMdFiles(
+    dir: string,
+    maxDepth = 3,
+    maxFiles = MAX_AUDIT_DOC_FILES,
+): { files: string[]; truncated: boolean } {
+    const results: string[] = [];
+    const pending = [{ path: dir, depth: maxDepth }];
+    const maxDirectories = maxFiles * 4;
+    let visitedDirectories = 0;
+    let truncated = false;
+    while (pending.length > 0 && results.length < maxFiles && visitedDirectories < maxDirectories) {
+        const current = pending.pop()!;
+        if (!existsSync(current.path) || current.depth <= 0) continue;
+        visitedDirectories += 1;
+        let handle;
+        try {
+            handle = opendirSync(current.path);
+            while (results.length < maxFiles) {
+                const entry = handle.readSync();
+                if (!entry) break;
+                const full = join(current.path, entry.name);
+                if (entry.isDirectory() && !entry.name.startsWith(".") && entry.name !== "node_modules") {
+                    if (pending.length < maxDirectories) pending.push({ path: full, depth: current.depth - 1 });
+                    else truncated = true;
+                } else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+                    results.push(full);
+                }
             }
-        }
+        } catch { /* skip unreadable dirs */ }
+        finally { try { handle?.closeSync(); } catch { /* best effort */ } }
     }
-    catch { /* skip unreadable dirs */ }
-    return results;
+    truncated ||= pending.length > 0 || results.length >= maxFiles || visitedDirectories >= maxDirectories;
+    return { files: results, truncated };
+}
+
+function readAuditEvidence(path: string): { content: string; truncated: boolean } {
+    const half = Math.floor(MAX_AUDIT_EVIDENCE_BYTES / 2);
+    const prefix = readTextFilePrefixSync(path, half);
+    if (!prefix.truncated) return { content: prefix.content, truncated: false };
+    const tail = readTextFileTailLinesSync(path, 1000, half);
+    return {
+        content: `${prefix.content}\n[...audit evidence truncated...]\n${tail}`,
+        truncated: true,
+    };
 }
 // ── v0.7.2: New audit checks (exported for testing) ────────────────
 /**
@@ -86,7 +157,7 @@ function findMdFiles(dir, maxDepth = 3) {
  * `*` matches a single path segment (no `/`).
  * Path separators in the pattern are expected to be `/`.
  */
-function globToRegExp(pattern) {
+function globToRegExp(pattern: string): RegExp {
     // Normalize backslashes to forward slashes for matching consistency.
     const normalized = pattern.replace(/\\/g, "/");
     let re = "^";
@@ -127,7 +198,7 @@ function globToRegExp(pattern) {
  * 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 function checkForbiddenScope(changedFiles, forbidden) {
+export function checkForbiddenScope(changedFiles: ChangedFile[], forbidden: string[] | null): AuditCheck | null {
     if (!forbidden || forbidden.length === 0)
         return null;
     if (changedFiles.length === 0) {
@@ -161,7 +232,7 @@ export function checkForbiddenScope(changedFiles, forbidden) {
  * Returns pass when all listed files exist in the task directory.
  * Returns warn when any listed file is missing.
  */
-export function checkDoneEvidenceMissing(taskDir, doneEvidence) {
+export function checkDoneEvidenceMissing(taskDir: string, doneEvidence: string[] | null): AuditCheck | null {
     if (!doneEvidence || doneEvidence.length === 0)
         return null;
     const missing = [];
@@ -189,7 +260,7 @@ const CODE_EXTENSIONS = new Set([
  * 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 function checkReadmeChangelogSync(changedFiles) {
+export function checkReadmeChangelogSync(changedFiles: ChangedFile[]): AuditCheck | null {
     const paths = changedFiles.map((f) => f.path);
     const hasCodeChange = paths.some((p) => {
         const lower = p.toLowerCase();
@@ -223,14 +294,14 @@ export function checkReadmeChangelogSync(changedFiles) {
  * Returns pass when package.json parses as JSON and has non-empty name and version strings.
  * Returns warn otherwise.
  */
-export function checkPackageManifestConsistency(changedFiles, repoPathSafe) {
+export function checkPackageManifestConsistency(changedFiles: ChangedFile[], repoPathSafe: string): AuditCheck | null {
     const includesPackageJson = changedFiles.some((f) => basename(f.path).toLowerCase() === "package.json");
     if (!includesPackageJson)
         return null;
     try {
         const pkgPath = join(repoPathSafe, "package.json");
         const raw = readFileSync(pkgPath, "utf-8");
-        const parsed = JSON.parse(raw);
+        const parsed = JSON.parse(raw) as { name?: unknown; version?: unknown };
         const hasName = typeof parsed.name === "string" && parsed.name.length > 0;
         const hasVersion = typeof parsed.version === "string" && parsed.version.length > 0;
         if (hasName && hasVersion) {
@@ -256,7 +327,7 @@ export function checkPackageManifestConsistency(changedFiles, repoPathSafe) {
  * Returns pass when no changed file path (or old_path) is sensitive.
  * Returns fail when any changed file path is flagged by isSensitivePath.
  */
-export function checkSensitivePathAccess(changedFiles) {
+export function checkSensitivePathAccess(changedFiles: ChangedFile[]): AuditCheck | null {
     if (changedFiles.length === 0)
         return null;
     const hits = [];
@@ -287,8 +358,8 @@ const HIGH_RISK_COMMAND_PATTERNS = [
     /\bRemove-Item\b[\s\S]{0,80}\b-Recurse\b/i,
     /\brm\s+-rf\b/i,
 ];
-function extractCommands(text) {
-    const found = [];
+function extractCommands(text: string): ExtractedCommand[] {
+    const found: ExtractedCommand[] = [];
     const runRe = /npm(?:\.cmd)?\s+run\s+([a-zA-Z0-9:_-]+)/gi;
     let m;
     while ((m = runRe.exec(text)) !== null) found.push({ type: "npm-run", name: m[1] });
@@ -302,31 +373,34 @@ function extractCommands(text) {
     while ((m = pythonRe.exec(text)) !== null) found.push({ type: "python", name: normalizeCommandName(m[1]) });
     return found;
 }
-function normalizeCommandName(value) {
+function normalizeCommandName(value: string): string {
     return value.replace(/\\/g, "/").replace(/^\.\//, "");
 }
-function commandKey(command) {
+function commandKey(command: ExtractedCommand): string {
     return command.name;
 }
-function readPackageScripts(repoPath) {
+function readPackageScripts(repoPath: string | null): Record<string, string> {
     if (!repoPath) return {};
     const pkgJsonPath = join(repoPath, "package.json");
     if (!existsSync(pkgJsonPath)) return {};
     try {
         guardSensitivePath(pkgJsonPath);
-        const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
-        if (!parsed.scripts || typeof parsed.scripts !== "object" || Array.isArray(parsed.scripts)) return {};
-        return Object.fromEntries(Object.entries(parsed.scripts).filter(([, value]) => typeof value === "string"));
+        const parsed = JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as { scripts?: Record<string, unknown> };
+        const scripts = parsed.scripts;
+        if (!scripts || typeof scripts !== "object" || Array.isArray(scripts)) return {};
+        return Object.fromEntries(
+            Object.entries(scripts).filter(([, value]) => typeof value === "string")
+        ) as Record<string, string>;
     }
     catch {
         return {};
     }
 }
-function buildCommandWhitelist(verifyCommands, testCommand, repoPath) {
+function buildCommandWhitelist(verifyCommands: string[], testCommand: string | null, repoPath: string | null): { allowed: Set<string>; transitive: Set<string> } {
     const scripts = readPackageScripts(repoPath);
-    const allowed = new Set();
-    const transitive = new Set();
-    const queue = [];
+    const allowed = new Set<string>();
+    const transitive = new Set<string>();
+    const queue: Array<{ command: ExtractedCommand; depth: number }> = [];
     const sources = [...verifyCommands];
     if (testCommand) sources.push(testCommand);
     for (const src of sources) {
@@ -336,9 +410,9 @@ function buildCommandWhitelist(verifyCommands, testCommand, repoPath) {
         }
     }
     let inspectedFiles = 0;
-    const seen = new Set();
+    const seen = new Set<string>();
     while (queue.length > 0) {
-        const { command, depth } = queue.shift();
+        const { command, depth } = queue.shift()!;
         if (depth > 4) continue;
         const key = `${command.type}:${command.name}`;
         if (seen.has(key)) continue;
@@ -365,7 +439,7 @@ function buildCommandWhitelist(verifyCommands, testCommand, repoPath) {
     }
     return { allowed, transitive };
 }
-function readLocalScript(repoPath, scriptPath) {
+function readLocalScript(repoPath: string, scriptPath: string): string | null {
     const resolvedRepo = resolve(repoPath);
     const resolvedScript = resolve(resolvedRepo, scriptPath);
     const rel = relative(resolvedRepo, resolvedScript);
@@ -380,17 +454,17 @@ function readLocalScript(repoPath, scriptPath) {
         return null;
     }
 }
-function findHighRiskCommandEvidence(text) {
-    const found = [];
+function findHighRiskCommandEvidence(text: string): string[] {
+    const found: string[] = [];
     for (const pattern of HIGH_RISK_COMMAND_PATTERNS) {
         const match = text.match(pattern);
         if (match) found.push(match[0]);
     }
     return [...new Set(found)];
 }
-export function checkUnrecordedCommandExecution(testLogContent: string | null, resultMdContent: string | null, verifyCommands: string[], testCommand: string | null, repoPath: string | null = null) {
-    const hasLog = testLogContent && testLogContent.length > 0;
-    const hasResult = resultMdContent && resultMdContent.length > 0;
+export function checkUnrecordedCommandExecution(testLogContent: string | null, resultMdContent: string | null, verifyCommands: string[], testCommand: string | null, repoPath: string | null = null): AuditCheck | null {
+    const hasLog = !!testLogContent && testLogContent.length > 0;
+    const hasResult = !!resultMdContent && resultMdContent.length > 0;
     if (!hasLog && !hasResult) return null;
     const combined = `${testLogContent || ""}\n${resultMdContent || ""}`;
     const highRisk = findHighRiskCommandEvidence(combined);
@@ -398,10 +472,10 @@ export function checkUnrecordedCommandExecution(testLogContent: string | null, r
         return { name: "unrecorded_command_execution", result: "fail", detail: `High-risk command evidence: ${highRisk.join(", ")}` };
     }
     const whitelist = buildCommandWhitelist(verifyCommands, testCommand, repoPath);
-    const discovered = [];
-    if (hasLog) discovered.push(...extractCommands(testLogContent));
-    if (hasResult) discovered.push(...extractCommands(resultMdContent));
-    const unrecorded = new Set();
+    const discovered: ExtractedCommand[] = [];
+    if (hasLog && testLogContent) discovered.push(...extractCommands(testLogContent));
+    if (hasResult && resultMdContent) discovered.push(...extractCommands(resultMdContent));
+    const unrecorded = new Set<string>();
     for (const cmd of discovered) {
         if (!whitelist.allowed.has(commandKey(cmd))) unrecorded.add(commandKey(cmd));
     }
@@ -415,7 +489,7 @@ export function checkUnrecordedCommandExecution(testLogContent: string | null, r
         detail: transitive.length > 0 ? `All commands are whitelisted; transitive_verified_command: ${transitive.join(", ")}` : "All commands in whitelist.",
     };
 }
-export function auditTask(taskId) {
+export function auditTask(taskId: string): AuditTaskOutput {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
     const taskDir = join(tasksDir, taskId);
@@ -424,17 +498,17 @@ export function auditTask(taskId) {
     if (!existsSync(statusFile)) {
         throw new Error(`Task not found: "${taskId}"`);
     }
-    const statusData = JSON.parse(readFileSync(statusFile, "utf-8"));
-    const checks = [];
-    const risks = [];
-    const actions = [];
-    const possibleFalsePositives = [];
-    const manualVerificationItems = [];
-    const addManualVerification = (item) => {
+    const statusData = JSON.parse(readFileSync(statusFile, "utf-8")) as TaskStatusData;
+    const checks: AuditCheck[] = [];
+    const risks: AuditRisk[] = [];
+    const actions: string[] = [];
+    const possibleFalsePositives: Array<{ check: string; reason: string }> = [];
+    const manualVerificationItems: string[] = [];
+    const addManualVerification = (item: string) => {
         if (!manualVerificationItems.includes(item))
             manualVerificationItems.push(item);
     };
-    const addPossibleFalsePositive = (check, reason) => {
+    const addPossibleFalsePositive = (check: string, reason: string) => {
         if (!possibleFalsePositives.some((item) => item.check === check && item.reason === reason)) {
             possibleFalsePositives.push({ check, reason });
         }
@@ -478,7 +552,7 @@ export function auditTask(taskId) {
     }
     if (existsSync(verifyJsonFile)) {
         try {
-            const verify = JSON.parse(readFileSync(verifyJsonFile, "utf-8"));
+            const verify = JSON.parse(readFileSync(verifyJsonFile, "utf-8")) as { status?: string };
             checks.push({
                 name: "verify_status",
                 result: verify.status === "passed" ? "pass" : verify.status === "failed" ? "fail" : "warn",
@@ -504,11 +578,11 @@ export function auditTask(taskId) {
             : "No new out-of-scope changes recorded.",
     });
     // Extract changed_files from change evidence (used by several v0.7.2 checks).
-    let changedFiles = [];
+    let changedFiles: ChangedFile[] = [];
     const changedFilesFile = join(taskDir, "changed-files.json");
     if (existsSync(changedFilesFile)) {
         try {
-            const changeEvidence = JSON.parse(readFileSync(changedFilesFile, "utf-8"));
+            const changeEvidence = JSON.parse(readFileSync(changedFilesFile, "utf-8")) as ChangedFilesEvidence;
             if (Array.isArray(changeEvidence.changed_files)) {
                 changedFiles = changeEvidence.changed_files;
             }
@@ -596,11 +670,11 @@ export function auditTask(taskId) {
         risks.push({ severity: "high", description: "repo_path inconsistent with workspace." });
     // ── 6. package.json scripts ──
     const pkgJsonPath = join(repoPathSafe, "package.json");
-    let pkgScripts = [];
+    let pkgScripts: string[] = [];
     if (existsSync(pkgJsonPath)) {
         try {
             guardSensitivePath(pkgJsonPath);
-            const pkgData = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+            const pkgData = JSON.parse(readFileSync(pkgJsonPath, "utf-8")) as { scripts?: Record<string, unknown> };
             pkgScripts = Object.keys(pkgData.scripts || {});
             checks.push({
                 name: "package_json_scripts",
@@ -621,20 +695,35 @@ export function auditTask(taskId) {
     if (existsSync(readmePath))
         docsToScan.push(readmePath);
     const docsDir = join(repoPathSafe, "docs");
+    let markdownEnumerationTruncated = false;
     if (existsSync(docsDir)) {
-        docsToScan.push(...findMdFiles(docsDir));
+        const markdown = findMdFiles(docsDir);
+        docsToScan.push(...markdown.files);
+        markdownEnumerationTruncated = markdown.truncated;
     }
     // Collect all npm run references from all docs
-    const allNpmRunRefs = new Set();
-    const allReleaseClaims = [];
+    const allNpmRunRefs = new Set<string>();
+    const allReleaseClaims: string[] = [];
+    let remainingDocBytes = MAX_AUDIT_DOC_TOTAL_BYTES;
+    let documentScanTruncated = markdownEnumerationTruncated || docsToScan.length > MAX_AUDIT_DOC_FILES;
     for (const docPath of docsToScan) {
-        let content;
+        if (remainingDocBytes <= 0) {
+            documentScanTruncated = true;
+            break;
+        }
+        let content: string;
         try {
             if (docPath !== resultFile) {
                 guardReadPath(docPath, config.workspaceRoot);
                 guardSensitivePath(docPath);
             }
-            content = readFileSync(docPath, "utf-8");
+            const bounded = readTextFilePrefixSync(
+                docPath,
+                Math.min(MAX_AUDIT_DOC_FILE_BYTES, remainingDocBytes),
+            );
+            content = bounded.content;
+            remainingDocBytes -= Buffer.byteLength(content, "utf-8");
+            documentScanTruncated ||= bounded.truncated;
         }
         catch {
             continue;
@@ -651,6 +740,14 @@ export function auditTask(taskId) {
         for (const c of claims)
             allReleaseClaims.push(`[${relative(repoPathSafe, docPath) || docPath}] ${c}`);
     }
+    if (documentScanTruncated) {
+        checks.push({
+            name: "documentation_scan_bounded",
+            result: "warn",
+            detail: `Documentation scan reached its ${MAX_AUDIT_DOC_FILES}-file or ${MAX_AUDIT_DOC_TOTAL_BYTES}-byte safety budget.`,
+        });
+        addManualVerification("Review documentation omitted by the bounded audit scan.");
+    }
     // Cross-check npm run refs against package.json scripts
     for (const scriptName of allNpmRunRefs) {
         if (pkgScripts.length > 0 && !pkgScripts.includes(scriptName)) {
@@ -693,11 +790,13 @@ export function auditTask(taskId) {
         addManualVerification("Verify remote npm, GitHub Release, and Git tag claims against authoritative remote services.");
     }
     // ── 9. test.log Exit code check ──
-    let testLogContent = null;
+    let testLogContent: string | null = null;
     if (hasTestLog) {
-        let logContent;
+        let logContent: string;
         try {
-            logContent = readFileSync(testLogFile, "utf-8");
+            const evidence = readAuditEvidence(testLogFile);
+            logContent = evidence.content;
+            if (evidence.truncated) addManualVerification("test.log exceeded the audit read budget; inspect the complete local artifact.");
         }
         catch {
             logContent = "";
@@ -732,10 +831,12 @@ export function auditTask(taskId) {
     }
     // ── v0.7.2: New audit checks ──
     // Read result.md content (guarded) for the unrecorded_command_execution check.
-    let resultMdContent = null;
+    let resultMdContent: string | null = null;
     if (hasResult) {
         try {
-            resultMdContent = readFileSync(resultFile, "utf-8");
+            const evidence = readAuditEvidence(resultFile);
+            resultMdContent = evidence.content;
+            if (evidence.truncated) addManualVerification("result.md exceeded the audit read budget; inspect the complete local artifact.");
         }
         catch {
             resultMdContent = null;
@@ -803,7 +904,7 @@ export function auditTask(taskId) {
         "## Recommended Actions",
         ...actions.map((a) => `- ${a}`),
     ].join("\n");
-    writeFileSync(join(taskDir, "independent-review.md"), reviewMd, "utf-8");
+    atomicWriteFileSync(join(taskDir, "independent-review.md"), reviewMd);
     // ── v0.7.2: 集成 acceptanceEngine ──
     const releaseClaimsUnverified = allReleaseClaims.length > 0;
     const acceptanceEvidence = {
@@ -818,8 +919,10 @@ export function auditTask(taskId) {
             if (!existsSync(verifyJsonFile))
                 return null;
             try {
-                const v = JSON.parse(readFileSync(verifyJsonFile, "utf-8"));
-                return v.status === "passed" ? "passed" : v.status === "failed" ? "failed" : "skipped";
+                const v = JSON.parse(readFileSync(verifyJsonFile, "utf-8")) as { status?: string };
+                if (v.status === "passed") return "passed" as const;
+                if (v.status === "failed") return "failed" as const;
+                return "skipped" as const;
             }
             catch {
                 return null;
@@ -838,16 +941,20 @@ export function auditTask(taskId) {
     const acceptanceResult = evaluateAcceptance(acceptanceEvidence);
     // 回写 status.json 的 acceptance_status（仅对 done_by_agent 有意义）
     if (taskStatus === "done_by_agent") {
-        const updatedStatus = {
-            ...statusData,
+        const statusPatch = {
             acceptance_status: acceptanceResult.acceptance_status,
-            updated_at: new Date().toISOString(),
         };
-        writeFileSync(statusFile, JSON.stringify(updatedStatus, null, 2), "utf-8");
+        mutateTaskStatus(statusFile, (current) => {
+            if (current.status !== "done_by_agent") {
+                return { result: current };
+            }
+            const next = { ...current, ...statusPatch, updated_at: new Date().toISOString() };
+            return { next, result: next };
+        });
     }
     // 导出 ACCEPTANCE.md
     const acceptanceMd = renderAcceptanceMarkdown(taskId, acceptanceResult, acceptanceEvidence);
-    writeFileSync(join(taskDir, "ACCEPTANCE.md"), acceptanceMd, "utf-8");
+    atomicWriteFileSync(join(taskDir, "ACCEPTANCE.md"), acceptanceMd);
     return {
         task_id: taskId,
         verdict,

package/src/tools/{healthCheck.ts → diagnostics/healthCheck.ts}

@@ -1,14 +1,14 @@
 import { accessSync, constants, existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
-import { getConfig, getTasksDir, getDirectSessionsDir, resolveWorkspaceRoot } from "../config.js";
-import { listAgents } from "./listAgents.js";
-import { redactSensitiveContent, redactSensitiveValue } from "../security/contentRedaction.js";
-import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
-import type { ToolCatalogSnapshot } from "./toolCatalog.js";
-import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES, CHATGPT_SEARCH_TOOL_NAMES, resolveToolProfile } from "./toolCatalog.js";
-import { readWatcherStatus } from "../watcherStatus.js";
-import { listTasks } from "./listTasks.js";
+import { getConfig, getTasksDir, getDirectSessionsDir, resolveWorkspaceRoot } from "../../config.js";
+import { listAgents } from "../workspace/listAgents.js";
+import { redactSensitiveContent, redactSensitiveValue } from "../../security/contentRedaction.js";
+import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../../version.js";
+import type { ToolCatalogSnapshot } from "../catalog/toolCatalog.js";
+import { CHATGPT_CORE_TOOL_NAMES, CHATGPT_DIRECT_TOOL_NAMES, CHATGPT_SEARCH_TOOL_NAMES, resolveToolProfile } from "../catalog/toolCatalog.js";
+import { readWatcherStatus } from "../../watcherStatus.js";
+import { listTasks } from "../tasks/listTasks.js";
 
 const SERVER_STARTED_AT = Date.now();
 
@@ -195,14 +195,14 @@ function directoryStatus(path: string, allowCreatable: boolean, createRoot?: str
       try {
         accessSync(parent, constants.R_OK | constants.W_OK);
         return { available: true, path, readable: false, writable: true, reason: "Directory will be created on first use." };
-      } catch {}
+      } catch {} // probe failure handled by return value
     }
     return { available: false, path, readable: false, writable: false, reason: "Directory does not exist." };
   }
   let readable = false;
   let writable = false;
-  try { accessSync(path, constants.R_OK); readable = true; } catch {}
-  try { accessSync(path, constants.W_OK); writable = true; } catch {}
+  try { accessSync(path, constants.R_OK); readable = true; } catch {} // probe failure handled by return value
+  try { accessSync(path, constants.W_OK); writable = true; } catch {} // probe failure handled by return value
   return {
     available: readable && writable,
     path,

package/src/tools/diagnostics/index.ts

@@ -0,0 +1,6 @@
+export * from "./auditSession.js";
+export * from "./auditTask.js";
+export * from "./healthCheck.js";
+export * from "./safeStatus.js";
+export * from "./safeViews.js";
+export * from "./schemaDriftCheck.js";

package/src/tools/{safeStatus.ts → diagnostics/safeStatus.ts}

@@ -1,12 +1,12 @@
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
-import { getTasksDir, getConfig, type PatchWardenConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import type { TaskStatus, TaskPhase, AcceptanceStatus } from "./createTask.js";
-import { readTaskRuntime } from "../taskRuntime.js";
-import { readWatcherStatus } from "../watcherStatus.js";
-import { diagnoseTask, type DiagnosisType, type DiagnosisConfidence } from "./diagnoseTask.js";
+import { getTasksDir, getConfig, type PatchWardenConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+import type { TaskStatus, TaskPhase, AcceptanceStatus } from "../tasks/createTask.js";
+import { readTaskRuntime } from "../../runner/taskRuntime.js";
+import { readWatcherStatus } from "../../watcherStatus.js";
+import { diagnoseTask, type DiagnosisType, type DiagnosisConfidence } from "../tasks/diagnoseTask.js";
 
 export interface SafeStatusOutput {
   task_id: string;