patchwarden 1.5.1 → 1.6.1

package/dist/tools/{checkReleaseGate.d.ts → release/checkReleaseGate.d.ts}

@@ -1,4 +1,4 @@
-import { type ReleaseStage } from "../release/releaseGate.js";
+import { type ReleaseStage } from "../../release/releaseGate.js";
 export interface CheckReleaseGateInput {
     repo_path: string;
     target_stage: ReleaseStage;

package/dist/tools/{checkReleaseGate.js → release/checkReleaseGate.js}

@@ -1,6 +1,6 @@
-import { getConfig } from "../config.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
-import { runReleaseGateCheck, } from "../release/releaseGate.js";
+import { getConfig } from "../../config.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { runReleaseGateCheck, } from "../../release/releaseGate.js";
 /**
  * MCP tool handler for the release gate.
  *

package/dist/tools/release/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./checkReleaseGate.js";
+export * from "./releaseMode.js";

package/dist/tools/release/index.js

@@ -0,0 +1,2 @@
+export * from "./checkReleaseGate.js";
+export * from "./releaseMode.js";

package/dist/tools/{releaseMode.d.ts → release/releaseMode.d.ts}

@@ -1,5 +1,5 @@
-import { type ReleaseStage } from "../release/releaseGate.js";
-import { type ProjectPolicySummary } from "../policy/projectPolicy.js";
+import { type ReleaseStage } from "../../release/releaseGate.js";
+import { type ProjectPolicySummary } from "../../policy/projectPolicy.js";
 export interface ReleaseCheckInput {
     repo_path: string;
     target_stage?: ReleaseStage;

package/dist/tools/{releaseMode.js → release/releaseMode.js}

@@ -1,11 +1,14 @@
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { join, relative, resolve, sep, isAbsolute } from "node:path";
-import { getConfig } from "../config.js";
-import { checkCiVerified, checkGitHubReleaseVerified, checkPublishedVerified, runReleaseGateCheck, } from "../release/releaseGate.js";
-import { guardTestCommand } from "../security/commandGuard.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
-import { commandAllowedByProjectPolicy, getProjectPolicySummary, isProtectedByProjectPolicy, readPackageJson, resolveVersionFromPolicy, } from "../policy/projectPolicy.js";
+import { getConfig } from "../../config.js";
+import { checkCiVerified, checkGitHubReleaseVerified, checkPublishedVerified, runReleaseGateCheck, } from "../../release/releaseGate.js";
+import { guardTestCommand } from "../../security/commandGuard.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { resolveTrustedCommandLine, buildGitEnvironment, resolveTrustedExecutable } from "../../runner/processSecurity.js";
+import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
+import { runSimpleProcessSync } from "../../runner/simpleProcess.js";
+import { commandAllowedByProjectPolicy, getProjectPolicySummary, isProtectedByProjectPolicy, readPackageJson, resolveVersionFromPolicy, } from "../../policy/projectPolicy.js";
 const LOCAL_TIMEOUT_MS = 300000;
 const CLEANUP_REPORT_DIR = ".patchwarden/release-cleanup";
 export function getProjectPolicyTool(repoPath) {
@@ -75,12 +78,21 @@ export function releasePrepare(input) {
             continue;
         }
         try {
-            execSync(command, {
+            const invocation = resolveTrustedCommandLine(command, repoPath);
+            const execution = runSimpleProcessSync({
+                command: invocation.command,
+                args: invocation.argsPrefix,
                 cwd: repoPath,
-                encoding: "utf-8",
-                timeout: timeoutMs,
-                stdio: ["ignore", "pipe", "pipe"],
+                timeoutMs,
             });
+            if (execution.spawnError)
+                throw new Error(execution.spawnError);
+            if (execution.timedOut)
+                throw new Error(`Command timed out after ${timeoutMs}ms`);
+            if (execution.exitCode !== 0) {
+                const status = execution.exitCode ?? -1;
+                throw Object.assign(new Error(`Command exited with code ${status}`), { status });
+            }
             results.push({ command, status: "passed", exit_code: 0, reason: null });
         }
         catch (err) {
@@ -204,7 +216,7 @@ export function releaseCleanup(input) {
     const reportDir = join(repoPath, CLEANUP_REPORT_DIR);
     mkdirSync(reportDir, { recursive: true });
     const reportPath = join(reportDir, `${report.generated_at.replace(/[-:.TZ]/g, "").slice(0, 14)}.json`);
-    writeFileSync(reportPath, JSON.stringify(report, null, 2) + "\n", "utf-8");
+    atomicWriteJsonFileSync(reportPath, report);
     return {
         ok: skipped.length === 0 || dryRun,
         mode: "release_cleanup",
@@ -297,10 +309,12 @@ function isTrackedByGit(root, relPath) {
     if (!isGitWorktree(root))
         return false;
     try {
-        execFileSync("git", ["ls-files", "--error-unmatch", "--", relPath], {
+        const env = buildGitEnvironment(root);
+        execFileSync(resolveTrustedExecutable("git", root, { pathValue: env.PATH }), ["ls-files", "--error-unmatch", "--", relPath], {
             cwd: root,
             stdio: "ignore",
             windowsHide: true,
+            env,
         });
         return true;
     }
@@ -312,33 +326,39 @@ function isIgnoredOrUntracked(root, relPath) {
     if (!isGitWorktree(root))
         return true;
     try {
-        execFileSync("git", ["check-ignore", "-q", "--", relPath], {
-            cwd: root,
-            stdio: "ignore",
-            windowsHide: true,
-        });
-        return true;
-    }
-    catch {
+        const env = buildGitEnvironment(root);
+        const git = resolveTrustedExecutable("git", root, { pathValue: env.PATH });
         try {
-            const output = execFileSync("git", ["ls-files", "--others", "--exclude-standard", "--", relPath], {
+            execFileSync(git, ["check-ignore", "-q", "--", relPath], {
                 cwd: root,
-                encoding: "utf-8",
+                stdio: "ignore",
                 windowsHide: true,
+                env,
             });
-            return output.trim().split(/\r?\n/).filter(Boolean).includes(relPath);
+            return true;
         }
         catch {
-            return false;
+            const output = execFileSync(git, ["ls-files", "--others", "--exclude-standard", "--", relPath], {
+                cwd: root,
+                encoding: "utf-8",
+                windowsHide: true,
+                env,
+            });
+            return output.trim().split(/\r?\n/).filter(Boolean).includes(relPath);
         }
     }
+    catch {
+        return false;
+    }
 }
 function isGitWorktree(root) {
     try {
-        return execFileSync("git", ["rev-parse", "--is-inside-work-tree"], {
+        const env = buildGitEnvironment(root);
+        return execFileSync(resolveTrustedExecutable("git", root, { pathValue: env.PATH }), ["rev-parse", "--is-inside-work-tree"], {
             cwd: root,
             encoding: "utf-8",
             windowsHide: true,
+            env,
         }).trim() === "true";
     }
     catch {

package/dist/tools/tasks/cancelTask.d.ts

@@ -0,0 +1,11 @@
+import type { TaskStatus } from "./createTask.js";
+export interface TaskTerminationResponse {
+    task_id: string;
+    previous_status: TaskStatus;
+    new_status: TaskStatus;
+    message: string;
+    cancel_requested?: boolean;
+    force_kill_requested?: boolean;
+}
+export declare function cancelTask(taskId: string): TaskTerminationResponse;
+export declare function requestTaskTermination(taskId: string, force: boolean): TaskTerminationResponse;

package/dist/tools/tasks/cancelTask.js

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

package/dist/tools/{createTask.d.ts → tasks/createTask.d.ts}

@@ -1,5 +1,5 @@
-import { type ChangePolicy, type TaskTemplateName } from "./taskTemplates.js";
-import { type PendingReason, type WatcherStatusSnapshot } from "../watcherStatus.js";
+import { type ChangePolicy, type TaskTemplateName } from "../taskTemplates.js";
+import { type PendingReason, type WatcherStatusSnapshot } from "../../watcherStatus.js";
 export type TaskStatus = "pending" | "running" | "collecting_artifacts" | "done_by_agent" | "accepted" | "rejected" | "needs_fix" | "blocked" | "done" | "failed" | "failed_verification" | "failed_scope_violation" | "failed_policy_violation" | "failed_stale" | "orphaned" | "canceled";
 /**
  * v0.7.2 acceptance status — only meaningful for done_by_agent.
@@ -32,6 +32,14 @@ export interface CreateTaskInput {
     done_evidence?: string[];
     goal_id?: string;
     subgoal_id?: string;
+    /** Internal provenance supplied by retry_task; not exposed in MCP schemas. */
+    retry_metadata?: {
+        retry_of: string;
+        retry_count: number;
+        plan_source: "saved" | "inline" | "template";
+        template: string | null;
+        change_policy: ChangePolicy;
+    };
 }
 export interface AssessOnlyOutput {
     assessment_id: string;

package/dist/tools/{createTask.js → tasks/createTask.js}

@@ -1,23 +1,25 @@
-import { mkdirSync, writeFileSync, existsSync, statSync, readFileSync } from "node:fs";
+import { mkdirSync, existsSync, statSync, readFileSync } from "node:fs";
 import { randomBytes } from "node:crypto";
 import { resolve, join } from "node:path";
-import { getTasksDir, getPlansDir, getConfig } from "../config.js";
-import { guardPath, guardWorkspacePath, guardReadPath } from "../security/pathGuard.js";
-import { guardTestCommand } from "../security/commandGuard.js";
-import { guardRuntimeSelfModification } from "../security/runtimeGuard.js";
-import { guardPlanContent } from "../security/planGuard.js";
-import { assessRisk } from "../security/riskEngine.js";
-import { createAssessment, readAssessment, validateAssessmentFreshness, generateAssessmentId, createAssessmentDir, } from "../assessments/assessmentStore.js";
-import { runAgentAssessment } from "../assessments/agentAssessor.js";
-import { captureRepoSnapshot } from "../runner/changeCapture.js";
-import { writeTaskProgress } from "../taskProgress.js";
-import { PatchWardenError } from "../errors.js";
-import { savePlan } from "./savePlan.js";
-import { expandTaskTemplate, TASK_TEMPLATE_NAMES, } from "./taskTemplates.js";
-import { PATCHWARDEN_VERSION } from "../version.js";
-import { getLastToolCatalogSnapshot, resolveToolProfile } from "./toolCatalog.js";
-import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
-import { routeAgent } from "../agents/agentRouter.js";
+import { getTasksDir, getPlansDir, getConfig } from "../../config.js";
+import { guardPath, guardWorkspacePath, guardReadPath } from "../../security/pathGuard.js";
+import { guardTestCommand } from "../../security/commandGuard.js";
+import { guardRuntimeSelfModification } from "../../security/runtimeGuard.js";
+import { guardPlanContent } from "../../security/planGuard.js";
+import { assessRisk } from "../../security/riskEngine.js";
+import { createAssessment, readAssessment, validateAssessmentFreshness, generateAssessmentId, createAssessmentDir, } from "../../assessments/assessmentStore.js";
+import { runAgentAssessment } from "../../assessments/agentAssessor.js";
+import { captureRepoSnapshot } from "../../runner/changeCapture.js";
+import { writeTaskProgress } from "../../runner/taskProgress.js";
+import { PatchWardenError } from "../../errors.js";
+import { savePlan } from "../goals/savePlan.js";
+import { expandTaskTemplate, TASK_TEMPLATE_NAMES, } from "../taskTemplates.js";
+import { PATCHWARDEN_VERSION, ARTIFACT_SCHEMA_VERSION } from "../../version.js";
+import { getLastToolCatalogSnapshot, resolveToolProfile } from "../catalog/toolCatalog.js";
+import { derivePendingReason, readWatcherStatus, } from "../../watcherStatus.js";
+import { routeAgent } from "../../agents/agentRouter.js";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 export async function createTask(input) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -339,12 +341,25 @@ export async function createTask(input) {
     const { taskId, taskDir } = createTaskDirectory(tasksDir, config.workspaceRoot, config.tasksDir);
     const status = "pending";
     const statusFile = join(taskDir, "status.json");
+    const retryMetadata = effectiveInput.retry_metadata;
+    const safeAcceptance = redactSensitiveValue({
+        goal: effectiveInput.goal || null,
+        scope: effectiveInput.scope ?? null,
+        forbidden: effectiveInput.forbidden ?? null,
+        verification: effectiveInput.verification ?? null,
+        done_evidence: effectiveInput.done_evidence ?? null,
+    }).value;
     const statusData = {
+        schema_version: ARTIFACT_SCHEMA_VERSION,
         task_id: taskId,
         plan_id: planId,
-        plan_source: planSource,
-        template: effectiveInput.template || null,
-        change_policy: changePolicy,
+        plan_source: retryMetadata?.plan_source ?? planSource,
+        template: retryMetadata?.template ?? effectiveInput.template ?? null,
+        change_policy: retryMetadata?.change_policy ?? changePolicy,
+        ...(retryMetadata ? {
+            retry_of: retryMetadata.retry_of,
+            retry_count: retryMetadata.retry_count,
+        } : {}),
         agent: effectiveInput.agent,
         workspace_root: resolve(config.workspaceRoot),
         repo_path: resolvedRepoPath,
@@ -361,11 +376,11 @@ export async function createTask(input) {
         current_command: null,
         error: null,
         // v0.7.2: 验收标准绑定到任务创建
-        goal: effectiveInput.goal || null,
-        scope: effectiveInput.scope ?? null,
-        forbidden: effectiveInput.forbidden ?? null,
-        verification: effectiveInput.verification ?? null,
-        done_evidence: effectiveInput.done_evidence ?? null,
+        goal: safeAcceptance.goal,
+        scope: safeAcceptance.scope,
+        forbidden: safeAcceptance.forbidden,
+        verification: safeAcceptance.verification,
+        done_evidence: safeAcceptance.done_evidence,
         acceptance_status: null,
         // v0.8.0: Goal Session 关联
         goal_id: effectiveInput.goal_id ?? null,
@@ -373,7 +388,7 @@ export async function createTask(input) {
         // v1.0.0: Agent routing decision (only present when agent was auto-routed)
         ...(agentSelectionReason ? { agent_selection_reason: agentSelectionReason } : {}),
     };
-    writeFileSync(statusFile, JSON.stringify(statusData, null, 2), "utf-8");
+    atomicWriteJsonFileSync(statusFile, statusData);
     writeTaskProgress(taskDir, "queued", {
         heartbeatAt: statusData.last_heartbeat_at,
         note: `Waiting for watcher. Timeout: ${timeoutSeconds} seconds.`,

package/dist/tools/{diagnoseTask.d.ts → tasks/diagnoseTask.d.ts}

@@ -1,4 +1,4 @@
-import { type PatchWardenConfig } from "../config.js";
+import { type PatchWardenConfig } from "../../config.js";
 export type DiagnosisType = "active_running" | "stale_running" | "possibly_stale_running" | "orphaned_running" | "artifact_collection_stuck" | "done_candidate" | "unknown" | "terminal";
 export type DiagnosisConfidence = "high" | "medium" | "low";
 export type SafeAction = "leave_unchanged" | "mark_failed_stale" | "mark_orphaned" | "mark_done_by_agent" | "collect_artifacts" | "recollect_artifacts" | "needs_fix";

package/dist/tools/{diagnoseTask.js → tasks/diagnoseTask.js}

@@ -1,11 +1,12 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { redactSensitiveContent } from "../security/contentRedaction.js";
-import { readTaskRuntime } from "../taskRuntime.js";
-import { isWatcherOwningTask, readWatcherInstanceId } from "../watcherStatus.js";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
+import { readTextFileTailLinesSync } from "../../utils/boundedFile.js";
+import { readTaskRuntime } from "../../runner/taskRuntime.js";
+import { isWatcherOwningTask, readWatcherInstanceId } from "../../watcherStatus.js";
 // ── Thresholds (seconds) ──────────────────────────────────────────
 //
 // These are intentionally conservative. A task is only "stale" when multiple
@@ -55,8 +56,7 @@ function readTailLines(filePath, lines) {
     if (!existsSync(filePath))
         return null;
     try {
-        const raw = readFileSync(filePath, "utf-8");
-        const tail = raw.split("\n").slice(-lines).join("\n");
+        const tail = readTextFileTailLinesSync(filePath, lines, 512 * 1024);
         return redactSensitiveContent(tail).content;
     }
     catch {

package/dist/tools/{evidencePack.js → tasks/evidencePack.js}

@@ -1,14 +1,16 @@
-import { execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getConfig } from "../config.js";
-import { guardReadPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { countRedactionsByCategory, redactSensitiveValue } from "../security/contentRedaction.js";
-import { getProjectPolicySummary } from "../policy/projectPolicy.js";
+import { getConfig } from "../../config.js";
+import { guardReadPath, guardWorkspacePath } from "../../security/pathGuard.js";
+import { countRedactionsByCategory, redactSensitiveValue } from "../../security/contentRedaction.js";
+import { getProjectPolicySummary } from "../../policy/projectPolicy.js";
 import { getTaskLineage } from "./taskLineage.js";
-import { getLastToolCatalogSnapshot } from "./toolCatalog.js";
-import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../version.js";
-import { PatchWardenError } from "../errors.js";
+import { getLastToolCatalogSnapshot } from "../catalog/toolCatalog.js";
+import { PATCHWARDEN_VERSION, TOOL_SCHEMA_EPOCH } from "../../version.js";
+import { PatchWardenError } from "../../errors.js";
+import { buildGitEnvironment, resolveTrustedExecutable } from "../../runner/processSecurity.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 export function exportTaskEvidencePack(input) {
     const lineageId = normalizeLineageId(input.lineage_id);
     const maxItems = normalizeMaxItems(input.max_items);
@@ -35,7 +37,7 @@ export function exportTaskEvidencePack(input) {
     const verifyContent = buildVerifyContent(lineage);
     const diffstatContent = buildDiffstatContent(lineage, config);
     const lineageSummary = buildLineageSummary(lineage);
-    const attestationContent = buildAttestation(catalog, generatedAt);
+    const attestationContent = buildAttestation(catalog, generatedAt, lineage.repo_path, config.workspaceRoot);
     // Count redactions across all v2 raw contents for the audit trail.
     const v2RawPayloads = [
         riskContent,
@@ -62,12 +64,12 @@ export function exportTaskEvidencePack(input) {
         note: "Only categories and counts are recorded; original secret values are never persisted.",
     };
     // Redact and write each v2 file.
-    writeFileSync(filePaths.risk, JSON.stringify(redactSensitiveValue(riskContent).value, null, 2) + "\n", "utf-8");
-    writeFileSync(filePaths.verify, JSON.stringify(redactSensitiveValue(verifyContent).value, null, 2) + "\n", "utf-8");
-    writeFileSync(filePaths.diffstat, JSON.stringify(redactSensitiveValue(diffstatContent).value, null, 2) + "\n", "utf-8");
-    writeFileSync(filePaths.lineage, JSON.stringify(redactSensitiveValue(lineageSummary).value, null, 2) + "\n", "utf-8");
-    writeFileSync(filePaths.attestation, JSON.stringify(redactSensitiveValue(attestationContent).value, null, 2) + "\n", "utf-8");
-    writeFileSync(filePaths.redactions, JSON.stringify(redactSensitiveValue(redactionsContent).value, null, 2) + "\n", "utf-8");
+    atomicWriteJsonFileSync(filePaths.risk, redactSensitiveValue(riskContent).value);
+    atomicWriteJsonFileSync(filePaths.verify, redactSensitiveValue(verifyContent).value);
+    atomicWriteJsonFileSync(filePaths.diffstat, redactSensitiveValue(diffstatContent).value);
+    atomicWriteJsonFileSync(filePaths.lineage, redactSensitiveValue(lineageSummary).value);
+    atomicWriteJsonFileSync(filePaths.attestation, redactSensitiveValue(attestationContent).value);
+    atomicWriteJsonFileSync(filePaths.redactions, redactSensitiveValue(redactionsContent).value);
     const safePack = redactSensitiveValue({
         evidence_pack_id: `evidence_${lineageId}`,
         lineage_id: lineageId,
@@ -94,8 +96,8 @@ export function exportTaskEvidencePack(input) {
         next_action: buildNextAction(lineage),
         bounded: true,
     }).value;
-    writeFileSync(safePack.files.json, JSON.stringify(safePack, null, 2) + "\n", "utf-8");
-    writeFileSync(safePack.files.markdown, buildEvidenceMarkdown(safePack), "utf-8");
+    atomicWriteJsonFileSync(safePack.files.json, safePack);
+    atomicWriteFileSync(safePack.files.markdown, buildEvidenceMarkdown(safePack));
     return safePack;
 }
 export function listEvidencePacks(options = {}) {
@@ -308,19 +310,29 @@ function buildLineageSummary(lineage) {
         truncated: lineage.truncated,
     };
 }
-function readGitCommitShort() {
+function readGitCommitShort(repoPath, workspaceRoot) {
     try {
-        return execSync("git rev-parse --short HEAD", { encoding: "utf-8", timeout: 5000 }).trim();
+        const cwd = guardWorkspacePath(repoPath || ".", workspaceRoot);
+        const env = buildGitEnvironment(cwd);
+        const git = resolveTrustedExecutable("git", cwd, { pathValue: env.PATH });
+        return execFileSync(git, ["rev-parse", "--short", "HEAD"], {
+            cwd,
+            encoding: "utf-8",
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            timeout: 5000,
+            windowsHide: true,
+        }).trim();
     }
     catch {
         return "unknown";
     }
 }
-function buildAttestation(catalog, generatedAt) {
+function buildAttestation(catalog, generatedAt, repoPath, workspaceRoot) {
     return {
         patchwarden_version: PATCHWARDEN_VERSION,
         package_version: PATCHWARDEN_VERSION,
-        commit: readGitCommitShort(),
+        commit: readGitCommitShort(repoPath, workspaceRoot),
         node_version: process.version,
         os: { platform: process.platform, arch: process.arch },
         tool_profile: catalog.tool_profile,

package/dist/tools/{getTaskFile.js → tasks/getTaskFile.js}

@@ -1,9 +1,9 @@
 import { readFileSync, existsSync, statSync } from "node:fs";
 import { resolve, join } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
 import { getTaskStatus } from "./getTaskStatus.js";
 export const TASK_READ_ONLY_FILES = [
     "result.md",

package/dist/tools/{getTaskStatus.d.ts → tasks/getTaskStatus.d.ts}

@@ -1,6 +1,6 @@
 import type { TaskStatus } from "./createTask.js";
 import type { TaskPhase } from "./createTask.js";
-import { type PendingReason, type WatcherStatusSnapshot } from "../watcherStatus.js";
+import { type PendingReason, type WatcherStatusSnapshot } from "../../watcherStatus.js";
 export interface GetTaskStatusOutput {
     task_id: string;
     plan_id: string;
@@ -28,6 +28,11 @@ export interface GetTaskStatusOutput {
         path: string;
         change: string;
     }>;
+    new_out_of_scope_changes?: Array<{
+        path: string;
+        change: string;
+    }>;
+    artifact_hygiene_counts?: Record<string, unknown>;
     verify_status?: "passed" | "failed" | "skipped";
     verify_commands?: string[];
     diff_available?: boolean;

package/dist/tools/{getTaskStatus.js → tasks/getTaskStatus.js}

@@ -1,10 +1,10 @@
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { readTaskRuntime } from "../taskRuntime.js";
-import { derivePendingReason, readWatcherStatus, } from "../watcherStatus.js";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+import { readTaskRuntime } from "../../runner/taskRuntime.js";
+import { derivePendingReason, readWatcherStatus, } from "../../watcherStatus.js";
 export function getTaskStatus(taskId) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);

package/dist/tools/{getTaskStdoutTail.js → tasks/getTaskStdoutTail.js}

@@ -1,8 +1,9 @@
-import { readFileSync, existsSync } from "node:fs";
+import { existsSync } from "node:fs";
 import { join } from "node:path";
-import { getTasksDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
+import { readTextFilePrefixSync, readTextFileTailLinesSync } from "../../utils/boundedFile.js";
 export function getTaskStdoutTail(taskId, lines = 80) {
     const config = getConfig();
     const tasksDir = getTasksDir(config);
@@ -16,29 +17,30 @@ export function getTaskStdoutTail(taskId, lines = 80) {
     const stdoutLog = join(taskDir, "stdout.log");
     const stderrLog = join(taskDir, "stderr.log");
     const resultFile = join(taskDir, "result.md");
-    const maxLines = Math.min(lines, 200);
+    const maxLines = Number.isFinite(lines)
+        ? Math.max(1, Math.min(200, Math.trunc(lines)))
+        : 80;
+    const stderrLines = Math.min(maxLines, 40);
     let stdoutTail = "";
     let stderrTail = "";
     let source = "none";
     // All log files are optional — don't throw if missing
     if (existsSync(stdoutLog)) {
-        const raw = readFileSync(stdoutLog, "utf-8");
-        stdoutTail = raw.split("\n").slice(-maxLines).join("\n");
+        stdoutTail = readTextFileTailLinesSync(stdoutLog, maxLines, config.maxReadFileBytes);
         source = "stdout.log";
     }
     if (existsSync(stderrLog)) {
-        const raw = readFileSync(stderrLog, "utf-8");
-        stderrTail = raw.split("\n").slice(-Math.min(maxLines, 40)).join("\n");
+        stderrTail = readTextFileTailLinesSync(stderrLog, stderrLines, config.maxReadFileBytes);
     }
     // Fallback to result.md
     if (!stdoutTail && existsSync(resultFile)) {
-        const raw = readFileSync(resultFile, "utf-8");
+        const raw = readTextFilePrefixSync(resultFile, config.maxReadFileBytes).content;
         const stdoutMatch = raw.match(/## Agent stdout\s*\n+```\s*([\s\S]*?)```/i);
         const stderrMatch = raw.match(/## Agent stderr\s*\n+```\s*([\s\S]*?)```/i);
         if (stdoutMatch)
             stdoutTail = stdoutMatch[1].split("\n").slice(-maxLines).join("\n");
         if (stderrMatch && !stderrTail)
-            stderrTail = stderrMatch[1].split("\n").slice(-Math.min(maxLines, 40)).join("\n");
+            stderrTail = stderrMatch[1].split("\n").slice(-stderrLines).join("\n");
         if (source === "none")
             source = "result.md";
     }