patchwarden 0.4.0 → 0.6.0

package/dist/runner/runTask.js

@@ -1,12 +1,14 @@
 import { spawn, spawnSync } from "node:child_process";
 import { createWriteStream, existsSync, readFileSync, writeFileSync, } from "node:fs";
-import { basename, isAbsolute, join, relative, resolve } from "node:path";
+import { isAbsolute, join, relative, resolve } from "node:path";
 import { getTasksDir, getPlansDir, getConfig, resolveWorkspaceRoot } from "../config.js";
 import { guardPath, guardWorkspacePath } from "../security/pathGuard.js";
-import { guardAgentCommand, guardTestCommand, sanitizePromptArg, } from "../security/commandGuard.js";
+import { guardTestCommand, } from "../security/commandGuard.js";
 import { writeTaskProgress } from "../taskProgress.js";
 import { writeTaskRuntime } from "../taskRuntime.js";
-import { buildChangeArtifacts, captureRepoSnapshot, compareSnapshots, writeSnapshot, } from "./changeCapture.js";
+import { validateAssessmentFreshness } from "../assessments/assessmentStore.js";
+import { buildAgentInvocation, buildExecutionPrompt } from "./agentInvocation.js";
+import { buildChangeArtifacts, captureRepoSnapshot, compareSnapshots, emptyArtifactHygiene, writeSnapshot, } from "./changeCapture.js";
 const HEARTBEAT_INTERVAL_MS = 2000;
 const GRACEFUL_KILL_MS = 2000;
 const MAX_CAPTURE_CHARS = 100_000;
