patchwarden 1.5.1 → 1.6.2

package/src/tools/{invokeDiscoveredTool.ts → discovery/invokeDiscoveredTool.ts}

@@ -7,13 +7,13 @@
  * 任一环节失败都记审计日志并返回错误结果，不向上层抛错。
  */
 
-import { consumeToken, type DiscoveryTokenRecord } from "../security/discoveryTokenStore.js";
-import { checkInvocation } from "../security/toolInvocationGuard.js";
-import { logToolInvocation, computeArgumentsDigest } from "../logging.js";
-import { buildToolRegistry, type PatchWardenToolMeta } from "./toolRegistry.js";
-import type { ToolProfile } from "./toolCatalog.js";
-import type { ToolDef } from "./registry.js";
-import { PatchWardenError } from "../errors.js";
+import { consumeToken, type DiscoveryTokenRecord } from "../../security/discoveryTokenStore.js";
+import { checkInvocation } from "../../security/toolInvocationGuard.js";
+import { logToolInvocation, computeArgumentsDigest } from "../../logging.js";
+import { buildToolRegistry, type PatchWardenToolMeta } from "../catalog/toolRegistry.js";
+import type { ToolProfile } from "../catalog/toolCatalog.js";
+import type { ToolDef } from "../registry.js";
+import { PatchWardenError } from "../../errors.js";
 
 // ── 类型定义 ──────────────────────────────────────────────────────
 

package/src/tools/dispatch/coreDispatch.ts

@@ -5,39 +5,44 @@
  * rewritten. Extracted from the original handleToolCallInternal switch.
  */
 
-import { savePlan } from "../savePlan.js";
-import { getPlan } from "../getPlan.js";
-import { createTask } from "../createTask.js";
-import { getTaskStatus } from "../getTaskStatus.js";
-import { getResult, getResultJson, getDiff, getTestLog, getTaskLogTail } from "../taskOutputs.js";
-import { listWorkspace } from "../listWorkspace.js";
-import { readWorkspaceFile } from "../readWorkspaceFile.js";
-import { listTasks } from "../listTasks.js";
-import { cancelTask } from "../cancelTask.js";
-import { killTask } from "../killTask.js";
-import { retryTask } from "../retryTask.js";
-import { getTaskStdoutTail } from "../getTaskStdoutTail.js";
-import { getTaskProgress } from "../getTaskProgress.js";
-import { listAgents } from "../listAgents.js";
-import { healthCheck } from "../healthCheck.js";
-import { getTaskSummary } from "../getTaskSummary.js";
-import { waitForTask } from "../waitForTask.js";
-import { runTaskLoop } from "../runTaskLoop.js";
-import { getTaskLineage } from "../taskLineage.js";
-import { exportTaskEvidencePack } from "../evidencePack.js";
-import { recommendAgentForTask } from "../recommendAgentForTask.js";
-import { auditTask } from "../auditTask.js";
-import { safeStatus } from "../safeStatus.js";
-import { safeAudit, safeDiffSummary, safeResult, safeTestSummary } from "../safeViews.js";
-import { diagnoseTask } from "../diagnoseTask.js";
-import { reconcileTasks } from "../reconcileTasks.js";
-import { checkReleaseGate } from "../checkReleaseGate.js";
-import { getProjectPolicyTool } from "../releaseMode.js";
+import { savePlan } from "../goals/savePlan.js";
+import { getPlan } from "../goals/getPlan.js";
+import { createTask } from "../tasks/createTask.js";
+import { getTaskStatus } from "../tasks/getTaskStatus.js";
+import { getResult, getResultJson, getDiff, getTestLog, getTaskLogTail } from "../tasks/taskOutputs.js";
+import { listWorkspace } from "../workspace/listWorkspace.js";
+import { readWorkspaceFile } from "../workspace/readWorkspaceFile.js";
+import { listTasks } from "../tasks/listTasks.js";
+import { cancelTask } from "../tasks/cancelTask.js";
+import { killTask } from "../tasks/killTask.js";
+import { retryTask } from "../tasks/retryTask.js";
+import { getTaskStdoutTail } from "../tasks/getTaskStdoutTail.js";
+import { getTaskProgress } from "../tasks/getTaskProgress.js";
+import { listAgents } from "../workspace/listAgents.js";
+import { healthCheck } from "../diagnostics/healthCheck.js";
+import { getTaskSummary } from "../tasks/getTaskSummary.js";
+import { waitForTask } from "../tasks/waitForTask.js";
+import { runTaskLoop } from "../tasks/runTaskLoop.js";
+import { getTaskLineage } from "../tasks/taskLineage.js";
+import { exportTaskEvidencePack } from "../tasks/evidencePack.js";
+import { recommendAgentForTask } from "../workspace/recommendAgentForTask.js";
+import { auditTask } from "../diagnostics/auditTask.js";
+import { safeStatus } from "../diagnostics/safeStatus.js";
+import { safeAudit, safeDiffSummary, safeResult, safeTestSummary } from "../diagnostics/safeViews.js";
+import { diagnoseTask } from "../tasks/diagnoseTask.js";
+import { reconcileTasks } from "../tasks/reconcileTasks.js";
+import { checkReleaseGate } from "../release/checkReleaseGate.js";
+import { getProjectPolicyTool } from "../release/releaseMode.js";
 import { runTask } from "../../runner/runTask.js";
 import { getConfig } from "../../config.js";
 import { getToolCatalogSnapshot } from "../registry.js";
 import type { ToolHandlerMap } from "./types.js";
 import { toResult } from "./types.js";
