patchwarden 1.5.1 → 1.6.1

package/src/goal/acceptanceEngine.ts

@@ -13,7 +13,7 @@
  *   4. 所有检查通过 → ACCEPTED
  */
 
-import type { AcceptanceStatus } from "../tools/createTask.js";
+import type { AcceptanceStatus } from "../tools/tasks/createTask.js";
 
 // ── 类型定义 ──────────────────────────────────────────────────────
 

package/src/goal/goalProgress.ts

@@ -15,7 +15,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { isAbsolute, join } from "node:path";
 import { getConfig } from "../config.js";
 import { PatchWardenError } from "../errors.js";
-import { readGoalStatus, writeGoalStatus } from "./goalStore.js";
+import { mutateGoalStatus, readGoalStatus } from "./goalStore.js";
 import { updateSubgoalStatus, type GoalStatus, type Subgoal } from "./goalStatus.js";
 import { getBlockedSubgoals } from "./goalGraph.js";
 
@@ -93,7 +93,7 @@ export function acceptSubgoal(
   subgoalId: string,
   workspaceRoot?: string
 ): { subgoal_id: string; status: "accepted"; accepted_at: string } {
-  const goalStatus = readGoalStatus(goalId, workspaceRoot);
+  return mutateGoalStatus(goalId, (goalStatus) => {
 
   const subgoal = goalStatus.subgoals.find((s) => s.id === subgoalId);
   if (!subgoal) {
@@ -146,14 +146,16 @@ export function acceptSubgoal(
   // 校验 3：通过状态机转换（要求 subgoal 当前为 done_by_agent）
   const updatedGoalStatus = updateSubgoalStatus(goalStatus, subgoalId, "accepted");
 
-  writeGoalStatus(goalId, updatedGoalStatus, workspaceRoot);
-
   const updatedSubgoal = updatedGoalStatus.subgoals.find((s) => s.id === subgoalId)!;
   return {
-    subgoal_id: subgoalId,
-    status: "accepted",
-    accepted_at: updatedSubgoal.accepted_at!,
+    next: updatedGoalStatus,
+    result: {
+      subgoal_id: subgoalId,
+      status: "accepted" as const,
+      accepted_at: updatedSubgoal.accepted_at!,
+    },
   };
+  }, workspaceRoot);
 }
 
 /**
@@ -175,7 +177,7 @@ export function rejectSubgoal(
   reason: string,
   workspaceRoot?: string
 ): { subgoal_id: string; status: "rejected"; rejected_reason: string } {
-  const goalStatus = readGoalStatus(goalId, workspaceRoot);
+  return mutateGoalStatus(goalId, (goalStatus) => {
 
   const index = goalStatus.subgoals.findIndex((s) => s.id === subgoalId);
   if (index === -1) {
@@ -222,13 +224,15 @@ export function rejectSubgoal(
     updated_at: new Date().toISOString(),
   };
 
-  writeGoalStatus(goalId, updatedGoalStatus, workspaceRoot);
-
   return {
-    subgoal_id: subgoalId,
-    status: "rejected",
-    rejected_reason: reason,
+    next: updatedGoalStatus,
+    result: {
+      subgoal_id: subgoalId,
+      status: "rejected" as const,
+      rejected_reason: reason,
+    },
   };
+  }, workspaceRoot);
 }
 
 /**

package/src/goal/goalReport.ts

@@ -6,11 +6,12 @@
  * 所有写入操作使用原子写（.tmp + rename），所有字符串内容经 redactSensitiveValue 脱敏。
  */
 
-import { mkdirSync, renameSync, writeFileSync } from "node:fs";
+import { mkdirSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { getConfig } from "../config.js";
 import { redactSensitiveValue } from "../security/contentRedaction.js";
-import { listEvidencePacks } from "../tools/evidencePack.js";
+import { listEvidencePacks } from "../tools/tasks/evidencePack.js";
+import { atomicWriteFileSync } from "../utils/atomicFile.js";
 import { summarizeGoalProgress, type GoalProgressSummary } from "./goalProgress.js";
 import { readGoalStatus } from "./goalStore.js";
 
@@ -45,15 +46,6 @@ function resolveWorkspaceRoot(workspaceRoot?: string): string {
   return workspaceRoot ?? getConfig().workspaceRoot;
 }
 
-/**
- * 原子写文件：先写到 .tmp 文件，再 renameSync 到目标路径。
- */
-function atomicWriteFile(filePath: string, content: string): void {
-  const tmpPath = filePath + ".tmp";
-  writeFileSync(tmpPath, content, "utf-8");
-  renameSync(tmpPath, filePath);
-}
-
 /**
  * 将百分比字符串（如 "100%"）解析为数字。
  */
@@ -261,11 +253,11 @@ export function exportGoalReport(
   const safeReport = redactSensitiveValue(rawReport).value as SafeGoalReport;
 
   // 原子写 JSON（机器可读）
-  atomicWriteFile(reportJsonPath, JSON.stringify(safeReport, null, 2) + "\n");
+  atomicWriteFileSync(reportJsonPath, JSON.stringify(safeReport, null, 2) + "\n");
 
   // 原子写 Markdown（人类可读，从脱敏后的对象生成）
   const markdown = buildReportMarkdown(safeReport, { noSubgoals, incomplete });
-  atomicWriteFile(reportMdPath, markdown);
+  atomicWriteFileSync(reportMdPath, markdown);
 
   return safeReport;
 }

package/src/goal/goalStatus.ts

@@ -12,6 +12,7 @@
  */
 
 import { PatchWardenError } from "../errors.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
 
 // ── 类型定义 ──────────────────────────────────────────────────────
 
@@ -35,6 +36,8 @@ export interface Subgoal {
   external_ref?: string;
   /** Spec Kit task.files 提示（作用域文件路径列表） */
   scope_hints?: string[];
+  /** Managed git worktree associated with an isolated subgoal task. */
+  worktree_id?: string;
 }
 
 export interface GoalStatus {
@@ -74,7 +77,7 @@ export function createInitialGoalStatus(
   const now = new Date().toISOString();
   return {
     goal_id: goalId,
-    title,
+    title: redactGoalText(title, 500),
     status: "active",
     repo_path: repoPath,
     created_at: now,
@@ -94,6 +97,15 @@ export function addSubgoal(
   title: string,
   dependsOn: string[] = []
 ): { goalStatus: GoalStatus; subgoalId: string } {
+  if (goalStatus.status !== "active") {
+    throw new PatchWardenError(
+      "goal_not_active",
+      `Goal "${goalStatus.goal_id}" is ${goalStatus.status} and cannot accept new subgoals.`,
+      "Create a new Goal Session for additional work.",
+      true,
+      { goal_id: goalStatus.goal_id, status: goalStatus.status },
+    );
+  }
   const existingIds = new Set(goalStatus.subgoals.map((s) => s.id));
   for (const depId of dependsOn) {
     if (!existingIds.has(depId)) {
@@ -111,7 +123,7 @@ export function addSubgoal(
   const subgoalId = `subgoal-${String(nextNumber).padStart(3, "0")}`;
   const newSubgoal: Subgoal = {
     id: subgoalId,
-    title,
+    title: redactGoalText(title, 500),
     status: "ready",
     depends_on: [...dependsOn],
     task_ids: [],
@@ -185,7 +197,7 @@ export function updateSubgoalStatus(
         { subgoal_id: subgoalId, from_status: current.status, to_status: newStatus }
       );
     }
-    updatedSubgoal.rejected_reason = options.rejected_reason;
+    updatedSubgoal.rejected_reason = redactGoalText(options.rejected_reason, 2000);
   }
 
   const newSubgoals = [...goalStatus.subgoals];
@@ -198,6 +210,10 @@ export function updateSubgoalStatus(
   };
 }
 
+function redactGoalText(value: string, maxChars: number): string {
+  return redactSensitiveContent(String(value || "")).content.slice(0, maxChars);
+}
+
 /**
  * 将 taskId 关联到指定 subgoal（去重）。
  * 不可变更新：返回新的 GoalStatus 对象。

package/src/goal/goalStore.ts

@@ -18,14 +18,20 @@ import {
   mkdirSync,
   readdirSync,
   readFileSync,
-  renameSync,
-  writeFileSync,
   statSync,
 } from "node:fs";
 import { join } from "node:path";
 import { getConfig } from "../config.js";
-import { guardWorkspacePath } from "../security/pathGuard.js";
+import { guardPath, guardWorkspacePath } from "../security/pathGuard.js";
 import { PatchWardenError } from "../errors.js";
+import { atomicWriteFileSync, atomicWriteJsonFileSync } from "../utils/atomicFile.js";
+import { redactSensitiveContent } from "../security/contentRedaction.js";
+import {
+  mutateLockedJsonFileSync,
+  readJsonObjectFileSync,
+  withFileLock,
+  withFileLockSync,
+} from "../utils/lockedJsonFile.js";
 import {
   type GoalStatus,
   type Subgoal,
@@ -38,6 +44,26 @@ function resolveWorkspaceRoot(workspaceRoot?: string): string {
   return workspaceRoot ?? getConfig().workspaceRoot;
 }
 
+const GOALS_PREFIX = join(".patchwarden", "goals");
+const GOAL_ID_MAX_LENGTH = 128;
+const GOAL_ID_PATTERN = /^goal_[A-Za-z0-9][A-Za-z0-9_-]*$/;
+
+/** Validate the storage key before it can participate in path construction. */
+export function assertValidGoalId(goalId: string): void {
+  if (
+    goalId.length > GOAL_ID_MAX_LENGTH ||
+    !GOAL_ID_PATTERN.test(goalId)
+  ) {
+    throw new PatchWardenError(
+      "invalid_goal_id",
+      `Invalid goal id. Expected "goal_" followed by at most ${GOAL_ID_MAX_LENGTH - 5} ASCII letters, digits, underscores, or hyphens.`,
+      "Use the goal_id returned by create_goal or list_goals.",
+      true,
+      { goal_id_length: goalId.length }
+    );
+  }
+}
+
 // ── Goal ID 生成 ──────────────────────────────────────────────────
 
 /**
@@ -86,14 +112,17 @@ export function generateGoalId(title: string, existingIds: string[]): string {
  * 不自动创建目录。
  */
 export function getGoalsDir(workspaceRoot?: string): string {
-  return join(resolveWorkspaceRoot(workspaceRoot), ".patchwarden", "goals");
+  const wsRoot = resolveWorkspaceRoot(workspaceRoot);
+  return guardPath(join(wsRoot, GOALS_PREFIX), wsRoot, GOALS_PREFIX);
 }
 
 /**
  * 返回 `{getGoalsDir()}/{goalId}` 路径。
  */
 export function getGoalDir(goalId: string, workspaceRoot?: string): string {
-  return join(getGoalsDir(workspaceRoot), goalId);
+  assertValidGoalId(goalId);
+  const wsRoot = resolveWorkspaceRoot(workspaceRoot);
+  return guardPath(join(getGoalsDir(wsRoot), goalId), wsRoot, GOALS_PREFIX);
 }
 
 // ── CRUD ──────────────────────────────────────────────────────────
@@ -112,12 +141,26 @@ export function createGoal(
   description: string,
   workspaceRoot?: string
 ): { goal_id: string; goal_dir: string } {
+  const safeTitle = redactSensitiveContent(title)
+    .content
+    .replace(/[\r\n\t]+/g, " ")
+    .trim()
+    .slice(0, 500) || "Untitled goal";
+  const safeDescription = redactSensitiveContent(description).content;
+  if (Buffer.byteLength(safeDescription, "utf-8") > 1024 * 1024) {
+    throw new PatchWardenError(
+      "goal_description_too_large",
+      "Goal description exceeds the 1 MiB limit.",
+      "Split the work into smaller Goal Sessions.",
+    );
+  }
   const wsRoot = resolveWorkspaceRoot(workspaceRoot);
   const guardedRepo = guardWorkspacePath(repoPath, wsRoot);
 
   const goalsDir = getGoalsDir(workspaceRoot);
-  const existingIds: string[] = [];
-  if (existsSync(goalsDir)) {
+  mkdirSync(goalsDir, { recursive: true });
+  return withFileLockSync(join(goalsDir, "goal-creation"), () => {
+    const existingIds: string[] = [];
     for (const entry of readdirSync(goalsDir)) {
       const entryPath = join(goalsDir, entry);
       try {
@@ -125,45 +168,38 @@ export function createGoal(
           existingIds.push(entry);
         }
       } catch {
-        // 跳过无法 stat 的条目
+        // Skip entries that cannot be inspected.
       }
     }
-  }
 
-  const goalId = generateGoalId(title, existingIds);
-  const goalDir = join(goalsDir, goalId);
-
-  // 创建目录结构
-  mkdirSync(join(goalDir, "tasks"), { recursive: true });
-  mkdirSync(join(goalDir, "artifacts"), { recursive: true });
-
-  // 写入 GOAL.md
-  const now = new Date().toISOString();
-  const goalMd = [
-    `# ${title}`,
-    "",
-    description,
-    "",
-    `- Created: ${now}`,
-    `- Repo: ${guardedRepo}`,
-    "- Status: active",
-    "",
-  ].join("\n");
-  writeFileSync(join(goalDir, "GOAL.md"), goalMd, "utf-8");
-
-  // 写入 GOALS.md
-  const goalsMd = `# Subgoals: ${title}\n\n_No subgoals yet._\n`;
-  writeFileSync(join(goalDir, "GOALS.md"), goalsMd, "utf-8");
-
-  // 写入 goal_status.json
-  const status = createInitialGoalStatus(goalId, title, guardedRepo);
-  writeFileSync(
-    join(goalDir, "goal_status.json"),
-    JSON.stringify(status, null, 2) + "\n",
-    "utf-8"
-  );
+    const goalId = generateGoalId(safeTitle, existingIds);
+    const goalDir = getGoalDir(goalId, wsRoot);
+
+    mkdirSync(goalDir);
+    mkdirSync(join(goalDir, "tasks"));
+    mkdirSync(join(goalDir, "artifacts"));
+
+    const now = new Date().toISOString();
+    const goalMd = [
+      `# ${safeTitle}`,
+      "",
+      safeDescription,
+      "",
+      `- Created: ${now}`,
+      `- Repo: ${guardedRepo}`,
+      "- Status: active",
+      "",
+    ].join("\n");
+    atomicWriteFileSync(join(goalDir, "GOAL.md"), goalMd);
+
+    const goalsMd = `# Subgoals: ${safeTitle}\n\n_No subgoals yet._\n`;
+    atomicWriteFileSync(join(goalDir, "GOALS.md"), goalsMd);
+
+    const status = createInitialGoalStatus(goalId, safeTitle, guardedRepo);
+    atomicWriteJsonFileSync(join(goalDir, "goal_status.json"), status);
 
-  return { goal_id: goalId, goal_dir: goalDir };
+    return { goal_id: goalId, goal_dir: goalDir };
+  }, goalBusyOptions("creation"));
 }
 
 /**
@@ -197,8 +233,8 @@ export function listGoals(
   }> = [];
 
   for (const entry of readdirSync(goalsDir)) {
-    const entryPath = join(goalsDir, entry);
     try {
+      const entryPath = getGoalDir(entry, workspaceRoot);
       if (!statSync(entryPath).isDirectory()) {
         continue;
       }
@@ -254,7 +290,12 @@ export function readGoal(
   let goalDescription = "";
   const goalMdPath = join(goalDir, "GOAL.md");
   if (existsSync(goalMdPath)) {
-    goalDescription = readFileSync(goalMdPath, "utf-8");
+    const safeGoalMdPath = guardPath(
+      goalMdPath,
+      resolveWorkspaceRoot(workspaceRoot),
+      GOALS_PREFIX,
+    );
+    goalDescription = readFileSync(safeGoalMdPath, "utf-8");
   }
 
   return {
@@ -270,8 +311,7 @@ export function readGoal(
 }
 
 /**
- * 原子写入 goal_status.json：先写到 .tmp 文件，再 renameSync。
- * JSON 序列化用 JSON.stringify(status, null, 2) + 末尾换行。
+ * Replace goal_status.json under the shared cross-process mutation lock.
  */
 export function writeGoalStatus(
   goalId: string,
@@ -279,10 +319,26 @@ export function writeGoalStatus(
   workspaceRoot?: string
 ): void {
   const goalDir = getGoalDir(goalId, workspaceRoot);
-  const finalPath = join(goalDir, "goal_status.json");
-  const tmpPath = join(goalDir, "goal_status.json.tmp");
-  writeFileSync(tmpPath, JSON.stringify(status, null, 2) + "\n", "utf-8");
-  renameSync(tmpPath, finalPath);
+  if (!existsSync(goalDir)) {
+    throw new PatchWardenError(
+      "goal_not_found",
+      `Goal directory not found: "${goalDir}"`,
+      "Ensure the goal has been created before writing its status.",
+      true,
+      { goal_id: goalId, goal_dir: goalDir },
+    );
+  }
+  const statusPath = getGoalStatusPath(goalId, workspaceRoot);
+  if (!existsSync(statusPath)) {
+    withFileLockSync(statusPath, () => {
+      atomicWriteJsonFileSync(
+        statusPath,
+        normalizeGoalLifecycle(validateGoalStatus(goalId, status, workspaceRoot)),
+      );
+    }, goalBusyOptions(goalId));
+    return;
+  }
+  mutateGoalStatus(goalId, () => ({ next: status, result: undefined }), workspaceRoot);
 }
 
 /**
@@ -290,8 +346,7 @@ export function writeGoalStatus(
  * 如果文件不存在，抛出 PatchWardenError("goal_not_found")。
  */
 export function readGoalStatus(goalId: string, workspaceRoot?: string): GoalStatus {
-  const goalDir = getGoalDir(goalId, workspaceRoot);
-  const statusPath = join(goalDir, "goal_status.json");
+  const statusPath = getGoalStatusPath(goalId, workspaceRoot);
   if (!existsSync(statusPath)) {
     throw new PatchWardenError(
       "goal_not_found",
@@ -301,6 +356,138 @@ export function readGoalStatus(goalId: string, workspaceRoot?: string): GoalStat
       { goal_id: goalId, status_path: statusPath }
     );
   }
-  const raw = readFileSync(statusPath, "utf-8");
-  return JSON.parse(raw) as GoalStatus;
+  let parsed: unknown;
+  try {
+    parsed = readJsonObjectFileSync(statusPath);
+  } catch {
+    throw invalidGoalStatus(goalId, "goal_status.json is not valid JSON");
+  }
+  return validateGoalStatus(goalId, parsed, workspaceRoot);
+}
+
+export interface GoalStatusMutation<R> {
+  next?: GoalStatus;
+  result: R;
+}
+
+export function mutateGoalStatus<R>(
+  goalId: string,
+  mutation: (current: GoalStatus) => GoalStatusMutation<R>,
+  workspaceRoot?: string,
+): R {
+  const statusPath = getGoalStatusPath(goalId, workspaceRoot);
+  ensureGoalStatusExists(goalId, statusPath);
+  return mutateLockedJsonFileSync<GoalStatus, R>(statusPath, (raw) => {
+    const current = validateGoalStatus(goalId, raw, workspaceRoot);
+    const outcome = mutation(current);
+    if (!outcome.next) return outcome;
+    return {
+      next: normalizeGoalLifecycle(validateGoalStatus(goalId, outcome.next, workspaceRoot)),
+      result: outcome.result,
+    };
+  }, goalBusyOptions(goalId));
+}
+
+export async function mutateGoalStatusAsync<R>(
+  goalId: string,
+  mutation: (current: GoalStatus) => Promise<GoalStatusMutation<R>>,
+  workspaceRoot?: string,
+): Promise<R> {
+  const statusPath = getGoalStatusPath(goalId, workspaceRoot);
+  ensureGoalStatusExists(goalId, statusPath);
+  return withFileLock(statusPath, async () => {
+    const current = validateGoalStatus(
+      goalId,
+      readJsonObjectFileSync(statusPath),
+      workspaceRoot,
+    );
+    const outcome = await mutation(current);
+    if (outcome.next) {
+      atomicWriteJsonFileSync(
+        statusPath,
+        normalizeGoalLifecycle(validateGoalStatus(goalId, outcome.next, workspaceRoot)),
+      );
+    }
+    return outcome.result;
+  }, goalBusyOptions(goalId));
+}
+
+function getGoalStatusPath(goalId: string, workspaceRoot?: string): string {
+  const wsRoot = resolveWorkspaceRoot(workspaceRoot);
+  return guardPath(
+    join(getGoalDir(goalId, wsRoot), "goal_status.json"),
+    wsRoot,
+    GOALS_PREFIX,
+  );
+}
+
+function ensureGoalStatusExists(goalId: string, statusPath: string): void {
+  if (!existsSync(statusPath)) {
+    throw new PatchWardenError(
+      "goal_not_found",
+      `goal_status.json not found for goal "${goalId}" at "${statusPath}"`,
+      "Ensure the goal has been created via createGoal before updating it.",
+      true,
+      { goal_id: goalId, status_path: statusPath },
+    );
+  }
+}
+
+function validateGoalStatus(
+  goalId: string,
+  value: unknown,
+  workspaceRoot?: string,
+): GoalStatus {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw invalidGoalStatus(goalId, "expected a JSON object");
+  }
+  const candidate = value as Partial<GoalStatus>;
+  if (candidate.goal_id !== goalId) {
+    throw invalidGoalStatus(goalId, "goal_id does not match its directory");
+  }
+  if (typeof candidate.title !== "string" || typeof candidate.repo_path !== "string") {
+    throw invalidGoalStatus(goalId, "title or repo_path is missing");
+  }
+  if (candidate.status !== "active" && candidate.status !== "completed" && candidate.status !== "abandoned") {
+    throw invalidGoalStatus(goalId, "status is invalid");
+  }
+  if (!Array.isArray(candidate.subgoals)) {
+    throw invalidGoalStatus(goalId, "subgoals must be an array");
+  }
+  guardWorkspacePath(candidate.repo_path, resolveWorkspaceRoot(workspaceRoot));
+  return candidate as GoalStatus;
+}
+
+function normalizeGoalLifecycle(status: GoalStatus): GoalStatus {
+  if (
+    status.status === "active" &&
+    status.subgoals.length > 0 &&
+    status.subgoals.every((subgoal) => subgoal.status === "accepted")
+  ) {
+    return { ...status, status: "completed", updated_at: new Date().toISOString() };
+  }
+  return status;
+}
+
+function invalidGoalStatus(goalId: string, detail: string): PatchWardenError {
+  return new PatchWardenError(
+    "invalid_goal_status",
+    `Invalid goal status for "${goalId}": ${detail}.`,
+    "Recreate the Goal Session or restore a valid goal_status.json artifact.",
+    true,
+    { goal_id: goalId },
+  );
+}
+
+function goalBusyOptions(goalId: string) {
+  return {
+    waitMs: 0,
+    busyError: () => new PatchWardenError(
+      "goal_busy",
+      `Goal "${goalId}" is currently being updated.`,
+      "Retry after the active Goal operation finishes.",
+      true,
+      { goal_id: goalId },
+    ),
+  };
 }

package/src/goal/handoffExport.ts

@@ -9,9 +9,10 @@
 
 import type { GoalStatus } from "./goalStatus.js";
 import { suggestNextSubgoal } from "./goalGraph.js";
-import { getConfig } from "../config.js";
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
+import { getGoalDir } from "./goalStore.js";
+import { mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { atomicWriteFileSync } from "../utils/atomicFile.js";
 
 // ── Markdown 生成 ────────────────────────────────────────────────
 
@@ -195,12 +196,11 @@ export function exportHandoff(
 ): { handoff_path: string; content_preview: string } {
   const content = generateHandoff(goalId, goalStatus);
 
-  const root = workspaceRoot ?? getConfig().workspaceRoot;
-  const goalDir = resolve(root, ".patchwarden", "goals", goalId);
+  const goalDir = getGoalDir(goalId, workspaceRoot);
   mkdirSync(goalDir, { recursive: true });
 
   const handoffPath = join(goalDir, "handoff.md");
-  writeFileSync(handoffPath, content, "utf-8");
+  atomicWriteFileSync(handoffPath, content);
 
   const preview = content.length > 500 ? content.slice(0, 500) + "..." : content;
 

package/src/goal/specKitImport.ts

@@ -11,7 +11,7 @@
 
 import { PatchWardenError } from "../errors.js";
 import { addSubgoal, type GoalStatus } from "./goalStatus.js";
-import { readGoalStatus, writeGoalStatus } from "./goalStore.js";
+import { mutateGoalStatus } from "./goalStore.js";
 
 // ── 类型定义 ──────────────────────────────────────────────────────
 
@@ -207,8 +207,8 @@ export function importSpecKitTasks(
 
   const workspaceRoot = options?.workspaceRoot;
 
-  // ── 读取现有 GoalStatus ────────────────────────────────────
-  let goalStatus: GoalStatus = readGoalStatus(goalId, workspaceRoot);
+  return mutateGoalStatus(goalId, (currentGoalStatus) => {
+  let goalStatus: GoalStatus = currentGoalStatus;
 
   // ── 构建 external_ref → subgoal_id 映射（现有 subgoal）─────
   const refToSubgoalId = new Map<string, string>();
@@ -341,15 +341,15 @@ export function importSpecKitTasks(
     };
   }
 
-  // ── 持久化（原子写）────────────────────────────────────────
-  writeGoalStatus(goalId, goalStatus, workspaceRoot);
-
-  // ── 返回结果 ───────────────────────────────────────────────
   return {
-    goal_id: goalId,
-    spec_name: input.spec,
-    created_count: createdIds.length,
-    existing_count: existingCount,
-    subgoal_ids: createdIds,
+    next: goalStatus,
+    result: {
+      goal_id: goalId,
+      spec_name: input.spec,
+      created_count: createdIds.length,
+      existing_count: existingCount,
+      subgoal_ids: createdIds,
+    },
   };
+  }, workspaceRoot);
 }