patchwarden 0.4.0 → 0.6.0

package/src/runner/agentInvocation.ts

@@ -0,0 +1,125 @@
+import { basename } from "node:path";
+import { PatchWardenConfig } from "../config.js";
+import { guardAgentCommand, sanitizePromptArg, type AllowedCommand } from "../security/commandGuard.js";
+
+export interface AgentInvocation {
+  command: string;
+  args: string[];
+  cwd: string;
+  commandLabel: string;
+  promptMode: "inline" | "file";
+  promptFilePath?: string;
+}
+
+/**
+ * Build agent invocation parameters from config.
+ * Replaces {repo}, {prompt}, and {prompt_file} placeholders.
+ * runTask and agentAssessor share this function to ensure consistent agent startup.
+ */
+export function buildAgentInvocation(
+  agentName: string,
+  repoPath: string,
+  prompt: string,
+  config: PatchWardenConfig,
+  promptFilePath?: string
+): AgentInvocation {
+  const agentCmd = guardAgentCommand(agentName, config);
+  const sanitizedPrompt = sanitizePromptArg(prompt);
+
+  const hasPromptFilePlaceholder = agentCmd.args.includes("{prompt_file}");
+  const promptMode: "inline" | "file" = hasPromptFilePlaceholder && promptFilePath ? "file" : "inline";
+
+  const resolvedArgs = agentCmd.args.map((arg) => {
+    if (arg === "{repo}") return repoPath;
+    if (arg === "{prompt}") return sanitizedPrompt;
+    if (arg === "{prompt_file}" && promptMode === "file" && promptFilePath) return promptFilePath;
+    return arg;
+  });
+
+  return {
+    command: agentCmd.command,
+    args: resolvedArgs,
+    cwd: repoPath,
+    commandLabel: `${basename(agentCmd.command)} (configured agent command)`,
+    promptMode,
+    ...(promptMode === "file" && promptFilePath ? { promptFilePath } : {}),
+  };
+}
+
+/**
+ * Build task execution prompt. Mechanically extracted from runTask.ts.
+ */
+export function buildExecutionPrompt(plan: string, repoPath: string, testCommand: string): string {
+  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. Leave repository changes uncommitted for review; remote operations are outside this task.
+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;
+}
+
+/**
+ * Build agentAssessor inspect-only prompt.
+ */
+export function buildAssessmentPrompt(goal: string, planContent: string, repoPath: string): string {
+  return `You are performing a READ-ONLY risk assessment of a planned task. Do NOT modify any files.
+
+## Repository
+${repoPath}
+
+## Goal
+${goal}
+
+## Plan
+${planContent}
+
+## Instructions
+1. Read the plan and goal carefully.
+2. Inspect the repository to understand the scope of changes.
+3. Do NOT create, edit, delete, rename, or generate any files.
+4. Assess the risk level of executing this plan.
+5. Identify affected file paths within the repository.
+6. Check for destructive actions, sensitive file access, or out-of-scope changes.
+7. Output your assessment as JSON after the marker ===ASSESSMENT_JSON=== on a new line.
+
+## Required JSON output format
+After your analysis, output exactly this format:
+
+===ASSESSMENT_JSON===
+{
+  "risk_level": "low" | "medium" | "high",
+  "reason_codes": ["short", "descriptive", "codes"],
+  "affected_paths": ["relative/path/to/file"],
+  "destructive_actions": ["description of any destructive actions"],
+  "requires_user_confirm": false,
+  "confidence": 0.0,
+  "notes": "Brief summary of findings"
+}
+
+## Risk level guidelines
+- low: Small source change, no sensitive files, no destructive actions
+- medium: Multiple files, build artifacts, dependency changes, or uncertain scope
+- high: Destructive actions, sensitive file access, out-of-scope changes, or large-scale deletion
+
+## Constraints
+- affected_paths must be relative paths within the repository (no absolute paths)
+- reason_codes: max 50 entries, each max 100 chars
+- destructive_actions: max 20 entries, each max 200 chars
+- notes: max 2000 chars
+- confidence: number from 0.0 to 1.0
+`;
+}

package/src/runner/changeCapture.ts

