patchwarden 1.5.0 → 1.6.1

package/src/tools/{checkReleaseGate.ts → release/checkReleaseGate.ts}

@@ -1,9 +1,9 @@
-import { getConfig } from "../config.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
+import { getConfig } from "../../config.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
 import {
   runReleaseGateCheck,
   type ReleaseStage,
-} from "../release/releaseGate.js";
+} from "../../release/releaseGate.js";
 
 export interface CheckReleaseGateInput {
   repo_path: string;

package/src/tools/release/index.ts

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

package/src/tools/{releaseMode.ts → release/releaseMode.ts}

@@ -1,7 +1,7 @@
-import { execFileSync, execSync } from "node:child_process";
-import { existsSync, mkdirSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync, readdirSync, rmSync, statSync } from "node:fs";
 import { join, relative, resolve, sep, isAbsolute } from "node:path";
-import { getConfig } from "../config.js";
+import { getConfig } from "../../config.js";
 import {
   checkCiVerified,
   checkGitHubReleaseVerified,
@@ -9,9 +9,12 @@ import {
   runReleaseGateCheck,
   type ReleaseStage,
   type ReleaseStageStatus,
-} from "../release/releaseGate.js";
-import { guardTestCommand } from "../security/commandGuard.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
+} 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,
@@ -19,7 +22,7 @@ import {
   readPackageJson,
   resolveVersionFromPolicy,
   type ProjectPolicySummary,
-} from "../policy/projectPolicy.js";
+} from "../../policy/projectPolicy.js";
 
 export interface ReleaseCheckInput {
   repo_path: string;
@@ -146,12 +149,19 @@ export function releasePrepare(input: ReleasePrepareInput): ReleaseModeResult {
       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) {
       const code = err && typeof err === "object" && "status" in err
@@ -280,7 +290,7 @@ export function releaseCleanup(input: ReleaseCleanupInput): ReleaseModeResult {
   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,
@@ -379,10 +389,12 @@ function walkFrom(base: string, dir: string, visit: (path: string, relPath: stri
 function isTrackedByGit(root: string, relPath: string): boolean {
   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;
   } catch {
@@ -393,32 +405,38 @@ function isTrackedByGit(root: string, relPath: string): boolean {
 function isIgnoredOrUntracked(root: string, relPath: string): boolean {
   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,
+        stdio: "ignore",
+        windowsHide: true,
+        env,
+      });
+      return true;
+    } catch {
+      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;
     }
+  } catch {
+    return false;
   }
 }
 
 function isGitWorktree(root: string): boolean {
   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 {
     return false;

package/src/tools/tasks/cancelTask.ts

@@ -0,0 +1,109 @@
+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";
+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;
+}
+
+interface TaskTerminationOutcome {
+  response: TaskTerminationResponse;
+  progress: {
+    phase: "canceled" | "canceling" | "terminating";
+    note: string;
+  } | null;
+}
+
+export function cancelTask(taskId: string) {
+  return requestTaskTermination(taskId, false);
+}
+
+export function requestTaskTermination(taskId: string, force: boolean) {
+  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<TaskTerminationOutcome>(statusFile, (current) => {
+    const currentStatus = current.status as TaskStatus;
+    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" as const,
+          new_status: "canceled" as const,
+          message: "Pending task canceled. It will not be executed by watcher.",
+        },
+        progress: { phase: "canceled" as const, note: reason },
+      } };
+    }
+
+    const phase = force ? "terminating" as const : "canceling" as const;
+    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" as const,
+        new_status: "running" as const,
+        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/src/tools/{createTask.ts → tasks/createTask.ts}

@@ -2,12 +2,12 @@ import { mkdirSync, writeFileSync, existsSync, statSync, readFileSync } from "no
 import { randomBytes } from "node:crypto";
 import { resolve, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
-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 { 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,
@@ -16,27 +16,29 @@ import {
   createAssessmentDir,
   type AssessmentRecord,
   type AgentAssessmentSummary,
-} 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";
+} 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,
   type ChangePolicy,
   type TaskTemplateName,
-} from "./taskTemplates.js";
-import { PATCHWARDEN_VERSION } from "../version.js";
-import { getLastToolCatalogSnapshot, resolveToolProfile } from "./toolCatalog.js";
+} from "../taskTemplates.js";
+import { PATCHWARDEN_VERSION, ARTIFACT_SCHEMA_VERSION } from "../../version.js";
+import { getLastToolCatalogSnapshot, resolveToolProfile } from "../catalog/toolCatalog.js";
 import {
   derivePendingReason,
   readWatcherStatus,
   type PendingReason,
   type WatcherStatusSnapshot,
-} from "../watcherStatus.js";
-import { routeAgent, type AgentRouteResult } from "../agents/agentRouter.js";
+} from "../../watcherStatus.js";
+import { routeAgent, type AgentRouteResult } from "../../agents/agentRouter.js";
+import { redactSensitiveValue } from "../../security/contentRedaction.js";
+import { atomicWriteJsonFileSync } from "../../utils/atomicFile.js";
 
 export type TaskStatus =
   | "pending"
@@ -110,6 +112,14 @@ export interface CreateTaskInput {
   // v0.8.0: Goal Session 关联
   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 {
@@ -181,9 +191,9 @@ export interface CreateTaskOutput {
   };
 }
 
-export function createTask(input: CreateTaskInput & { execution_mode: "assess_only" }): AssessOnlyOutput;
-export function createTask(input: CreateTaskInput): CreateTaskOutput;
-export function createTask(input: CreateTaskInput): CreateTaskResult {
+export function createTask(input: CreateTaskInput & { execution_mode: "assess_only" }): Promise<AssessOnlyOutput>;
+export function createTask(input: CreateTaskInput): Promise<CreateTaskOutput>;
+export async function createTask(input: CreateTaskInput): Promise<CreateTaskResult> {
   const config = getConfig();
   const tasksDir = getTasksDir(config);
   const plansDir = getPlansDir(config);
@@ -243,7 +253,7 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
 
   // Resolve repo alias if configured
   let resolvedRepoPath = effectiveInput.repo_path?.trim() || "";
-  const aliases = (config as any).repoAliases as Record<string, string> | undefined;
+  const aliases = config.repoAliases;
   if (aliases && resolvedRepoPath && aliases[resolvedRepoPath]) {
     resolvedRepoPath = aliases[resolvedRepoPath];
   }
@@ -382,7 +392,7 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
       planBlockReason = e instanceof PatchWardenError ? e.reason : "plan_content_blocked";
     }
 
-    const snapshot = captureRepoSnapshot(safeRepoPath);
+    const snapshot = await captureRepoSnapshot(safeRepoPath);
     const snapshotTruncated = snapshot.warnings.some((w) => w.includes("snapshot limited"));
 
     let riskResult;
@@ -441,7 +451,7 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
       preGeneratedAssessmentDir = createAssessmentDir(preGeneratedAssessmentId);
 
       const assessorAgentName = config.agentAssessmentAgentName || effectiveInput.agent;
-      agentAssessmentSummary = runAgentAssessment({
+      agentAssessmentSummary = await runAgentAssessment({
         assessmentId: preGeneratedAssessmentId,
         assessmentDir: preGeneratedAssessmentDir,
         agentName: assessorAgentName,
@@ -572,7 +582,7 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
 
   // ── execute mode with assessment_id: validate freshness ──
   if (assessmentRecord) {
-    const snapshot = captureRepoSnapshot(safeRepoPath);
+    const snapshot = await captureRepoSnapshot(safeRepoPath);
     const validation = validateAssessmentFreshness(input.assessment_id!, snapshot);
     if (!validation.valid) {
       throw new PatchWardenError(
@@ -589,12 +599,25 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
 
   const status: TaskStatus = "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,
@@ -611,11 +634,11 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
     current_command: null as string | null,
     error: null as string | 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 as AcceptanceStatus,
     // v0.8.0: Goal Session 关联
     goal_id: effectiveInput.goal_id ?? null,
@@ -624,7 +647,7 @@ export function createTask(input: CreateTaskInput): CreateTaskResult {
     ...(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/src/tools/{diagnoseTask.ts → tasks/diagnoseTask.ts}

@@ -1,11 +1,12 @@
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { getTasksDir, getConfig, type PatchWardenConfig } 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, type PatchWardenConfig } 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";
 
 // ── v0.7.0: Task diagnosis types ──────────────────────────────────
 
@@ -118,8 +119,7 @@ function fileAgeSeconds(filePath: string, nowMs: number): { age: number; size: n
 function readTailLines(filePath: string, lines: number): string | null {
   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 {
     return null;