patchwarden 1.5.1 → 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 {
@@ -589,12 +599,25 @@ export async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
 
   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 async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
     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 async function createTask(input: CreateTaskInput): Promise<CreateTaskResu
     ...(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;

package/src/tools/{evidencePack.ts → tasks/evidencePack.ts}

@@ -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, type SafeTaskLineage } 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 interface SafeEvidencePack {
   evidence_pack_id: string;
@@ -72,7 +74,7 @@ export function exportTaskEvidencePack(input: { lineage_id: string; max_items?:
   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 = [
@@ -99,12 +101,12 @@ export function exportTaskEvidencePack(input: { lineage_id: string; max_items?:
   };
 
   // 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}`,
@@ -133,8 +135,8 @@ export function exportTaskEvidencePack(input: { lineage_id: string; max_items?:
     bounded: true,
   }).value as SafeEvidencePack;
 
-  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;
 }
 
@@ -410,9 +412,19 @@ function buildLineageSummary(lineage: SafeTaskLineage): {
   };
 }
 
-function readGitCommitShort(): string {
+function readGitCommitShort(repoPath: string, workspaceRoot: string): string {
   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";
   }
@@ -420,7 +432,9 @@ function readGitCommitShort(): string {
 
 function buildAttestation(
   catalog: SafeEvidencePack["catalog"],
-  generatedAt: string
+  generatedAt: string,
+  repoPath: string,
+  workspaceRoot: string,
 ): {
   patchwarden_version: string;
   package_version: string;
@@ -434,7 +448,7 @@ function buildAttestation(
   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/src/tools/{getTaskFile.ts → tasks/getTaskFile.ts}

@@ -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 interface GetTaskFileOutput {

package/src/tools/{getTaskStatus.ts → tasks/getTaskStatus.ts}

@@ -1,17 +1,17 @@
 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 { getTasksDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
 import type { TaskStatus } from "./createTask.js";
 import type { TaskPhase } from "./createTask.js";
-import { readTaskRuntime } from "../taskRuntime.js";
+import { readTaskRuntime } from "../../runner/taskRuntime.js";
 import {
   derivePendingReason,
   readWatcherStatus,
   type PendingReason,
   type WatcherStatusSnapshot,
-} from "../watcherStatus.js";
+} from "../../watcherStatus.js";
 
 export interface GetTaskStatusOutput {
   task_id: string;
@@ -34,6 +34,8 @@ export interface GetTaskStatusOutput {
   finished_at?: string;
   changed_files?: Array<{ path: string; change: string }>;
   out_of_scope_changes?: Array<{ 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/src/tools/{getTaskStdoutTail.ts → tasks/getTaskStdoutTail.ts}

@@ -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: string, lines = 80) {
   const config = getConfig();
@@ -19,7 +20,10 @@ export function getTaskStdoutTail(taskId: string, 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 = "";
@@ -27,22 +31,20 @@ export function getTaskStdoutTail(taskId: string, lines = 80) {
 
   // 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");
+    if (stderrMatch && !stderrTail) stderrTail = stderrMatch[1].split("\n").slice(-stderrLines).join("\n");
     if (source === "none") source = "result.md";
   }