@@ -29,7 +31,6 @@ export async function runTask(taskId) {
     let verifyCommands;
     let timeoutSeconds;
     try {
-        verifyCommands = normalizeVerifyCommands(initialStatus.verify_commands, testCommand, config);
         timeoutSeconds = normalizeTimeout(initialStatus.timeout_seconds, config);
     }
     catch (error) {
@@ -45,6 +46,29 @@ export async function runTask(taskId) {
         const message = `repo_path validation failed: ${errorMessage(error)}`;
         return failBeforeExecution(taskId, taskDir, message);
     }
+    try {
+        verifyCommands = normalizeVerifyCommands(initialStatus.verify_commands, testCommand, config, repoPath);
+    }
+    catch (error) {
+        const message = `verification metadata validation failed: ${errorMessage(error)}`;
+        return failBeforeExecution(taskId, taskDir, message);
+    }
+    // ── Assessment freshness revalidation before execution ──
+    const assessmentId = String(initialStatus.assessment_id || "");
+    if (assessmentId) {
+        try {
+            const preExecSnapshot = captureRepoSnapshot(repoPath);
+            const validation = validateAssessmentFreshness(assessmentId, preExecSnapshot);
+            if (!validation.valid) {
+                const message = `assessment validation failed: ${validation.failure_reason}. Re-run create_task with execution_mode=assess_only to get a fresh assessment_id.`;
+                return failBeforeExecution(taskId, taskDir, message);
+            }
+        }
+        catch (error) {
+            const message = `assessment validation error: ${errorMessage(error)}`;
+            return failBeforeExecution(taskId, taskDir, message);
+        }
+    }
     updateStatus(taskDir, {
         status: "running",
         phase: "preparing",
@@ -77,20 +101,13 @@ export async function runTask(taskId) {
         if (!existsSync(planFile))
             throw new Error(`Plan not found: "${planId}". Save the plan first.`);
         const planContent = readFileSync(planFile, "utf-8");
-        const agentCmd = guardAgentCommand(agentName, config);
-        const prompt = sanitizePromptArg(buildExecutionPrompt(planContent, repoPath, testCommand));
-        const resolvedArgs = agentCmd.args.map((arg) => {
-            if (arg === "{repo}")
-                return repoPath;
-            if (arg === "{prompt}")
-                return prompt;
-            return arg;
-        });
-        const agentCommandLabel = `${basename(agentCmd.command)} (configured agent command)`;
+        const prompt = buildExecutionPrompt(planContent, repoPath, testCommand);
+        const invocation = buildAgentInvocation(agentName, repoPath, prompt, config);
+        const agentCommandLabel = invocation.commandLabel;
         setTaskPhase(taskDir, "executing_agent", agentCommandLabel);
         agentResult = await runManagedProcess({
-            command: agentCmd.command,
-            args: resolvedArgs,
+            command: invocation.command,
+            args: invocation.args,
             cwd: repoPath,
             taskDir,
             statusFile,
@@ -177,6 +194,7 @@ export async function runTask(taskId) {
             workspace_dirty_after: beforeSnapshot.workspace_dirty,
             patch_mode: "hash_only",
             unavailable_reason: `Change capture failed: ${errorMessage(error)}`,
+            artifact_hygiene: emptyArtifactHygiene(),
         };
         finalError ||= `Change capture failed: ${errorMessage(error)}`;
         finalStatus = "failed";
@@ -270,6 +288,7 @@ export async function runTask(taskId) {
         change_policy: changePolicy,
         summary: finalError || "Agent execution and configured verification completed successfully.",
         changed_files: changes.changed_files,
+        artifact_hygiene: changes.artifact_hygiene,
         out_of_scope_changes: outOfScopeChanges,
         verify_status: verifyJson.status,
         verify_commands: verifyJson.commands,
@@ -309,6 +328,7 @@ export async function runTask(taskId) {
         finished_at: finishedAt,
         error: finalError,
         changed_files: changes.changed_files.map(({ path, change }) => ({ path, change })),
+        artifact_hygiene_counts: changes.artifact_hygiene.counts,
         out_of_scope_changes: outOfScopeChanges,
         verify_status: verifyJson.status,
         verify_commands: verifyCommands,
@@ -403,6 +423,8 @@ async function runManagedProcess(options) {
     let spawnError = null;
     let terminationReason = null;
     let forceTimer = null;
+    let fallbackTimer = null;
+    let childExitFinish = null;
     let terminationStarted = false;
     const heartbeat = () => {
         const now = new Date().toISOString();
@@ -442,6 +464,22 @@ async function runManagedProcess(options) {
             gracefulKill(child);
             forceTimer = setTimeout(() => forceKill(child), GRACEFUL_KILL_MS);
         }
+        // Fallback: if neither close nor exit fires within 10s after taskkill,
+        // force-resolve to prevent the runner from hanging indefinitely.
+        // Only starts AFTER termination is requested — normal long tasks are unaffected.
+        fallbackTimer = setTimeout(() => {
+            try {
+                forceKill(child);
+            }
+            catch { }
+            try {
+                child.kill("SIGKILL");
+            }
+            catch { }
+            // Resolve the exit promise via the shared finish handle
+            if (childExitFinish)
+                childExitFinish(null);
+        }, 10000);
     };
     child.stdout?.on("data", (chunk) => {
         const text = chunk.toString("utf-8");
@@ -461,9 +499,19 @@ async function runManagedProcess(options) {
             if (settled)
                 return;
             settled = true;
+            if (fallbackTimer)
+                clearTimeout(fallbackTimer);
+            childExitFinish = null;
             resolveExit(code);
         };
+        childExitFinish = finish;
         child.once("close", (code) => finish(code));
+        child.once("exit", (code) => {
+            // On Windows, "close" can lag behind "exit" when stdio pipes drain
+            // after taskkill. Resolve on exit to avoid hanging the runner, but
+            // still let "close" fire if it arrives first.
+            finish(code);
+        });
         child.once("error", (error) => {
             spawnError = error.message;
             finish(null);
@@ -472,8 +520,8 @@ async function runManagedProcess(options) {
     clearInterval(heartbeatTimer);
     if (forceTimer)
         clearTimeout(forceTimer);
-    stdoutStream?.end();
-    stderrStream?.end();
+    stdoutStream?.destroy();
+    stderrStream?.destroy();
     writeTaskRuntime(options.taskDir, {
         phase: options.phase,
         last_heartbeat_at: new Date().toISOString(),
@@ -485,7 +533,7 @@ async function runManagedProcess(options) {
 }
 async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile, deadlineMs) {
     const config = getConfig();
-    const trusted = guardTestCommand(testCommand, config);
+    const trusted = guardTestCommand(testCommand, config, repoPath);
     const startedAtMs = Date.now();
     const startedAt = new Date(startedAtMs).toISOString();
     const parts = trusted.split(/\s+/).filter(Boolean);
@@ -518,28 +566,6 @@ async function runTrustedTestCommand(testCommand, repoPath, taskDir, statusFile,
         duration_ms: finishedAtMs - startedAtMs,
     };
 }
-function buildExecutionPrompt(plan, repoPath, testCommand) {
-    let prompt = `You are executing a pre-written plan in a local repository.
-
-## Repository
-${repoPath}
-
-## Plan
-${plan}
-
-## Instructions
-1. Read the plan carefully.
-2. Implement the changes in this repository only.
-3. Do NOT modify files outside this repository.
-4. Do NOT commit or push changes.
-5. After implementing, describe what you changed.
-6. Output a summary with what was done, files modified, and issues encountered.
-`;
-    if (testCommand) {
-        prompt += `\n7. You may run ${testCommand}; PatchWarden will independently run it again for verification.`;
-    }
-    return prompt;
-}
 function buildTestLog(result) {
     if (result.skipped)
         return `${result.command || "(no test command)"}\nExit code: not run\n${result.stderr}\n`;
@@ -671,13 +697,13 @@ function buildVerifyLog(commands) {
         entry.stderr_tail || "(empty)",
     ].join("\n")).join("\n\n");
 }
-function normalizeVerifyCommands(value, legacyTestCommand, config) {
+function normalizeVerifyCommands(value, legacyTestCommand, config, repoPath) {
     if (value !== undefined && !Array.isArray(value)) {
         throw new Error("Invalid task verify_commands metadata; expected an array.");
     }
     return [...new Set([
-            ...(value || []).map((command) => guardTestCommand(String(command), config)),
-            ...(legacyTestCommand ? [guardTestCommand(legacyTestCommand, config)] : []),
+            ...(value || []).map((command) => guardTestCommand(String(command), config, repoPath)),
+            ...(legacyTestCommand ? [guardTestCommand(legacyTestCommand, config, repoPath)] : []),
         ])];
 }
 function summarizeOutput(value) {

package/dist/runner/simpleProcess.d.ts

@@ -0,0 +1,21 @@
+export interface SimpleProcessOptions {
+    command: string;
+    args: string[];
+    cwd: string;
+    timeoutMs: number;
+    maxStdoutBytes?: number;
+    maxStderrBytes?: number;
+    stdoutPath?: string;
+    stderrPath?: string;
+}
+export interface SimpleProcessResult {
+    exitCode: number | null;
+    stdout: string;
+    stderr: string;
+    spawnError: string | null;
+    timedOut: boolean;
+    stdoutTruncated: boolean;
+    stderrTruncated: boolean;
+}
+export declare function runSimpleProcessSync(options: SimpleProcessOptions): SimpleProcessResult;
+export declare function runSimpleProcess(options: SimpleProcessOptions): Promise<SimpleProcessResult>;

package/dist/runner/simpleProcess.js

@@ -0,0 +1,206 @@
+import { spawn, spawnSync } from "node:child_process";
+import { createWriteStream, writeFileSync, readFileSync, existsSync } from "node:fs";
+const GRACEFUL_KILL_MS = 2000;
+const DEFAULT_MAX_STDOUT = 524288;
+const DEFAULT_MAX_STDERR = 131072;
+export function runSimpleProcessSync(options) {
+    const maxStdout = options.maxStdoutBytes ?? DEFAULT_MAX_STDOUT;
+    const maxStderr = options.maxStderrBytes ?? DEFAULT_MAX_STDERR;
+    let result;
+    try {
+        result = spawnSync(options.command, options.args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            timeout: options.timeoutMs,
+            windowsHide: true,
+            maxBuffer: maxStdout + 1024,
+            encoding: "utf-8",
+        });
+    }
+    catch (error) {
+        return {
+            exitCode: null,
+            stdout: "",
+            stderr: "",
+            spawnError: error instanceof Error ? error.message : String(error),
+            timedOut: false,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+        };
+    }
+    const stdout = result.stdout || "";
+    const stderr = result.stderr || "";
+    const timedOut = Boolean(result.signal === "SIGTERM" || result.signal === "SIGKILL" ||
+        (result.signal !== null && result.status === null) ||
+        (result.error && result.error.code === "ETIMEDOUT"));
+    if (options.stdoutPath && stdout) {
+        try {
+            writeFileSyncAppend(options.stdoutPath, stdout);
+        }
+        catch { }
+    }
+    if (options.stderrPath && stderr) {
+        try {
+            writeFileSyncAppend(options.stderrPath, stderr);
+        }
+        catch { }
+    }
+    return {
+        exitCode: result.status,
+        stdout: stdout.length > maxStdout ? stdout.slice(0, maxStdout) : stdout,
+        stderr: stderr.length > maxStderr ? stderr.slice(0, maxStderr) : stderr,
+        // If timed out, don't report spawnError — it's a timeout, not a spawn failure
+        spawnError: timedOut ? null : (result.error ? result.error.message : null),
+        timedOut,
+        stdoutTruncated: stdout.length > maxStdout,
+        stderrTruncated: stderr.length > maxStderr,
+    };
+}
+export async function runSimpleProcess(options) {
+    const maxStdout = options.maxStdoutBytes ?? DEFAULT_MAX_STDOUT;
+    const maxStderr = options.maxStderrBytes ?? DEFAULT_MAX_STDERR;
+    const deadlineMs = Date.now() + options.timeoutMs;
+    let child;
+    try {
+        child = spawn(options.command, options.args, {
+            cwd: options.cwd,
+            stdio: ["ignore", "pipe", "pipe"],
+            detached: process.platform !== "win32",
+            windowsHide: true,
+        });
+    }
+    catch (error) {
+        return {
+            exitCode: null,
+            stdout: "",
+            stderr: "",
+            spawnError: error instanceof Error ? error.message : String(error),
+            timedOut: false,
+            stdoutTruncated: false,
+            stderrTruncated: false,
+        };
+    }
+    const stdoutStream = options.stdoutPath ? createWriteStream(options.stdoutPath, { flags: "a" }) : null;
+    const stderrStream = options.stderrPath ? createWriteStream(options.stderrPath, { flags: "a" }) : null;
+    let stdoutBuf = Buffer.alloc(0);
+    let stderrBuf = Buffer.alloc(0);
+    let stdoutTruncated = false;
+    let stderrTruncated = false;
+    let spawnError = null;
+    let timedOut = false;
+    let forceTimer = null;
+    let terminationStarted = false;
+    const requestTermination = (reason, force) => {
+        if (terminationStarted)
+            return;
+        terminationStarted = true;
+        if (reason === "timeout")
+            timedOut = true;
+        if (force) {
+            forceKill(child);
+        }
+        else {
+            gracefulKill(child);
+            forceTimer = setTimeout(() => forceKill(child), GRACEFUL_KILL_MS);
+        }
+    };
+    child.stdout?.on("data", (chunk) => {
+        stdoutStream?.write(chunk);
+        if (stdoutBuf.length < maxStdout) {
+            const remaining = maxStdout - stdoutBuf.length;
+            if (chunk.length <= remaining) {
+                stdoutBuf = Buffer.concat([stdoutBuf, chunk]);
+            }
+            else {
+                stdoutBuf = Buffer.concat([stdoutBuf, chunk.slice(0, remaining)]);
+                stdoutTruncated = true;
+            }
+        }
+        else {
+            stdoutTruncated = true;
+        }
+    });
+    child.stderr?.on("data", (chunk) => {
+        stderrStream?.write(chunk);
+        if (stderrBuf.length < maxStderr) {
+            const remaining = maxStderr - stderrBuf.length;
+            if (chunk.length <= remaining) {
+                stderrBuf = Buffer.concat([stderrBuf, chunk]);
+            }
+            else {
+                stderrBuf = Buffer.concat([stderrBuf, chunk.slice(0, remaining)]);
+                stderrTruncated = true;
+            }
+        }
+        else {
+            stderrTruncated = true;
+        }
+    });
+    const timeoutTimer = setTimeout(() => requestTermination("timeout", true), options.timeoutMs);
+    const exitCode = await new Promise((resolveExit) => {
+        let settled = false;
+        const finish = (code) => {
+            if (settled)
+                return;
+            settled = true;
+            resolveExit(code);
+        };
+        child.once("close", (code) => finish(code));
+        child.once("exit", (code) => finish(code));
+        child.once("error", (error) => {
+            spawnError = error.message;
+            finish(null);
+        });
+    });
+    clearTimeout(timeoutTimer);
+    if (forceTimer)
+        clearTimeout(forceTimer);
+    stdoutStream?.destroy();
+    stderrStream?.destroy();
+    return {
+        exitCode,
+        stdout: stdoutBuf.toString("utf-8"),
+        stderr: stderrBuf.toString("utf-8"),
+        spawnError,
+        timedOut,
+        stdoutTruncated,
+        stderrTruncated,
+    };
+}
+function gracefulKill(child) {
+    try {
+        if (process.platform !== "win32" && child.pid)
+            process.kill(-child.pid, "SIGTERM");
+        else
+            child.kill("SIGTERM");
+    }
+    catch { }
+}
+function forceKill(child) {
+    if (!child.pid)
+        return;
+    try {
+        if (process.platform === "win32") {
+            const result = spawnSync("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], {
+                stdio: "ignore",
+                timeout: 5000,
+                windowsHide: true,
+            });
+            if (result.status !== 0)
+                child.kill("SIGKILL");
+        }
+        else {
+            process.kill(-child.pid, "SIGKILL");
+        }
+    }
+    catch {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch { }
+    }
+}
+function writeFileSyncAppend(path, content) {
+    const existing = existsSync(path) ? readFileSync(path, "utf-8") : "";
+    writeFileSync(path, existing + content, "utf-8");
+}

package/dist/runner/watch.js

@@ -21,6 +21,8 @@ import { resolve, join, dirname } from "node:path";
 import { loadConfig, getConfig, getTasksDir, resolveWorkspaceRoot } from "../config.js";
 import { guardWorkspacePath } from "../security/pathGuard.js";
 import { guardAgentCommand, guardTestCommand } from "../security/commandGuard.js";
+import { validateAssessmentFreshness } from "../assessments/assessmentStore.js";
+import { captureRepoSnapshot } from "./changeCapture.js";
 import { runTask } from "./runTask.js";
 // ── Bootstrap ─────────────────────────────────────────────────────
 loadConfig();
@@ -80,12 +82,25 @@ async function tick() {
             // ── Pre-flight safety checks ──
             try {
                 // Check repo_path
-                guardWorkspacePath(statusData.repo_path || wsRoot, wsRoot);
+                const resolvedRepoPath = guardWorkspacePath(statusData.resolved_repo_path || statusData.repo_path || wsRoot, wsRoot);
                 // Check agent
                 guardAgentCommand(statusData.agent, config);
                 // Check test_command
                 if (statusData.test_command) {
-                    guardTestCommand(statusData.test_command, config);
+                    guardTestCommand(statusData.test_command, config, resolvedRepoPath);
+                }
+                if (Array.isArray(statusData.verify_commands)) {
+                    for (const command of statusData.verify_commands) {
+                        guardTestCommand(String(command), config, resolvedRepoPath);
+                    }
+                }
+                // Assessment freshness revalidation
+                if (statusData.assessment_id) {
+                    const preExecSnapshot = captureRepoSnapshot(resolvedRepoPath);
+                    const validation = validateAssessmentFreshness(String(statusData.assessment_id), preExecSnapshot);
+                    if (!validation.valid) {
+                        throw new Error(`assessment validation failed: ${validation.failure_reason}`);
+                    }
                 }
             }
             catch (err) {

package/dist/security/commandGuard.d.ts

@@ -13,7 +13,8 @@ export interface AllowedCommand {
     args: string[];
 }
 export declare function guardAgentCommand(agent: string, config: PatchWardenConfig): AllowedCommand;
-export declare function guardTestCommand(testCommand: string, config: PatchWardenConfig): string;
+export declare function guardTestCommand(testCommand: string, config: PatchWardenConfig, repoPath?: string): string;
+export declare function guardDirectCommand(command: string, config: PatchWardenConfig, repoPath?: string): string;
 /**
  * Escape a user-provided string for safe use in shell arguments.
  * We prevent injection by refusing to pass arbitrary strings to shell.

package/dist/security/commandGuard.js

@@ -1,3 +1,4 @@
+import { getRepoAllowedTestCommands, getRepoDirectAllowedCommands } from "../config.js";
 import { PatchWardenError } from "../errors.js";
 export function guardAgentCommand(agent, config) {
     const agentCfg = config.agents[agent];
@@ -32,7 +33,7 @@ function isSafeConfiguredCommand(command) {
     const basename = parts[parts.length - 1] || "";
     return /^[a-zA-Z0-9._-]+$/.test(basename);
 }
-export function guardTestCommand(testCommand, config) {
+export function guardTestCommand(testCommand, config, repoPath) {
     if (!testCommand || typeof testCommand !== "string") {
         // If no test command specified, that's ok — skip tests
         return "";
@@ -40,8 +41,29 @@ export function guardTestCommand(testCommand, config) {
     const trimmed = testCommand.trim();
     if (trimmed === "")
         return "";
-    if (!config.allowedTestCommands.includes(trimmed)) {
-        throw new PatchWardenError("test_command_not_allowlisted", `Test command "${trimmed}" is not in the allowed list. Allowed: ${config.allowedTestCommands.join(", ")}`, "Use an exact allowed command shown by create_task, or omit test_command.");
+    const allowedCommands = [
+        ...config.allowedTestCommands,
+        ...(repoPath ? getRepoAllowedTestCommands(config, repoPath) : []),
+    ];
+    if (!allowedCommands.includes(trimmed)) {
+        throw new PatchWardenError("test_command_not_allowlisted", `Test command "${trimmed}" is not allowed for this repository. Allowed: ${allowedCommands.join(", ")}`, "Use an exact allowed command shown by create_task, or omit test_command.");
+    }
+    return trimmed;
+}
+export function guardDirectCommand(command, config, repoPath) {
+    if (!command || typeof command !== "string") {
+        throw new PatchWardenError("direct_command_required", "A command string is required for run_verification.", "Provide one of the allowed Direct verification commands.");
+    }
+    const trimmed = command.trim();
+    if (trimmed === "") {
+        throw new PatchWardenError("direct_command_required", "A command string is required for run_verification.", "Provide one of the allowed Direct verification commands.");
+    }
+    const allowedCommands = [
+        ...(config.directAllowedCommands || []),
+        ...(repoPath ? getRepoDirectAllowedCommands(config, repoPath) : []),
+    ];
+    if (!allowedCommands.includes(trimmed)) {
+        throw new PatchWardenError("direct_command_not_allowlisted", `Direct command "${trimmed}" is not allowed. Allowed: ${allowedCommands.join(", ")}`, "Use an exact allowed command from the Direct allowlist.");
     }
     return trimmed;
 }

package/dist/security/riskEngine.d.ts

@@ -0,0 +1,27 @@
+import { PatchWardenConfig } from "../config.js";
+import type { TaskTemplateName } from "../tools/taskTemplates.js";
+export type RiskLevel = "low" | "medium" | "high";
+export type RiskDecision = "allow" | "needs_confirm" | "blocked";
+export interface RiskAssessmentInput {
+    repoPath: string;
+    resolvedRepoPath: string;
+    planContent: string;
+    planTitle: string;
+    testCommand: string;
+    verifyCommands: string[];
+    template?: TaskTemplateName;
+    goal?: string;
+    agent: string;
+    config: PatchWardenConfig;
+    snapshotTruncated: boolean;
+}
+export interface RiskAssessmentResult {
+    risk_level: RiskLevel;
+    decision: RiskDecision;
+    reason_codes: string[];
+    risk_hints: string[];
+    hard_rule_hits: string[];
+}
+export declare function assessRisk(input: RiskAssessmentInput): RiskAssessmentResult;
+/** Risk hints — keyword detection only, never affects risk_level (收缩 #4). */
+export declare function collectRiskHints(input: RiskAssessmentInput): string[];