@@ -19,6 +19,8 @@ const SKIP_DIRECTORIES = new Set([".git", ".patchwarden", "node_modules"]);
 export interface FileFingerprint {
   size: number;
   sha256: string;
+  tracked: boolean;
+  ignored: boolean;
 }
 
 export interface RepoSnapshot {
@@ -37,6 +39,33 @@ export interface ChangedFile {
   old_path?: string;
   before_sha256: string | null;
   after_sha256: string | null;
+  tracked: boolean;
+  ignored: boolean;
+  kind: "source" | "build_artifact" | "runtime_generated";
+}
+
+export interface ClassifiedChange {
+  path: string;
+  change: ChangedFile["change"];
+  tracked: boolean;
+  ignored: boolean;
+  kind: ChangedFile["kind"];
+  reason: string;
+}
+
+export interface ArtifactHygiene {
+  counts: {
+    source_changes: number;
+    tracked_build_artifacts: number;
+    ignored_untracked_artifacts: number;
+    runtime_generated_files: number;
+    suspicious_changes: number;
+  };
+  source_changes: ClassifiedChange[];
+  tracked_build_artifacts: ClassifiedChange[];
+  ignored_untracked_artifacts: ClassifiedChange[];
+  runtime_generated_files: ClassifiedChange[];
+  suspicious_changes: ClassifiedChange[];
 }
 
 export interface ChangeArtifacts {
@@ -57,6 +86,7 @@ export interface ChangeArtifacts {
   workspace_dirty_after: boolean;
   patch_mode: "textual" | "no_changes" | "hash_only";
   unavailable_reason: string | null;
+  artifact_hygiene: ArtifactHygiene;
 }
 
 export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
@@ -65,11 +95,23 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
   let head: string | null = null;
   let status = "";
   let paths: string[] = [];
+  const trackedPaths = new Set<string>();
+  const ignoredPaths = new Set<string>();
 
   if (isGit) {
     const headResult = runGit(repoPath, ["rev-parse", "HEAD"]);
     if (headResult.status === 0) head = headResult.stdout.trim() || null;
     status = runGit(repoPath, ["status", "--porcelain=v1", "-uall"]).stdout.trimEnd();
+    const tracked = runGit(repoPath, ["ls-files", "-z"]);
+    if (tracked.status === 0) {
+      for (const path of tracked.stdout.split("\0").filter(Boolean)) trackedPaths.add(normalizePath(path));
+    }
+    const ignored = runGit(repoPath, ["ls-files", "-o", "-i", "--exclude-standard", "-z"]);
+    if (ignored.status === 0) {
+      for (const path of ignored.stdout.split("\0").filter(Boolean)) ignoredPaths.add(normalizePath(path));
+    } else {
+      warnings.push("git ignored-file discovery failed; ignored classification may be incomplete");
+    }
     const listed = runGit(repoPath, ["ls-files", "-co", "--exclude-standard", "-z"]);
     if (listed.status === 0) {
       paths = [...new Set([
@@ -92,7 +134,7 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
 
   const files: Record<string, FileFingerprint> = {};
   for (const inputPath of paths.sort()) {
-    const normalized = inputPath.replace(/\\/g, "/");
+    const normalized = normalizePath(inputPath);
     if (!normalized || normalized.startsWith(".patchwarden/") || isSensitivePath(normalized)) continue;
     const absolutePath = resolve(repoPath, inputPath);
     try {
@@ -101,7 +143,12 @@ export function captureRepoSnapshot(repoPath: string): RepoSnapshot {
       const sha256 = stat.size <= MAX_HASH_BYTES
         ? createHash("sha256").update(readFileSync(absolutePath)).digest("hex")
         : `large-file:${stat.size}:${Math.trunc(stat.mtimeMs)}`;
-      files[normalized] = { size: stat.size, sha256 };
+      files[normalized] = {
+        size: stat.size,
+        sha256,
+        tracked: trackedPaths.has(normalized),
+        ignored: !trackedPaths.has(normalized) && ignoredPaths.has(normalized),
+      };
     } catch {
       warnings.push(`could not fingerprint: ${normalized}`);
     }
@@ -128,6 +175,7 @@ export function buildChangeArtifacts(
   after: RepoSnapshot
 ): ChangeArtifacts {
   const changedFiles = compareSnapshots(before, after);
+  const artifactHygiene = classifyArtifactHygiene(changedFiles);
   const sections: string[] = [];
   const scopedPaths = [...new Set(changedFiles.flatMap((file) => file.old_path ? [file.old_path, file.path] : [file.path]))];
 
@@ -179,6 +227,7 @@ export function buildChangeArtifacts(
           ? "Git could not produce a textual patch for the changed files; hash evidence remains available."
           : "Repository is not a Git worktree; only bounded hash evidence is available.")
       : null,
+    artifact_hygiene: artifactHygiene,
   };
 }
 
@@ -232,11 +281,11 @@ export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): Cha
     const left = before.files[path];
     const right = after.files[path];
     if (!left && right) {
-      changed.push({ path, change: "added", before_sha256: null, after_sha256: right.sha256 });
+      changed.push(classifyChangedFile(path, "added", null, right));
     } else if (left && !right) {
-      changed.push({ path, change: "deleted", before_sha256: left.sha256, after_sha256: null });
+      changed.push(classifyChangedFile(path, "deleted", left, null));
     } else if (left.sha256 !== right.sha256) {
-      changed.push({ path, change: "modified", before_sha256: left.sha256, after_sha256: right.sha256 });
+      changed.push(classifyChangedFile(path, "modified", left, right));
     }
   }
   const deletedByHash = new Map<string, ChangedFile[]>();
@@ -260,6 +309,9 @@ export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): Cha
       change: "renamed",
       before_sha256: source.before_sha256,
       after_sha256: file.after_sha256,
+      tracked: file.tracked || source.tracked,
+      ignored: file.ignored,
+      kind: classifyPathKind(file.path),
     });
   }
 
@@ -267,6 +319,89 @@ export function compareSnapshots(before: RepoSnapshot, after: RepoSnapshot): Cha
     .sort((left, right) => left.path.localeCompare(right.path));
 }
 
+export function emptyArtifactHygiene(): ArtifactHygiene {
+  return {
+    counts: {
+      source_changes: 0,
+      tracked_build_artifacts: 0,
+      ignored_untracked_artifacts: 0,
+      runtime_generated_files: 0,
+      suspicious_changes: 0,
+    },
+    source_changes: [],
+    tracked_build_artifacts: [],
+    ignored_untracked_artifacts: [],
+    runtime_generated_files: [],
+    suspicious_changes: [],
+  };
+}
+
+function classifyChangedFile(
+  path: string,
+  change: ChangedFile["change"],
+  before: FileFingerprint | null,
+  after: FileFingerprint | null
+): ChangedFile {
+  return {
+    path,
+    change,
+    before_sha256: before?.sha256 || null,
+    after_sha256: after?.sha256 || null,
+    tracked: Boolean(after?.tracked || before?.tracked),
+    ignored: Boolean(after?.ignored ?? before?.ignored),
+    kind: classifyPathKind(path),
+  };
+}
+
+function classifyArtifactHygiene(changes: ChangedFile[]): ArtifactHygiene {
+  const hygiene = emptyArtifactHygiene();
+  const entries = changes.map((change): ClassifiedChange => ({
+    path: change.path,
+    change: change.change,
+    tracked: change.tracked,
+    ignored: change.ignored,
+    kind: change.kind,
+    reason: classificationReason(change),
+  }));
+  hygiene.source_changes = entries.filter((entry) => entry.kind === "source" && !entry.ignored);
+  hygiene.tracked_build_artifacts = entries.filter((entry) => entry.kind === "build_artifact" && entry.tracked);
+  hygiene.ignored_untracked_artifacts = entries.filter((entry) => entry.ignored && !entry.tracked);
+  hygiene.runtime_generated_files = entries.filter((entry) => entry.kind === "runtime_generated");
+  hygiene.suspicious_changes = entries.filter((entry) =>
+    (entry.kind === "build_artifact" || entry.kind === "runtime_generated") && !entry.ignored
+  );
+  hygiene.counts = {
+    source_changes: hygiene.source_changes.length,
+    tracked_build_artifacts: hygiene.tracked_build_artifacts.length,
+    ignored_untracked_artifacts: hygiene.ignored_untracked_artifacts.length,
+    runtime_generated_files: hygiene.runtime_generated_files.length,
+    suspicious_changes: hygiene.suspicious_changes.length,
+  };
+  return hygiene;
+}
+
+function classifyPathKind(path: string): ChangedFile["kind"] {
+  const normalized = normalizePath(path).toLowerCase();
+  const parts = normalized.split("/");
+  const basename = parts[parts.length - 1] || "";
+  if (basename === "sync-store.json" || /\.(log|tmp|temp|pid)$/.test(basename)) return "runtime_generated";
+  if (parts.some((part) => ["dist", "release", "build", "out", "coverage", ".next"].includes(part))) return "build_artifact";
+  if (/\.(exe|dll|pak|bin|zip|tgz|tar\.gz)$/.test(basename)) return "build_artifact";
+  return "source";
+}
+
+function classificationReason(change: ChangedFile): string {
+  if (change.ignored) return "untracked path is ignored by repository Git rules";
+  if (change.kind === "build_artifact" && change.tracked) return "artifact-like path is tracked by Git and requires review";
+  if (change.kind === "build_artifact") return "artifact-like path is not ignored and requires review";
+  if (change.kind === "runtime_generated") return "runtime-generated path is not ignored and requires review";
+  return change.tracked ? "tracked source change" : "untracked source change";
+}
+
+function normalizePath(value: string): string {
+  return value.replace(/\\/g, "/");
+}
+
 function walkWorkspace(root: string): string[] {
   const result: string[] = [];
   const visit = (directory: string) => {

package/src/runner/runTask.ts

@@ -6,21 +6,22 @@ import {
   writeFileSync,
   type WriteStream,
 } 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 { writeTaskProgress } from "../taskProgress.js";
 import { writeTaskRuntime } from "../taskRuntime.js";
+import { validateAssessmentFreshness } from "../assessments/assessmentStore.js";
+import { buildAgentInvocation, buildExecutionPrompt } from "./agentInvocation.js";
 import type { TaskPhase, TaskStatus } from "../tools/createTask.js";
 import {
   buildChangeArtifacts,
   captureRepoSnapshot,
   compareSnapshots,
+  emptyArtifactHygiene,
   writeSnapshot,
   type ChangedFile,
   type ChangeArtifacts,
@@ -94,7 +95,6 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
   let verifyCommands: string[];
   let timeoutSeconds: number;
   try {
-    verifyCommands = normalizeVerifyCommands(initialStatus.verify_commands, testCommand, config);
     timeoutSeconds = normalizeTimeout(initialStatus.timeout_seconds, config);
   } catch (error) {
     return failBeforeExecution(taskId, taskDir, errorMessage(error));
@@ -109,6 +109,28 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     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",
@@ -143,19 +165,14 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     const planFile = resolve(plansDir, planId, "plan.md");
     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,
@@ -232,6 +249,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
       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";
@@ -326,6 +344,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     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,
@@ -365,6 +384,7 @@ export async function runTask(taskId: string): Promise<TaskRunResult> {
     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,
@@ -483,6 +503,8 @@ async function runManagedProcess(options: {
   let spawnError: string | null = null;
   let terminationReason: TerminationReason = null;
   let forceTimer: ReturnType<typeof setTimeout> | null = null;
+  let fallbackTimer: ReturnType<typeof setTimeout> | null = null;
+  let childExitFinish: ((code: number | null) => void) | null = null;
   let terminationStarted = false;
 
   const heartbeat = () => {
@@ -520,6 +542,15 @@ 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: Buffer) => {
@@ -540,9 +571,18 @@ async function runManagedProcess(options: {
     const finish = (code: number | null) => {
       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);
@@ -551,8 +591,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(),
@@ -572,7 +612,7 @@ async function runTrustedTestCommand(
   deadlineMs: number
 ): Promise<TestExecutionResult> {
   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);
@@ -606,29 +646,6 @@ async function runTrustedTestCommand(
   };
 }
 
-function buildExecutionPrompt(plan: string, repoPath: string, testCommand: string): string {
-  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: TestExecutionResult): string {
   if (result.skipped) return `${result.command || "(no test command)"}\nExit code: not run\n${result.stderr}\n`;
   return [
@@ -777,14 +794,15 @@ function buildVerifyLog(commands: VerifyCommandRecord[]): string {
 function normalizeVerifyCommands(
   value: unknown,
   legacyTestCommand: string,
-  config: ReturnType<typeof getConfig>
+  config: ReturnType<typeof getConfig>,
+  repoPath: string
 ): string[] {
   if (value !== undefined && !Array.isArray(value)) {
     throw new Error("Invalid task verify_commands metadata; expected an array.");
   }
   return [...new Set([
-    ...((value as unknown[] | undefined) || []).map((command) => guardTestCommand(String(command), config)),
-    ...(legacyTestCommand ? [guardTestCommand(legacyTestCommand, config)] : []),
+    ...((value as unknown[] | undefined) || []).map((command) => guardTestCommand(String(command), config, repoPath)),
+    ...(legacyTestCommand ? [guardTestCommand(legacyTestCommand, config, repoPath)] : []),
   ])];
 }