+import {
+  parseOptionalTaskTemplate,
+  parseReleaseStage,
+  parseTaskLogFile,
+} from "./validation.js";
 
 // ── Local helpers (moved verbatim from registry.ts) ───────────────
 
@@ -82,7 +87,7 @@ export const coreHandlers: ToolHandlerMap = {
         plan_id: args?.plan_id ? String(args.plan_id) : undefined,
         inline_plan: args?.inline_plan ? String(args.inline_plan) : undefined,
         plan_title: args?.plan_title ? String(args.plan_title) : undefined,
-        template: args?.template ? (String(args.template) as any) : undefined,
+        template: parseOptionalTaskTemplate(args?.template),
         goal: args?.goal ? String(args.goal) : undefined,
         source_task_id: args?.source_task_id ? String(args.source_task_id) : undefined,
         agent: String(args?.agent ?? ""),
@@ -259,7 +264,7 @@ export const coreHandlers: ToolHandlerMap = {
     return toResult(
       getTaskLogTail(
         String(args?.task_id ?? ""),
-        (args?.file as "stdout" | "stderr" | "test" | "verify") || "stdout",
+        parseTaskLogFile(args?.file),
         {
           lines: args?.lines ? Number(args.lines) : undefined,
           redact: args?.redact !== undefined ? Boolean(args.redact) : undefined,
@@ -349,7 +354,7 @@ export const coreHandlers: ToolHandlerMap = {
     return toResult(
       await checkReleaseGate({
         repo_path: String(args?.repo_path ?? ""),
-        target_stage: String(args?.target_stage ?? "local_ready") as any,
+        target_stage: parseReleaseStage(args?.target_stage),
         package_name: args?.package_name ? String(args.package_name) : undefined,
         version: args?.version ? String(args.version) : undefined,
         github_repo: args?.github_repo ? String(args.github_repo) : undefined,

package/src/tools/dispatch/diagnosticDispatch.ts

@@ -5,23 +5,25 @@
  * invoke_discovered_tool consumes a discovery token and dispatches to
  * the target tool via handleToolCall.
  *
- * Note: This module imports getToolDefs and handleToolCall from
- * registry.ts. The import is a live ESM binding resolved at runtime,
- * so the circular dependency (registry → diagnosticDispatch → registry)
- * is safe: neither binding is touched during module evaluation.
+ * The registry injects the audited dispatcher used by invoke_discovered_tool,
+ * avoiding a registry -> diagnosticDispatch -> registry import cycle.
  */
 
-import { discoverTools } from "../discoverTools.js";
-import { explainTool } from "../explainTool.js";
-import { invokeDiscoveredTool } from "../invokeDiscoveredTool.js";
+import { discoverTools } from "../discovery/discoverTools.js";
+import { explainTool } from "../discovery/explainTool.js";
+import { invokeDiscoveredTool } from "../discovery/invokeDiscoveredTool.js";
 import { getConfig } from "../../config.js";
-import { resolveToolProfile } from "../toolCatalog.js";
-import { getToolDefs, handleToolCall } from "../registry.js";
+import { resolveToolProfile } from "../catalog/toolCatalog.js";
+import type { ToolRisk } from "../catalog/toolRegistry.js";
+import { getToolDefs } from "../definitions/toolDefs.js";
 import type { ToolHandlerMap } from "./types.js";
 import { toResult } from "./types.js";
 
-export const diagnosticHandlers: ToolHandlerMap = {
-  discover_tools: async (args) => {
+export function buildDiagnosticHandlers(
+  dispatchTool: (name: string, args: Record<string, unknown> | undefined) => Promise<unknown>,
+): ToolHandlerMap {
+  return {
+    discover_tools: async (args) => {
     const profile =
       args?.profile === "full" ||
       args?.profile === "chatgpt_core" ||
@@ -37,15 +39,17 @@ export const diagnosticHandlers: ToolHandlerMap = {
       args?.mode === "diagnostic"
         ? args.mode
         : undefined;
-    const riskCeiling = [
+    const riskCeilings = new Set<string>([
       "readonly",
       "workspace_read_sensitive",
       "workspace_write",
       "command",
       "release",
       "credential_sensitive",
-    ].includes(String(args?.riskCeiling ?? ""))
-      ? (String(args?.riskCeiling) as any)
+    ]);
+    const requestedRiskCeiling = String(args?.riskCeiling ?? "");
+    const riskCeiling = riskCeilings.has(requestedRiskCeiling)
+      ? (requestedRiskCeiling as ToolRisk)
       : undefined;
     return toResult(
       discoverTools(
@@ -61,9 +65,9 @@ export const diagnosticHandlers: ToolHandlerMap = {
         getToolDefs(),
       ),
     );
-  },
+    },
 
-  explain_tool: async (args) => {
+    explain_tool: async (args) => {
     return toResult(
       explainTool(
         {
@@ -74,9 +78,9 @@ export const diagnosticHandlers: ToolHandlerMap = {
         getToolDefs(),
       ),
     );
-  },
+    },
 
-  invoke_discovered_tool: async (args) => {
+    invoke_discovered_tool: async (args) => {
     const profile = resolveToolProfile(getConfig().toolProfile);
     const result = await invokeDiscoveredTool(
       {
@@ -92,10 +96,11 @@ export const diagnosticHandlers: ToolHandlerMap = {
         tools: getToolDefs(),
         profile,
         dispatch: async (name, dispatchArgs) => {
-          return handleToolCall(name, dispatchArgs);
+          return dispatchTool(name, dispatchArgs);
         },
       },
     );
     return toResult(result);
-  },
-};
+    },
+  };
+}

package/src/tools/dispatch/directDispatch.ts

@@ -7,21 +7,22 @@
 
 import { getConfig } from "../../config.js";
 import { PatchWardenError } from "../../errors.js";
-import { createDirectSession } from "../createDirectSession.js";
-import { searchWorkspace } from "../searchWorkspace.js";
-import { applyPatch } from "../applyPatch.js";
-import { runVerification } from "../runVerification.js";
-import { runDirectVerificationBundle } from "../runDirectVerificationBundle.js";
-import { finalizeDirectSession } from "../finalizeDirectSession.js";
-import { auditSession } from "../auditSession.js";
-import { syncFile } from "../syncFile.js";
+import { createDirectSession } from "../direct/createDirectSession.js";
+import { searchWorkspace } from "../workspace/searchWorkspace.js";
+import { applyPatch } from "../workspace/applyPatch.js";
+import { runVerification } from "../tasks/runVerification.js";
+import { runDirectVerificationBundle } from "../direct/runDirectVerificationBundle.js";
+import { finalizeDirectSession } from "../direct/finalizeDirectSession.js";
+import { auditSession } from "../diagnostics/auditSession.js";
+import { syncFile } from "../workspace/syncFile.js";
 import {
   safeAuditDirectSession,
   safeDirectSummary,
   safeFinalizeDirectSession,
-} from "../safeViews.js";
+} from "../diagnostics/safeViews.js";
 import type { ToolHandlerMap } from "./types.js";
 import { toResult } from "./types.js";
+import { parsePatchOperations } from "./validation.js";
 
 /** Mirror of guardDirectProfileEnabled from the original registry.ts. */
 function guardDirectProfileEnabled(): void {
@@ -72,7 +73,7 @@ export const directHandlers: ToolHandlerMap = {
         session_id: String(args?.session_id ?? ""),
         path: String(args?.path ?? ""),
         expected_sha256: String(args?.expected_sha256 ?? ""),
-        operations: Array.isArray(args?.operations) ? (args.operations as any) : [],
+        operations: parsePatchOperations(args?.operations),
       }),
     );
   },

package/src/tools/dispatch/goalDispatch.ts

@@ -11,11 +11,12 @@ import { exportHandoff } from "../../goal/handoffExport.js";
 import { acceptSubgoal, rejectSubgoal, summarizeGoalProgress } from "../../goal/goalProgress.js";
 import { exportGoalReport } from "../../goal/goalReport.js";
 import { importSpecKitTasks, parseSpecKitJson } from "../../goal/specKitImport.js";
-import { createSubgoalTask } from "../goalSubgoalTask.js";
-import { mergeWorktreeTool } from "../mergeWorktree.js";
-import { discardWorktreeTool } from "../discardWorktree.js";
+import { createSubgoalTask } from "../goals/goalSubgoalTask.js";
+import { mergeWorktreeTool } from "../workspace/mergeWorktree.js";
+import { discardWorktreeTool } from "../workspace/discardWorktree.js";
 import type { ToolHandlerMap } from "./types.js";
 import { toResult } from "./types.js";
+import { parseOptionalTaskTemplate } from "./validation.js";
 
 export const goalHandlers: ToolHandlerMap = {
   create_goal: async (args) => {
@@ -45,7 +46,7 @@ export const goalHandlers: ToolHandlerMap = {
         plan_id: args?.plan_id ? String(args.plan_id) : undefined,
         inline_plan: args?.inline_plan ? String(args.inline_plan) : undefined,
         plan_title: args?.plan_title ? String(args.plan_title) : undefined,
-        template: args?.template ? (String(args.template) as any) : undefined,
+        template: parseOptionalTaskTemplate(args?.template),
         goal: args?.goal ? String(args.goal) : undefined,
         agent: args?.agent ? String(args.agent) : undefined,
         repo_path: String(args?.repo_path ?? ""),

package/src/tools/dispatch/releaseDispatch.ts

@@ -10,16 +10,17 @@ import {
   releasePrepare,
   releaseVerify,
   releaseCleanup,
-} from "../releaseMode.js";
+} from "../release/releaseMode.js";
 import type { ToolHandlerMap } from "./types.js";
 import { toResult } from "./types.js";
+import { parseReleaseStage } from "./validation.js";
 
 export const releaseHandlers: ToolHandlerMap = {
   release_check: async (args) => {
     return toResult(
       await releaseCheck({
         repo_path: String(args?.repo_path ?? ""),
-        target_stage: String(args?.target_stage ?? "local_ready") as any,
+        target_stage: parseReleaseStage(args?.target_stage),
         package_name: args?.package_name ? String(args.package_name) : undefined,
         version: args?.version ? String(args.version) : undefined,
         github_repo: args?.github_repo ? String(args.github_repo) : undefined,

package/src/tools/dispatch/validation.ts

@@ -0,0 +1,78 @@
+import type { PatchOperation, PatchOperationType } from "../../direct/directPatch.js";
+import type { ReleaseStage } from "../../release/releaseGate.js";
+import { TASK_TEMPLATE_NAMES, type TaskTemplateName } from "../taskTemplates.js";
+
+const RELEASE_STAGES: ReadonlySet<ReleaseStage> = new Set([
+  "local_ready",
+  "packed_ready",
+  "published_verified",
+  "github_release_verified",
+  "ci_verified",
+]);
+const PATCH_OPERATION_TYPES: ReadonlySet<PatchOperationType> = new Set([
+  "replace_exact",
+  "insert_before",
+  "insert_after",
+  "replace_whole_file",
+]);
+const PATCH_OCCURRENCES = new Set(["first", "all", "exactly_once"]);
+const TASK_LOG_FILES = new Set(["stdout", "stderr", "test", "verify"]);
+
+export function parseOptionalTaskTemplate(value: unknown): TaskTemplateName | undefined {
+  if (value === undefined || value === null || value === "") return undefined;
+  if (typeof value !== "string" || !TASK_TEMPLATE_NAMES.includes(value as TaskTemplateName)) {
+    throw new Error(`template must be one of: ${TASK_TEMPLATE_NAMES.join(", ")}`);
+  }
+  return value as TaskTemplateName;
+}
+
+export function parseReleaseStage(value: unknown): ReleaseStage {
+  const stage = value === undefined || value === null || value === ""
+    ? "local_ready"
+    : String(value);
+  if (!RELEASE_STAGES.has(stage as ReleaseStage)) {
+    throw new Error(`target_stage must be one of: ${[...RELEASE_STAGES].join(", ")}`);
+  }
+  return stage as ReleaseStage;
+}
+
+export function parseTaskLogFile(value: unknown): "stdout" | "stderr" | "test" | "verify" {
+  const file = value === undefined || value === null || value === "" ? "stdout" : String(value);
+  if (!TASK_LOG_FILES.has(file)) {
+    throw new Error(`file must be one of: ${[...TASK_LOG_FILES].join(", ")}`);
+  }
+  return file as "stdout" | "stderr" | "test" | "verify";
+}
+
+export function parsePatchOperations(value: unknown): PatchOperation[] {
+  if (!Array.isArray(value)) throw new Error("operations must be an array");
+  return value.map((entry, index) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+      throw new Error(`operations[${index}] must be an object`);
+    }
+    const record = entry as Record<string, unknown>;
+    if (typeof record.type !== "string" || !PATCH_OPERATION_TYPES.has(record.type as PatchOperationType)) {
+      throw new Error(`operations[${index}].type is invalid`);
+    }
+    if (typeof record.new_text !== "string") {
+      throw new Error(`operations[${index}].new_text must be a string`);
+    }
+    if (record.old_text !== undefined && typeof record.old_text !== "string") {
+      throw new Error(`operations[${index}].old_text must be a string`);
+    }
+    if (
+      record.occurrence !== undefined
+      && (typeof record.occurrence !== "string" || !PATCH_OCCURRENCES.has(record.occurrence))
+    ) {
+      throw new Error(`operations[${index}].occurrence is invalid`);
+    }
+    return {
+      type: record.type as PatchOperationType,
+      new_text: record.new_text,
+      ...(record.old_text === undefined ? {} : { old_text: record.old_text }),
+      ...(record.occurrence === undefined
+        ? {}
+        : { occurrence: record.occurrence as PatchOperation["occurrence"] }),
+    };
+  });
+}

package/src/tools/{getPlan.ts → goals/getPlan.ts}

@@ -1,9 +1,9 @@
 import { readFileSync, existsSync } from "node:fs";
 import { resolve, join } from "node:path";
-import { getPlansDir, getConfig } from "../config.js";
-import { guardReadPath } from "../security/pathGuard.js";
-import { guardSensitivePath } from "../security/sensitiveGuard.js";
-import { redactSensitiveContent } from "../security/contentRedaction.js";
+import { getPlansDir, getConfig } from "../../config.js";
+import { guardReadPath } from "../../security/pathGuard.js";
+import { guardSensitivePath } from "../../security/sensitiveGuard.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
 
 export interface GetPlanInput {
   plan_id: string;

package/src/tools/{goalSubgoalTask.ts → goals/goalSubgoalTask.ts}

@@ -14,12 +14,14 @@
  *   - createTask 内部使用 getConfig()，因此 workspaceRoot 由全局配置决定。
  */
 
-import { readGoalStatus, writeGoalStatus } from "../goal/goalStore.js";
-import { addSubgoal, linkTaskToSubgoal, updateSubgoalStatus, type Subgoal } from "../goal/goalStatus.js";
-import { createTask, type CreateTaskInput } from "./createTask.js";
-import { createWorktree, discardWorktree } from "../goal/worktreeManager.js";
-import { getConfig } from "../config.js";
-import { PatchWardenError } from "../errors.js";
+import { mutateGoalStatusAsync } from "../../goal/goalStore.js";
+import { addSubgoal, linkTaskToSubgoal, updateSubgoalStatus, type Subgoal } from "../../goal/goalStatus.js";
+import { createTask, type CreateTaskInput } from "../tasks/createTask.js";
+import { createWorktree, discardWorktree } from "../../goal/worktreeManager.js";
+import { getConfig } from "../../config.js";
+import { PatchWardenError } from "../../errors.js";
+import { guardWorkspacePath } from "../../security/pathGuard.js";
+import { resolve } from "node:path";
 
 // ── 类型定义 ──────────────────────────────────────────────────────
 
@@ -76,17 +78,30 @@ export async function createSubgoalTask(input: CreateSubgoalTaskInput): Promise<
     );
   }
 
-  // 1. 读取 goal_status.json，如果不存在抛 goal_not_found
-  let goalStatus;
-  try {
-    goalStatus = readGoalStatus(input.goal_id);
-  } catch {
+  const config = getConfig();
+  return mutateGoalStatusAsync(input.goal_id, async (goalStatus) => {
+  if (goalStatus.status !== "active") {
+    throw new PatchWardenError(
+      "goal_not_active",
+      `Goal "${input.goal_id}" is ${goalStatus.status} and cannot accept new subgoals.`,
+      "Create a new Goal Session for additional work.",
+      true,
+      { goal_id: input.goal_id, status: goalStatus.status },
+    );
+  }
+
+  const goalRepoPath = guardWorkspacePath(goalStatus.repo_path, config.workspaceRoot);
+  const requestedRepoPath = guardWorkspacePath(input.repo_path, config.workspaceRoot);
+  const sameRepo = process.platform === "win32"
+    ? resolve(goalRepoPath).toLowerCase() === resolve(requestedRepoPath).toLowerCase()
+    : resolve(goalRepoPath) === resolve(requestedRepoPath);
+  if (!sameRepo) {
     throw new PatchWardenError(
-      "goal_not_found",
-      `Goal "${input.goal_id}" not found`,
-      "Call list_goals to see available goals.",
+      "goal_repo_mismatch",
+      `Subgoal repo_path does not match Goal "${input.goal_id}".`,
+      "Use the repo_path recorded on the Goal Session.",
       true,
-      { goal_id: input.goal_id }
+      { goal_id: input.goal_id },
     );
   }
 
@@ -101,11 +116,10 @@ export async function createSubgoalTask(input: CreateSubgoalTaskInput): Promise<
   //     用 worktree 路径作为 createTask 的 repo_path，避免并发 task 互相污染。
   //     isolate_worktree === false 时退化为原行为（使用 input.repo_path）。
   const isolate = input.isolate_worktree !== false;
-  let repoPathForTask = input.repo_path;
+  let repoPathForTask = goalRepoPath;
   let worktreeId: string | null = null;
   if (isolate) {
-    const workspaceRoot = getConfig().workspaceRoot;
-    const wt = createWorktree(input.goal_id, subgoalId, workspaceRoot);
+    const wt = createWorktree(input.goal_id, subgoalId, goalRepoPath);
     repoPathForTask = wt.worktreePath;
     worktreeId = wt.worktreeId;
   }
@@ -139,7 +153,7 @@ export async function createSubgoalTask(input: CreateSubgoalTaskInput): Promise<
     // createTask 失败：清理已创建的隔离 worktree，避免遗留半成品（best effort）
     if (isolate && worktreeId) {
       try {
-        discardWorktree(worktreeId, getConfig().workspaceRoot);
+        discardWorktree(worktreeId, goalRepoPath);
       } catch { /* ignore cleanup failure，向上抛出原始 createTask 错误 */ }
     }
     throw createTaskErr;
@@ -153,18 +167,19 @@ export async function createSubgoalTask(input: CreateSubgoalTaskInput): Promise<
   if (isolate && worktreeId) {
     const newSubgoals: Subgoal[] = withRunning.subgoals.map((s) =>
       s.id === subgoalId
-        ? ({ ...s, worktree_id: worktreeId } as Subgoal)
+        ? { ...s, worktree_id: worktreeId }
         : s
     );
     withRunning = { ...withRunning, subgoals: newSubgoals };
   }
 
-  // 5. 写回 goal_status.json
-  writeGoalStatus(input.goal_id, withRunning);
-
   return {
-    subgoal_id: subgoalId,
-    task_id: taskId,
-    subgoal_status: "running",
+    next: withRunning,
+    result: {
+      subgoal_id: subgoalId,
+      task_id: taskId,
+      subgoal_status: "running" as const,
+    },
   };
+  });
 }

package/src/tools/goals/index.ts

@@ -0,0 +1,3 @@
+export * from "./getPlan.js";
+export * from "./goalSubgoalTask.js";
+export * from "./savePlan.js";

package/src/tools/{savePlan.ts → goals/savePlan.ts}

@@ -1,9 +1,15 @@
-import { mkdirSync, writeFileSync, existsSync, readFileSync } from "node:fs";
+import { mkdirSync, existsSync, readFileSync, statSync } from "node:fs";
 import { resolve, join, relative } from "node:path";
-import { getPlansDir, getConfig } from "../config.js";
-import { guardPath } from "../security/pathGuard.js";
-import { guardPlanContent } from "../security/planGuard.js";
-import { PatchWardenError } from "../errors.js";
+import { randomBytes } from "node:crypto";
+import { getPlansDir, getConfig } from "../../config.js";
+import { guardPath } from "../../security/pathGuard.js";
+import { guardPlanContent } from "../../security/planGuard.js";
+import { PatchWardenError } from "../../errors.js";
+import { redactSensitiveContent } from "../../security/contentRedaction.js";
+import { atomicWriteFileSync } from "../../utils/atomicFile.js";
+
+const MAX_PLAN_BYTES = 1024 * 1024;
+const MAX_PLAN_TITLE_CHARS = 500;
 
 export interface SavePlanInput {
   title: string;
@@ -49,6 +55,14 @@ export function savePlan(input: SavePlanInput): SavePlanOutput {
         { plan_ref: input.plan_ref }
       );
     }
+    const planMetadata = statSync(targetPath);
+    if (!planMetadata.isFile() || planMetadata.size > MAX_PLAN_BYTES) {
+      throw new PatchWardenError(
+        "plan_content_too_large",
+        `plan_ref must point to a regular file no larger than ${MAX_PLAN_BYTES} bytes.`,
+        "Use a smaller plan file under .patchwarden/plans/.",
+      );
+    }
     content = readFileSync(targetPath, "utf-8");
     if (!title || title.trim() === "") {
       title = "Plan from file";
@@ -71,16 +85,32 @@ export function savePlan(input: SavePlanInput): SavePlanOutput {
 
   guardPlanContent(title, content);
 
-  const planId = `plan_${Date.now()}_${sanitizeTitle(title)}`;
+  if (Buffer.byteLength(content, "utf-8") > MAX_PLAN_BYTES) {
+    throw new PatchWardenError(
+      "plan_content_too_large",
+      `Plan content exceeds the ${MAX_PLAN_BYTES}-byte limit.`,
+      "Split the work into smaller plans.",
+    );
+  }
+  title = redactSensitiveContent(title)
+    .content
+    .replace(/[\r\n\t]+/g, " ")
+    .trim()
+    .slice(0, MAX_PLAN_TITLE_CHARS) || "Inline plan";
+  content = redactSensitiveContent(content).content;
+
+  const planId = `plan_${Date.now()}_${sanitizeTitle(title)}_${randomBytes(4).toString("hex")}`;
   const planDir = resolve(plansDir, planId);
 
   // Guards: plan dir & file must stay inside workspace
+  guardPath(plansDir, config.workspaceRoot, config.plansDir);
+  mkdirSync(plansDir, { recursive: true });
   guardPath(planDir, config.workspaceRoot, config.plansDir);
-  mkdirSync(planDir, { recursive: true });
+  mkdirSync(planDir);
 
   const planFile = join(planDir, "plan.md");
   const header = `# ${title}\n\n> Plan ID: ${planId}\n> Created: ${new Date().toISOString()}\n\n`;
-  writeFileSync(planFile, header + content, "utf-8");
+  atomicWriteFileSync(planFile, header + content);
 
   return {
     plan_id: planId,