tower-studio 0.2.30 → 0.2.31

package/dist/mcp-server.cjs

@@ -26440,23 +26440,25 @@ function resolveSdkExecutable(command, platform = process.platform, readFile = (
   const ext = import_node_path2.default.extname(command).toLowerCase();
   if (ext !== ".cmd" && ext !== ".bat") return command;
   const dir = import_node_path2.default.win32.dirname(command);
+  let shimSnippet = "";
   try {
     const shim = readFile(command);
-    const match = shim.match(/%~?dp0%[\\/]?([^"]+?\.(?:js|mjs|cjs))/i);
+    shimSnippet = shim.replace(/\s+/g, " ").slice(0, 400);
+    const match = shim.match(/"([^"]*\.(?:c?js|mjs))"/i);
     if (match) {
-      const resolved = import_node_path2.default.win32.resolve(dir, match[1].replace(/\//g, "\\"));
+      let p2 = match[1].replace(/%~?dp0%/gi, dir).replace(/\//g, "\\");
+      const resolved = import_node_path2.default.win32.isAbsolute(p2) ? import_node_path2.default.win32.normalize(p2) : import_node_path2.default.win32.resolve(dir, p2);
       if (fileExists(resolved)) return resolved;
+      console.error(`[resolveSdkExecutable] parsed cli="${resolved}" but it doesn't exist`);
     }
-  } catch {
+  } catch (e2) {
+    console.error(`[resolveSdkExecutable] shim read failed: ${e2 instanceof Error ? e2.message : e2}`);
   }
-  const guess = import_node_path2.default.win32.join(
-    dir,
-    "node_modules",
-    "@anthropic-ai",
-    "claude-code",
-    "cli.js"
-  );
+  const guess = import_node_path2.default.win32.join(dir, "node_modules", "@anthropic-ai", "claude-code", "cli.js");
   if (fileExists(guess)) return guess;
+  console.error(
+    `[resolveSdkExecutable] could not convert ${command} \u2192 guess="${guess}" exists=${fileExists(guess)} shim="${shimSnippet}"`
+  );
   return command;
 }
 async function resolveSpawnTarget(command, args, opts = {}) {
@@ -26988,7 +26990,7 @@ var init_claude_cli_adapter = __esm({
           fs3.mkdirSync(path4.dirname(target), { recursive: true });
           const existing = await fs3.promises.lstat(target).catch(() => null);
           if (existing) {
-            if (existing.isSymbolicLink() || process.platform === "win32" && existing.isDirectory()) {
+            if (existing.isSymbolicLink() || isWindows() && existing.isDirectory()) {
               try {
                 const current = await fs3.promises.readlink(target);
                 if (path4.resolve(current) === path4.resolve(sourceDir)) {
@@ -27014,7 +27016,7 @@ var init_claude_cli_adapter = __esm({
               };
             }
           }
-          const linkType = process.platform === "win32" ? "junction" : "dir";
+          const linkType = isWindows() ? "junction" : "dir";
           await fs3.promises.symlink(sourceDir, target, linkType);
           return { ok: true, method: "symlink", detail: `${target} \u2192 ${sourceDir}` };
         } catch (err) {
@@ -27116,7 +27118,7 @@ var init_claude_cli_adapter = __esm({
        *  Public so claude-session.ts can reuse instead of duplicating findClaudeBinary(). */
       resolveCommand() {
         if (process.env.CLAUDE_CODE_PATH) return process.env.CLAUDE_CODE_PATH;
-        if (process.platform === "win32") {
+        if (isWindows()) {
           const native = resolveCommandPathSync("claude-code");
           if (native !== "claude-code") return native;
         }
@@ -47400,27 +47402,24 @@ function getMergeBase(cwd) {
   }
   return null;
 }
-function captureGitLog(cwd) {
+function resolveGitBase(cwd, forkCommit) {
+  if (forkCommit) return forkCommit;
+  return getMergeBase(cwd);
+}
+function captureGitLog(cwd, forkCommit) {
   try {
-    const mergeBase = getMergeBase(cwd);
-    if (mergeBase) {
-      const log2 = runGit(["log", "--oneline", `${mergeBase}..HEAD`], cwd);
-      if (log2) return log2;
-    }
-    return runGit(["log", "--oneline", "-3"], cwd) || null;
+    const base = resolveGitBase(cwd, forkCommit);
+    if (!base) return null;
+    return runGit(["log", "--oneline", `${base}..HEAD`], cwd) || null;
   } catch {
     return null;
   }
 }
-function captureGitStats(cwd) {
+function captureGitStats(cwd, forkCommit) {
   try {
-    let diffOutput;
-    const mergeBase = getMergeBase(cwd);
-    if (mergeBase) {
-      diffOutput = runGit(["diff", "--stat", `${mergeBase}..HEAD`], cwd);
-    } else {
-      diffOutput = runGit(["diff", "--stat", "HEAD~20", "HEAD"], cwd);
-    }
+    const base = resolveGitBase(cwd, forkCommit);
+    if (!base) return null;
+    const diffOutput = runGit(["diff", "--stat", `${base}..HEAD`], cwd);
     if (!diffOutput) return null;
     return parseDiffStat(diffOutput);
   } catch {
@@ -47459,17 +47458,17 @@ function trimTerminalBuffer(buffer) {
   if (clean.length <= TERMINAL_LOG_MAX) return clean;
   return clean.slice(clean.length - TERMINAL_LOG_MAX);
 }
-async function captureExecutionSummary(executionId, _taskId, exitCode, terminalBuffer, worktreePath) {
+async function captureExecutionSummary(executionId, _taskId, exitCode, terminalBuffer, worktreePath, forkCommit = null) {
   try {
-    console.error(`[captureExecutionSummary] Starting: exec=${executionId.slice(0, 8)} exit=${exitCode} buffer=${terminalBuffer.length}chars worktree=${worktreePath}`);
+    console.error(`[captureExecutionSummary] Starting: exec=${executionId.slice(0, 8)} exit=${exitCode} buffer=${terminalBuffer.length}chars worktree=${worktreePath} fork=${forkCommit?.slice(0, 8) ?? "none"}`);
     let gitLog = null;
     let gitStats = null;
     let summary = null;
     if (worktreePath && (0, import_fs6.existsSync)(worktreePath)) {
       try {
         runGit(["rev-parse", "--git-dir"], worktreePath);
-        gitLog = captureGitLog(worktreePath);
-        gitStats = captureGitStats(worktreePath);
+        gitLog = captureGitLog(worktreePath, forkCommit);
+        gitStats = captureGitStats(worktreePath, forkCommit);
         if (gitStats && gitLog) {
           const commitCount = gitLog.split("\n").filter(Boolean).length;
           gitStats = { ...gitStats, commits: commitCount };
@@ -47575,6 +47574,437 @@ var init_execution_summary = __esm({
   }
 });
 
+// src/lib/fts.ts
+async function searchNotes(db4, projectId, query) {
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+  if (trimmed.length < 3) {
+    return db4.$queryRawUnsafe(
+      `SELECT id as note_id, title, content FROM "ProjectNote"
+       WHERE "projectId" = ? AND (title LIKE ? OR content LIKE ?)
+       LIMIT 20`,
+      projectId,
+      `%${trimmed}%`,
+      `%${trimmed}%`
+    );
+  }
+  return db4.$queryRawUnsafe(
+    `SELECT f.note_id, f.title, f.content
+     FROM notes_fts f
+     JOIN "ProjectNote" n ON n.id = f.note_id
+     WHERE f.notes_fts MATCH ? AND n."projectId" = ?
+     ORDER BY rank
+     LIMIT 20`,
+    trimmed,
+    projectId
+  );
+}
+async function syncNoteToFts(db4, note) {
+  await db4.$executeRawUnsafe(
+    "DELETE FROM notes_fts WHERE note_id = ?",
+    note.id
+  );
+  await db4.$executeRawUnsafe(
+    "INSERT INTO notes_fts(note_id, title, content) VALUES (?, ?, ?)",
+    note.id,
+    note.title,
+    note.content
+  );
+}
+async function deleteNoteFromFts(db4, noteId) {
+  await db4.$executeRawUnsafe(
+    "DELETE FROM notes_fts WHERE note_id = ?",
+    noteId
+  );
+}
+var init_fts = __esm({
+  "src/lib/fts.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/task-diff-resolver.ts
+async function resolveTaskDiffSource(taskId) {
+  const task = await db2.task.findUnique({
+    where: { id: taskId },
+    include: { project: true }
+  });
+  if (!task) return { kind: "error", status: 404, message: "Task not found" };
+  if (!task.project?.localPath) {
+    return { kind: "error", status: 400, message: "Project has no local path" };
+  }
+  const baseBranch = task.baseBranch || "main";
+  const localPath = task.project.localPath;
+  const latestExecution = await db2.taskExecution.findFirst({
+    where: { taskId },
+    orderBy: { createdAt: "desc" }
+  });
+  if (!latestExecution) return { kind: "empty" };
+  const { forkCommit, mergeCommit, branchTipCommit, worktreeBranch, worktreePath } = latestExecution;
+  if (mergeCommit && forkCommit) {
+    const endCommit = branchTipCommit || mergeCommit;
+    return {
+      kind: "ok",
+      data: {
+        diffCwd: localPath,
+        diffTarget: `${forkCommit}..${endCommit}`,
+        baseRef: forkCommit,
+        endRef: endCommit,
+        worktreePath: null
+      }
+    };
+  }
+  if (forkCommit && worktreePath && (0, import_fs7.existsSync)(worktreePath)) {
+    return {
+      kind: "ok",
+      data: {
+        diffCwd: worktreePath,
+        diffTarget: forkCommit,
+        baseRef: forkCommit,
+        endRef: null,
+        worktreePath
+      }
+    };
+  }
+  if (forkCommit && !worktreePath) {
+    return {
+      kind: "ok",
+      data: {
+        diffCwd: localPath,
+        diffTarget: forkCommit,
+        baseRef: forkCommit,
+        endRef: null,
+        worktreePath: null
+      }
+    };
+  }
+  if (worktreeBranch) {
+    try {
+      const mb2 = (0, import_child_process6.execFileSync)(
+        "git",
+        ["merge-base", baseBranch, worktreeBranch],
+        { cwd: localPath, encoding: "utf-8", timeout: 5e3 }
+      ).trim();
+      const wtp = worktreePath && (0, import_fs7.existsSync)(worktreePath) ? worktreePath : localPath;
+      return {
+        kind: "ok",
+        data: {
+          diffCwd: wtp,
+          diffTarget: mb2,
+          baseRef: mb2,
+          endRef: null,
+          worktreePath: worktreePath && (0, import_fs7.existsSync)(worktreePath) ? worktreePath : null
+        }
+      };
+    } catch {
+      return { kind: "branch-deleted" };
+    }
+  }
+  return { kind: "empty" };
+}
+var import_child_process6, import_fs7;
+var init_task_diff_resolver = __esm({
+  "src/lib/task-diff-resolver.ts"() {
+    "use strict";
+    import_child_process6 = require("child_process");
+    import_fs7 = require("fs");
+    init_db();
+  }
+});
+
+// src/lib/diff-parser.ts
+function parseDiffOutput(numstat, unifiedDiff) {
+  const numstatEntries = [];
+  for (const line of numstat.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    const parts = trimmed.split("	");
+    if (parts.length < 3) continue;
+    const [addedStr, removedStr, ...filenameParts] = parts;
+    const filename = filenameParts.join("	");
+    if (addedStr === "-" && removedStr === "-") {
+      numstatEntries.push({ filename, added: 0, removed: 0, isBinary: true });
+    } else {
+      numstatEntries.push({
+        filename,
+        added: parseInt(addedStr, 10) || 0,
+        removed: parseInt(removedStr, 10) || 0,
+        isBinary: false
+      });
+    }
+  }
+  const DIFF_GIT_HEADER = /^diff --git a\/.+ b\/.+$/m;
+  const diffHeaderRegex = /^diff --git a\/(.+) b\/(.+)$/;
+  const patchMap = /* @__PURE__ */ new Map();
+  if (unifiedDiff.trim()) {
+    const isTruncationNeeded = unifiedDiff.length > 500 * 1024;
+    const segments = unifiedDiff.split(/(?=^diff --git )/m);
+    for (const segment of segments) {
+      if (!segment.trim()) continue;
+      const firstLine = segment.split("\n")[0];
+      const match = diffHeaderRegex.exec(firstLine);
+      if (!match) continue;
+      const filename = match[2];
+      let patch = segment;
+      if (isTruncationNeeded) {
+        const lines = segment.split("\n");
+        if (lines.length > 200) {
+          patch = lines.slice(0, 200).join("\n") + "\n... (truncated)";
+        }
+      }
+      patchMap.set(filename, patch);
+    }
+  }
+  const files = numstatEntries.map((entry) => ({
+    filename: entry.filename,
+    added: entry.added,
+    removed: entry.removed,
+    isBinary: entry.isBinary,
+    patch: patchMap.get(entry.filename) ?? ""
+  }));
+  const totalAdded = files.reduce((sum, f2) => sum + f2.added, 0);
+  const totalRemoved = files.reduce((sum, f2) => sum + f2.removed, 0);
+  return { files, totalAdded, totalRemoved };
+}
+var init_diff_parser = __esm({
+  "src/lib/diff-parser.ts"() {
+    "use strict";
+  }
+});
+
+// src/lib/task-overview-format.ts
+function buildFallbackSummary(commitLog) {
+  if (!commitLog) return null;
+  const lines = commitLog.split("\n").filter(Boolean);
+  if (lines.length === 0) return null;
+  const first = lines[0].replace(/^[a-f0-9]+\s+/, "");
+  return lines.length === 1 ? first : `${lines.length} \u4E2A\u63D0\u4EA4\uFF1A${first}`;
+}
+function buildNoteTitle(taskTitle, kind = "done") {
+  const prefix = kind === "cancelled" ? "\u4EFB\u52A1\u6982\u89C8\uFF08\u5DF2\u53D6\u6D88\uFF09\uFF1A" : "\u4EFB\u52A1\u6982\u89C8\uFF1A";
+  return `${prefix}${taskTitle}`.slice(0, 200);
+}
+function formatNoteContent(data, summary, generatedAt, kind = "done") {
+  const intro = kind === "cancelled" ? "> \u672C\u7B14\u8BB0\u7531\u4EFB\u52A1\u53D6\u6D88\u65F6\u81EA\u52A8\u751F\u6210\uFF0C\u8BB0\u5F55\u5DF2\u4EA7\u751F\u7684\u6539\u52A8\uFF0C\u4F5C\u4E3A\u4E0B\u6B21\u91CD\u542F\u8BE5\u4EFB\u52A1\u7684\u53C2\u8003\u7ECF\u9A8C\u3002" : "> \u672C\u7B14\u8BB0\u7531\u4EFB\u52A1\u5B8C\u6210\u65F6\u81EA\u52A8\u751F\u6210\uFF0C\u8BB0\u5F55\u672C\u6B21\u4EFB\u52A1\u7684\u6539\u52A8\u6982\u89C8\uFF0C\u4FBF\u4E8E\u540E\u7EED\u590D\u76D8\u4E0E\u6392\u67E5\u3002";
+  const lines = [];
+  lines.push(intro);
+  lines.push("");
+  lines.push("## \u6539\u52A8\u6458\u8981");
+  lines.push(summary ?? "\uFF08\u672A\u80FD\u751F\u6210\u6539\u52A8\u6458\u8981\uFF09");
+  lines.push("");
+  lines.push("## \u6587\u4EF6\u6E05\u5355");
+  if (data.files.length > 0) {
+    const shown = data.files.slice(0, FILE_LIST_NOTE_MAX);
+    for (const f2 of shown) {
+      lines.push(
+        f2.isBinary ? `- \`${f2.filename}\`\uFF08\u4E8C\u8FDB\u5236\uFF09` : `- \`${f2.filename}\` (+${f2.added} / -${f2.removed})`
+      );
+    }
+    if (data.files.length > shown.length) {
+      lines.push(`- \u2026\u5176\u4F59 ${data.files.length - shown.length} \u4E2A\u6587\u4EF6`);
+    }
+    lines.push("");
+    lines.push(`\u5171 ${data.files.length} \u4E2A\u6587\u4EF6\u3001${data.commitCount} \u4E2A\u63D0\u4EA4\u3002`);
+  } else {
+    lines.push(`\uFF08\u672A\u80FD\u83B7\u53D6\u7CBE\u786E\u6587\u4EF6\u6E05\u5355\uFF0C\u672C\u6B21\u7EA6 ${data.commitCount} \u4E2A\u63D0\u4EA4\u3002\uFF09`);
+  }
+  lines.push("");
+  lines.push("## \u76F8\u5173\u9644\u4EF6\u4E0E\u53C2\u8003\u8D44\u6599");
+  if (data.assets.length > 0) {
+    for (const a2 of data.assets) {
+      lines.push(a2.description ? `- ${a2.filename} \u2014 ${a2.description}` : `- ${a2.filename}`);
+    }
+  } else {
+    lines.push("\uFF08\u65E0\uFF09");
+  }
+  lines.push("");
+  lines.push("---");
+  lines.push(`> \u5173\u8054\u4EFB\u52A1\uFF1A${data.taskTitle} (\`${data.taskId}\`)`);
+  lines.push(`> \u9879\u76EE\uFF1A${data.projectName}`);
+  lines.push(`> \u751F\u6210\u65F6\u95F4\uFF1A${generatedAt}`);
+  return lines.join("\n");
+}
+var FILE_LIST_NOTE_MAX;
+var init_task_overview_format = __esm({
+  "src/lib/task-overview-format.ts"() {
+    "use strict";
+    FILE_LIST_NOTE_MAX = 100;
+  }
+});
+
+// src/lib/task-overview.ts
+var task_overview_exports = {};
+__export2(task_overview_exports, {
+  TASK_OVERVIEW_CATEGORY: () => TASK_OVERVIEW_CATEGORY,
+  captureTaskOverview: () => captureTaskOverview
+});
+function runGit2(args, cwd, maxBuffer = 1024 * 1024) {
+  try {
+    return (0, import_child_process7.execFileSync)("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: 3e4,
+      maxBuffer,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+async function gatherTaskChangeData(taskId) {
+  const task = await db2.task.findUnique({
+    where: { id: taskId },
+    include: { project: true }
+  });
+  if (!task || !task.project) return null;
+  const localPath = task.project.localPath ?? null;
+  let files = [];
+  let commitLog = null;
+  let commitCount = 0;
+  let diffText = null;
+  let cwd = localPath || process.cwd();
+  if (localPath) {
+    const resolved = await resolveTaskDiffSource(taskId);
+    if (resolved.kind === "ok") {
+      const { diffCwd, diffTarget } = resolved.data;
+      cwd = diffCwd;
+      const logRange = diffTarget.includes("..") ? diffTarget : `${diffTarget}..HEAD`;
+      const numstat = runGit2(["diff", "--numstat", diffTarget], diffCwd, GIT_MAX_BUFFER);
+      if (numstat) {
+        files = parseDiffOutput(numstat, "").files;
+      }
+      commitLog = runGit2(["log", "--oneline", logRange], diffCwd) || null;
+      const countStr = runGit2(["rev-list", "--count", logRange], diffCwd);
+      commitCount = countStr ? parseInt(countStr, 10) || 0 : 0;
+      const rawDiff = runGit2(["diff", diffTarget], diffCwd, GIT_MAX_BUFFER);
+      if (rawDiff) {
+        diffText = rawDiff.length > DIFF_TEXT_MAX ? rawDiff.slice(0, DIFF_TEXT_MAX) + "\n...(diff truncated)" : rawDiff;
+      }
+    }
+  }
+  if (files.length === 0 && commitCount === 0) {
+    const latestExec = await db2.taskExecution.findFirst({
+      where: { taskId },
+      orderBy: { createdAt: "desc" },
+      select: { gitLog: true, worktreePath: true }
+    });
+    if (latestExec?.gitLog) {
+      commitLog = latestExec.gitLog;
+      commitCount = latestExec.gitLog.split("\n").filter(Boolean).length;
+    }
+    if (latestExec?.worktreePath && (0, import_fs8.existsSync)(latestExec.worktreePath)) {
+      cwd = latestExec.worktreePath;
+    }
+  }
+  if (files.length === 0 && commitCount === 0) return null;
+  const assetRows = await db2.projectAsset.findMany({
+    where: { taskId },
+    orderBy: { createdAt: "asc" },
+    select: { filename: true, description: true }
+  });
+  const assets = assetRows.map((a2) => ({
+    filename: a2.filename,
+    description: a2.description
+  }));
+  return {
+    taskId,
+    taskTitle: task.title,
+    projectId: task.projectId,
+    projectName: task.project.name,
+    files,
+    commitLog,
+    commitCount,
+    diffText,
+    assets,
+    cwd
+  };
+}
+async function generateChangeSummary(data) {
+  const fileListText = data.files.slice(0, FILE_LIST_PROMPT_MAX).map(
+    (f2) => f2.isBinary ? `${f2.filename} (binary)` : `${f2.filename} (+${f2.added}/-${f2.removed})`
+  ).join("\n") || "\uFF08\u65E0\u6587\u4EF6\u6E05\u5355\uFF09";
+  const prompt = `\u4F60\u662F\u8D44\u6DF1\u5DE5\u7A0B\u5E08\u3002\u4E0B\u9762\u662F\u4E00\u4E2A\u521A\u5B8C\u6210\u7684\u5F00\u53D1\u4EFB\u52A1\u7684\u4EE3\u7801\u6539\u52A8\u4FE1\u606F\uFF0C\u8BF7\u7528\u7B80\u6D01\u4E2D\u6587\u5199\u4E00\u6BB5\u300C\u6539\u52A8\u6458\u8981\u300D\uFF1A\u8BF4\u660E\u8FD9\u6B21\u6539\u52A8\u505A\u4E86\u4EC0\u4E48\u3001\u89E3\u51B3\u4E86\u4EC0\u4E48\u95EE\u9898\u3001\u4E3B\u8981\u6D89\u53CA\u54EA\u4E9B\u6A21\u5757\u6216\u903B\u8F91\u3002\u8981\u6C42 3-6 \u53E5\u3001\u7EAF\u6587\u672C\uFF0C\u4E0D\u8981 markdown \u6807\u9898\uFF0C\u4E0D\u8981\u9010\u6761\u7F57\u5217\u6587\u4EF6\uFF08\u6587\u4EF6\u6E05\u5355\u4F1A\u53E6\u5916\u5C55\u793A\uFF09\u3002
+
+\u4EFB\u52A1\u6807\u9898\uFF1A${data.taskTitle}
+
+\u63D0\u4EA4\u8BB0\u5F55\uFF1A
+${data.commitLog ?? "\uFF08\u65E0\u63D0\u4EA4\u8BB0\u5F55\uFF09"}
+
+\u53D8\u66F4\u6587\u4EF6\uFF08\u5171 ${data.files.length} \u4E2A\uFF09\uFF1A
+${fileListText}
+
+diff\uFF08\u53EF\u80FD\u5DF2\u622A\u65AD\uFF09\uFF1A
+\`\`\`diff
+${data.diffText ?? "\uFF08\u65E0 diff\uFF09"}
+\`\`\``;
+  const cwd = (0, import_fs8.existsSync)(data.cwd) ? data.cwd : process.cwd();
+  const result = await aiQuery(prompt, cwd, { maxTurns: 1 });
+  if (result) {
+    const cleaned = result.replace(/^[#*\->"'\s]+/, "").trim();
+    if (cleaned) return cleaned;
+  }
+  return buildFallbackSummary(data.commitLog);
+}
+async function captureTaskOverview(taskId, opts = {}) {
+  const kind = opts.kind ?? "done";
+  let data = null;
+  try {
+    data = await gatherTaskChangeData(taskId);
+  } catch (err) {
+    console.error("[captureTaskOverview] Failed to gather change data:", err);
+    return;
+  }
+  if (!data) {
+    console.error(`[captureTaskOverview] No changes for task=${taskId.slice(0, 8)} \u2014 skip`);
+    return;
+  }
+  const captured = data;
+  void (async () => {
+    try {
+      const summary = await generateChangeSummary(captured);
+      const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      const content = formatNoteContent(captured, summary, generatedAt, kind);
+      const title = buildNoteTitle(captured.taskTitle, kind);
+      const note = await db2.projectNote.create({
+        data: {
+          title,
+          content,
+          category: TASK_OVERVIEW_CATEGORY,
+          projectId: captured.projectId,
+          // taskId stays null so the note surfaces in the project Notes page
+          // (getProjectNotes filters taskId:null). The task linkage lives as a
+          // text backlink in the note body instead.
+          taskId: null
+        }
+      });
+      await syncNoteToFts(db2, { id: note.id, title: note.title, content: note.content });
+      console.error(
+        `[captureTaskOverview] Note created: ${note.id} for task=${taskId.slice(0, 8)}`
+      );
+    } catch (err) {
+      console.error("[captureTaskOverview] Failed to create overview note:", err);
+    }
+  })();
+}
+var import_child_process7, import_fs8, TASK_OVERVIEW_CATEGORY, DIFF_TEXT_MAX, FILE_LIST_PROMPT_MAX, GIT_MAX_BUFFER;
+var init_task_overview = __esm({
+  "src/lib/task-overview.ts"() {
+    "use strict";
+    import_child_process7 = require("child_process");
+    import_fs8 = require("fs");
+    init_db();
+    init_fts();
+    init_claude_session();
+    init_task_diff_resolver();
+    init_diff_parser();
+    init_task_overview_format();
+    TASK_OVERVIEW_CATEGORY = "\u4EFB\u52A1\u7B14\u8BB0";
+    DIFF_TEXT_MAX = 12 * 1024;
+    FILE_LIST_PROMPT_MAX = 60;
+    GIT_MAX_BUFFER = 64 * 1024 * 1024;
+  }
+});
+
 // node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/utils.js
 var require_utils4 = __commonJS({
   "node_modules/.pnpm/node-pty@1.1.0/node_modules/node-pty/lib/utils.js"(exports2) {
@@ -49127,8 +49557,8 @@ async function updateTaskStatus(taskId, status) {
   });
   if (status === "DONE" && !task.baseBranch && task.project?.localPath) {
     try {
-      const { execFileSync: execFileSync5 } = await import("child_process");
-      const headCommit = execFileSync5(
+      const { execFileSync: execFileSync7 } = await import("child_process");
+      const headCommit = execFileSync7(
         "git",
         ["rev-parse", "HEAD"],
         { cwd: task.project.localPath, encoding: "utf-8", timeout: 5e3 }
@@ -49154,6 +49584,11 @@ async function updateTaskStatus(taskId, status) {
       });
     }).catch(() => {
     });
+    Promise.resolve().then(() => (init_task_overview(), task_overview_exports)).then(({ captureTaskOverview: captureTaskOverview2 }) => {
+      captureTaskOverview2(taskId).catch(() => {
+      });
+    }).catch(() => {
+    });
   }
   if (status === "DONE" || status === "CANCELLED") {
     try {
@@ -49163,6 +49598,14 @@ async function updateTaskStatus(taskId, status) {
       log.error("PTY session destroy failed", error48, { taskId });
     }
   }
+  if (status === "CANCELLED" && task.project?.localPath) {
+    try {
+      const { captureTaskOverview: captureTaskOverview2 } = await Promise.resolve().then(() => (init_task_overview(), task_overview_exports));
+      await captureTaskOverview2(taskId, { kind: "cancelled" });
+    } catch (error48) {
+      log.error("Task overview capture failed", error48, { taskId });
+    }
+  }
   if (status === "CANCELLED" && task.project?.localPath) {
     try {
       await removeWorktree(task.project.localPath, taskId);
@@ -49273,20 +49716,20 @@ async function getArchivedTasks(projectId) {
   });
 }
 async function checkWorktreeClean(taskId) {
-  const { execFileSync: execFileSync5 } = await import("child_process");
-  const { existsSync: existsSync10 } = await import("fs");
+  const { execFileSync: execFileSync7 } = await import("child_process");
+  const { existsSync: existsSync12 } = await import("fs");
   const task = await db2.task.findUnique({ where: { id: taskId } });
   const execution = await db2.taskExecution.findFirst({
     where: { taskId },
     orderBy: { createdAt: "desc" }
   });
-  if (!execution?.worktreePath || !existsSync10(execution.worktreePath)) {
+  if (!execution?.worktreePath || !existsSync12(execution.worktreePath)) {
     return { clean: true, files: [], hasCommits: false, lastCommitMessage: null, commitLog: [], hasWorktree: false };
   }
   const cwd = execution.worktreePath;
   const baseBranch = task?.baseBranch || "main";
   try {
-    const status = execFileSync5(
+    const status = execFileSync7(
       "git",
       ["status", "--porcelain"],
       { cwd, encoding: "utf-8", timeout: 5e3 }
@@ -49297,24 +49740,24 @@ async function checkWorktreeClean(taskId) {
     let lastCommitMessage = null;
     let commitLog = [];
     try {
-      const forkPoint = execFileSync5(
+      const forkPoint = execFileSync7(
         "git",
         ["merge-base", baseBranch, "HEAD"],
         { cwd, encoding: "utf-8", timeout: 5e3 }
       ).trim();
-      const commitCount = execFileSync5(
+      const commitCount = execFileSync7(
         "git",
         ["rev-list", "--count", `${forkPoint}..HEAD`],
         { cwd, encoding: "utf-8", timeout: 5e3 }
       ).trim();
       hasCommits = parseInt(commitCount, 10) > 0;
       if (hasCommits) {
-        lastCommitMessage = execFileSync5(
+        lastCommitMessage = execFileSync7(
           "git",
           ["log", "-1", "--format=%B"],
           { cwd, encoding: "utf-8", timeout: 5e3 }
         ).trim();
-        const log2 = execFileSync5(
+        const log2 = execFileSync7(
           "git",
           ["log", "--oneline", `${forkPoint}..HEAD`],
           { cwd, encoding: "utf-8", timeout: 5e3 }
@@ -49329,23 +49772,23 @@ async function checkWorktreeClean(taskId) {
   }
 }
 async function commitWorktreeChanges(taskId, message) {
-  const { execFileSync: execFileSync5 } = await import("child_process");
-  const { existsSync: existsSync10 } = await import("fs");
+  const { execFileSync: execFileSync7 } = await import("child_process");
+  const { existsSync: existsSync12 } = await import("fs");
   const execution = await db2.taskExecution.findFirst({
     where: { taskId },
     orderBy: { createdAt: "desc" }
   });
-  if (!execution?.worktreePath || !existsSync10(execution.worktreePath)) {
+  if (!execution?.worktreePath || !existsSync12(execution.worktreePath)) {
     throw new Error("No active worktree for this task");
   }
   const cwd = execution.worktreePath;
-  execFileSync5("git", ["add", "-A"], { cwd, timeout: 1e4 });
-  const status = execFileSync5("git", ["status", "--porcelain"], { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+  execFileSync7("git", ["add", "-A"], { cwd, timeout: 1e4 });
+  const status = execFileSync7("git", ["status", "--porcelain"], { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
   if (!status) {
     throw new Error("No changes to commit");
   }
-  execFileSync5("git", ["commit", "-m", message], { cwd, encoding: "utf-8", timeout: 15e3 });
-  const hash2 = execFileSync5("git", ["rev-parse", "--short", "HEAD"], { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+  execFileSync7("git", ["commit", "-m", message], { cwd, encoding: "utf-8", timeout: 15e3 });
+  const hash2 = execFileSync7("git", ["rev-parse", "--short", "HEAD"], { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
   return { hash: hash2 };
 }
 async function getTaskOverview(taskId) {
@@ -49558,8 +50001,8 @@ var projectTools = {
 
 // src/mcp/tools/task-tools.ts
 init_zod();
-var import_child_process6 = require("child_process");
-var import_fs7 = require("fs");
+var import_child_process8 = require("child_process");
+var import_fs9 = require("fs");
 var import_path11 = require("path");
 
 // src/lib/config-reader.ts
@@ -49736,7 +50179,7 @@ var taskTools = {
           const project = await db.project.findUnique({ where: { id: args.projectId }, select: { localPath: true } });
           if (project?.localPath) {
             try {
-              baseBranch = (0, import_child_process6.execFileSync)("git", ["branch", "--show-current"], {
+              baseBranch = (0, import_child_process8.execFileSync)("git", ["branch", "--show-current"], {
                 cwd: project.localPath,
                 encoding: "utf-8",
                 timeout: 5e3
@@ -49767,20 +50210,20 @@ var taskTools = {
       let updatedDesc = null;
       if (args.references && args.references.length > 0) {
         const assetsDir = (0, import_path11.join)(MCP_PROJECT_ROOT, "data", "assets", args.projectId);
-        (0, import_fs7.mkdirSync)(assetsDir, { recursive: true });
+        (0, import_fs9.mkdirSync)(assetsDir, { recursive: true });
         for (const filePath of args.references) {
           try {
-            if (!(0, import_fs7.existsSync)(filePath)) continue;
-            const stat = (0, import_fs7.statSync)(filePath);
+            if (!(0, import_fs9.existsSync)(filePath)) continue;
+            const stat = (0, import_fs9.statSync)(filePath);
             if (!stat.isFile()) continue;
             const isCache = isAssistantCachePath(filePath);
             let filename = isCache ? stripCacheUuidSuffix((0, import_path11.basename)(filePath)) : (0, import_path11.basename)(filePath);
-            if ((0, import_fs7.existsSync)((0, import_path11.join)(assetsDir, filename))) {
+            if ((0, import_fs9.existsSync)((0, import_path11.join)(assetsDir, filename))) {
               const ext = (0, import_path11.extname)(filename);
               const base = (0, import_path11.basename)(filename, ext);
               if (isCache) {
                 let counter = 1;
-                while ((0, import_fs7.existsSync)((0, import_path11.join)(assetsDir, `${base} (${counter})${ext}`))) {
+                while ((0, import_fs9.existsSync)((0, import_path11.join)(assetsDir, `${base} (${counter})${ext}`))) {
                   counter++;
                 }
                 filename = `${base} (${counter})${ext}`;
@@ -49789,7 +50232,7 @@ var taskTools = {
               }
             }
             const dest = (0, import_path11.join)(assetsDir, filename);
-            (0, import_fs7.copyFileSync)(filePath, dest);
+            (0, import_fs9.copyFileSync)(filePath, dest);
             await db.projectAsset.create({
               data: {
                 filename,
@@ -50272,52 +50715,7 @@ var knowledgeTools = {
 init_zod();
 var fs4 = __toESM(require("node:fs"));
 var path5 = __toESM(require("node:path"));
-
-// src/lib/fts.ts
-async function searchNotes(db4, projectId, query) {
-  const trimmed = query.trim();
-  if (!trimmed) return [];
-  if (trimmed.length < 3) {
-    return db4.$queryRawUnsafe(
-      `SELECT id as note_id, title, content FROM "ProjectNote"
-       WHERE "projectId" = ? AND (title LIKE ? OR content LIKE ?)
-       LIMIT 20`,
-      projectId,
-      `%${trimmed}%`,
-      `%${trimmed}%`
-    );
-  }
-  return db4.$queryRawUnsafe(
-    `SELECT f.note_id, f.title, f.content
-     FROM notes_fts f
-     JOIN "ProjectNote" n ON n.id = f.note_id
-     WHERE f.notes_fts MATCH ? AND n."projectId" = ?
-     ORDER BY rank
-     LIMIT 20`,
-    trimmed,
-    projectId
-  );
-}
-async function syncNoteToFts(db4, note) {
-  await db4.$executeRawUnsafe(
-    "DELETE FROM notes_fts WHERE note_id = ?",
-    note.id
-  );
-  await db4.$executeRawUnsafe(
-    "INSERT INTO notes_fts(note_id, title, content) VALUES (?, ?, ?)",
-    note.id,
-    note.title,
-    note.content
-  );
-}
-async function deleteNoteFromFts(db4, noteId) {
-  await db4.$executeRawUnsafe(
-    "DELETE FROM notes_fts WHERE note_id = ?",
-    noteId
-  );
-}
-
-// src/mcp/tools/note-asset-tools.ts
+init_fts();
 var manageNotesSchema = external_exports.object({
   action: external_exports.enum(["create", "update", "delete", "get", "list", "search"]),
   projectId: external_exports.string().optional(),