aizuchi 0.2.0 → 0.4.0

package/dist/server/lib/files.js

@@ -1,7 +1,7 @@
 import { promises as fs } from 'node:fs';
 import matter from 'gray-matter';
 import path from 'node:path';
-import { resolveConfigPath } from './config-paths.js';
+import { GLOBAL_BROWSE_DIRS, resolveConfigPath, resolveGlobalConfigPath } from './config-paths.js';
 import { hasSafeConfigExt, isSecretPath, PathValidationError, readFileNoFollow, sanitizeConfigDirEntries, writeFileAtomic, } from './fs-safe.js';
 /**
  * AI 設定ファイル管理 (F-4) のファイル I/O。
@@ -19,26 +19,32 @@ async function relPathFromRealRoot(projectRoot, absPath) {
     const rootReal = await fs.realpath(root).catch(() => root);
     return path.relative(rootReal, absPath);
 }
+/** root に正規化済み absPath を読む共通コア (O_NOFOLLOW で検証〜読取間の symlink 差し替えを防ぐ・N-8) */
+async function readResolved(root, absPath) {
+    const stat = await fs.stat(absPath);
+    const content = await readFileNoFollow(absPath);
+    return { path: await relPathFromRealRoot(root, absPath), content, mtimeMs: stat.mtimeMs };
+}
 /** 許可リスト内ファイルを読む (F-4-1 / F-4-6)。許可外は PathValidationError */
 export async function readConfigFile(projectRoot, config, relPath) {
     const { absPath } = await resolveConfigPath(projectRoot, config, relPath);
-    const stat = await fs.stat(absPath);
-    // R14-4 再修正 (#5): docs だけでなく config 読取も O_NOFOLLOW で TOCTOU を塞ぐ (resolveConfigPath の
-    // lstat symlink 拒否と読取の間で対象が symlink へ差し替わる窓を閉じる)。config はより秘匿性が高い。
-    const content = await readFileNoFollow(absPath);
-    return { path: await relPathFromRealRoot(projectRoot, absPath), content, mtimeMs: stat.mtimeMs };
+    return readResolved(projectRoot, absPath);
+}
+/** グローバル (~/.claude/skills,agents) ファイルを読む。同じ検証コアを root=home で通す */
+export async function readGlobalConfigFile(homeDir, relPath) {
+    const { absPath } = await resolveGlobalConfigPath(homeDir, relPath);
+    return readResolved(homeDir, absPath);
 }
 /**
- * 許可リスト内ファイルを保存する (F-4-1/F-4-3/F-4-6)。
- * - 既存があれば `.bak` を作成 (上書き前のバックアップ)
- * - mode を保全 (秘匿ファイルの権限が緩まないように、N-8 / Round 1 #7)
+ * root に正規化済み absPath を保存する共通コア。
+ * - 親未作成なら作成 (新規ファイル作成の導線)
+ * - 既存があれば `.bak` を作成 (上書き前のバックアップ・mode 保全 R8-2)
+ * - 本体も mode 保全 (秘匿ファイルの権限が緩まないように、N-8 / Round 1 #7)
  * mtime 不一致は呼び出し側で 409 にする (この関数は検証済み前提で書く)。
  */
-export async function saveConfigFile(projectRoot, config, relPath, content) {
-    const { absPath } = await resolveConfigPath(projectRoot, config, relPath);
-    // 既存があれば .bak を作る (内容をそのままコピー)。新規作成時はバックアップ不要。
-    // .bak はコピー元 (秘匿ファイル) の mode を継がせる (R8-2: settings.local.json 0o600 の .bak が
-    // 0o644 で漏れないように)。preserveMode は .bak の既存 mode を見るため未存在だと効かない → mode を明示
+async function writeResolved(root, absPath, content) {
+    // absPath は resolveConfigPath / resolveGlobalConfigPath で検証済み (root 配下・許可リスト内・symlink 非経由)
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
     try {
         const prevStat = await fs.stat(absPath);
         // R14-4 再修正 (#5): prev 読取も O_NOFOLLOW に統一 (config 読取経路の TOCTOU を docs と対称に塞ぐ)
@@ -51,11 +57,20 @@ export async function saveConfigFile(projectRoot, config, relPath, content) {
     }
     await writeFileAtomic(absPath, content, { preserveMode: true });
     const stat = await fs.stat(absPath);
-    return { path: await relPathFromRealRoot(projectRoot, absPath), content, mtimeMs: stat.mtimeMs };
+    return { path: await relPathFromRealRoot(root, absPath), content, mtimeMs: stat.mtimeMs };
 }
-/** ファイルの現在 mtime を返す (PUT の競合検知用)。存在しなければ null */
-export async function fileMtime(projectRoot, config, relPath) {
+/** 許可リスト内ファイルを保存する (F-4-1/F-4-3/F-4-6)。許可外は PathValidationError */
+export async function saveConfigFile(projectRoot, config, relPath, content) {
     const { absPath } = await resolveConfigPath(projectRoot, config, relPath);
+    return writeResolved(projectRoot, absPath, content);
+}
+/** グローバル (~/.claude/skills,agents) ファイルを保存する。同じ検証コアを root=home で通す */
+export async function saveGlobalConfigFile(homeDir, relPath, content) {
+    const { absPath } = await resolveGlobalConfigPath(homeDir, relPath);
+    return writeResolved(homeDir, absPath, content);
+}
+/** ファイルの現在 mtime を返す (PUT の競合検知用)。存在しなければ null */
+async function statMtime(absPath) {
     try {
         return (await fs.stat(absPath)).mtimeMs;
     }
@@ -63,6 +78,15 @@ export async function fileMtime(projectRoot, config, relPath) {
         return null;
     }
 }
+export async function fileMtime(projectRoot, config, relPath) {
+    const { absPath } = await resolveConfigPath(projectRoot, config, relPath);
+    return statMtime(absPath);
+}
+/** グローバルファイルの現在 mtime (PUT 競合検知用)。許可外は PathValidationError */
+export async function globalFileMtime(homeDir, relPath) {
+    const { absPath } = await resolveGlobalConfigPath(homeDir, relPath);
+    return statMtime(absPath);
+}
 /** browseDirs 配下のファイルツリーを構築する (F-4-2)。各 browseDir をルートにした木の配列 */
 export async function buildFileTree(projectRoot, config) {
     const root = path.resolve(projectRoot);
@@ -179,17 +203,20 @@ async function collectMarkdownFilesNoSymlink(absDir) {
  * .md ファイルのみ対象。frontmatter が無い / パース不能ならそれぞれ null。
  * symlink 中間ディレクトリ・symlink ファイルは辿らない (R8-1: プロジェクト外漏洩を防ぐ)。
  */
-export async function buildCatalog(projectRoot, config) {
-    const root = path.resolve(projectRoot);
+async function buildCatalogFrom(rootInput, browseDirsRel) {
+    const root = path.resolve(rootInput);
     const items = [];
     // R14-1: buildFileTree と同じく root 自身 / 外を指す browseDir を除外する
-    for (const absDir of sanitizeConfigDirEntries(root, config.aiConfigPaths.browseDirs)) {
+    for (const absDir of sanitizeConfigDirEntries(root, [...browseDirsRel])) {
         // R14-1 再修正 (#3): browseDir 自体が .git 等の秘匿パスなら catalog 化しない
         if (isSecretPath(absDir))
             continue;
         for (const abs of await collectMarkdownFilesNoSymlink(absDir)) {
             try {
-                const raw = await fs.readFile(abs, 'utf8');
+                // readConfigFile / readDoc と同じく O_NOFOLLOW 読込に統一し、collectMarkdownFilesNoSymlink の
+                // lstat → 読込の間に最終成分が symlink へ差し替わる TOCTOU 窓を塞ぐ (R14-4 #5 の defense-in-depth)。
+                // symlink は throw → 下の catch でスキップされる (通常ファイルの挙動は不変)。
+                const raw = await readFileNoFollow(abs);
                 const data = matter(raw).data;
                 items.push({
                     path: path.relative(root, abs),
@@ -205,4 +232,12 @@ export async function buildCatalog(projectRoot, config) {
     items.sort((a, b) => a.path.localeCompare(b.path));
     return items;
 }
+/** プロジェクトの skill / agent カタログ (F-4-4)。aiConfigPaths.browseDirs の frontmatter name/description 一覧 */
+export async function buildCatalog(projectRoot, config) {
+    return buildCatalogFrom(projectRoot, config.aiConfigPaths.browseDirs);
+}
+/** グローバル (~/.claude/skills,agents) の skill / agent カタログ。同じ走査ロジックを root=home で通す */
+export async function buildGlobalCatalog(homeDir) {
+    return buildCatalogFrom(homeDir, GLOBAL_BROWSE_DIRS);
+}
 export { PathValidationError };

package/dist/server/lib/proposal.js

@@ -42,6 +42,16 @@ export function replaceBody(raw, newBody) {
     // gray-matter の content は閉じ --- 直後の 1 改行を取り除いた形なので、ここで 1 つ補う
     return `${bom}${header}\n${newBody}`;
 }
+/**
+ * 差し戻し (やり直し依頼) の作業ログ行の本文を組み立てる純関数。
+ * 作業ログは行ベース (`- 時刻 [member] <text>`) なので、reason に含まれる改行は半角スペースへ畳み、
+ * 前後の空白を除く。reason が空 (未指定 / 空白のみ) なら理由なしの「差し戻し」だけを返す。
+ * (reject の `却下: ${reason}` パターンに対応する revise 版。reason は任意なのでこの分岐を持つ)
+ */
+export function reviseWorkLogText(reason) {
+    const normalized = (reason ?? '').replace(/[\r\n]+/g, ' ').trim();
+    return normalized.length > 0 ? `差し戻し: ${normalized}` : '差し戻し';
+}
 /**
  * タスク本文の `## 作業ログ` セクション末尾に 1 行追記する。
  * - セクションがあれば、その内容ブロックの末尾 (次見出し or EOF 直前) に挿入

package/dist/server/lib/task-ops.js

@@ -3,11 +3,12 @@ import path from 'node:path';
 import { findMemberViolations, moveInputSchema, newTaskInputSchema, NEW_TASK_BODY, summarizeZodError, taskFrontmatterSchema, taskIdSchema, } from '../../shared/schema.js';
 import { loadConfig, loadTaskView } from '../board.js';
 import { allocateNextId, createSerialQueue } from './id.js';
-import { FileExistsError, safeWriteFile } from './fs-safe.js';
+import { FileExistsError, resolveKanbanReal, safeWriteFile } from './fs-safe.js';
 import { applyPinpointPatch, verifyPinpointResult } from './pinpoint.js';
-import { appendCommentLine, appendWorkLogLine, replaceBody } from './proposal.js';
+import { appendCommentLine, appendWorkLogLine, replaceBody, reviseWorkLogText } from './proposal.js';
 import { parseTaskFile, serializeTaskFile, TaskFileParseError } from './task-file.js';
 import { nowIso, workLogTimestamp } from './time.js';
+import { DEFAULT_TRASH_KEEP, snapshotToTrash } from './trash.js';
 /**
  * タスク操作のコアロジック (AI 用 CLI F-6-3 が使う)。
  *
@@ -18,6 +19,18 @@ import { nowIso, workLogTimestamp } from './time.js';
  * エラーは TaskOpError (code 付き) で投げる。N-8: メッセージにファイル本文・設定内容を含めない。
  */
 const NEW_TASK_STATUS_DEFAULT = 'todo';
+/**
+ * 差し戻し (revise) を許可する源 status の集合。proposed / backlog は除外する。
+ * proposed→todo を revise で迂回されると approve 承認フロー (proposed→todo) を骨抜きにし恒久
+ * mode_violation を生むため、CLI (TaskOps.revise) と HTTP ルート (app.ts) で同じ集合を共有する。
+ * 軽量モジュール (HTTP 非依存) であるここを唯一の源にし、app.ts はこれを import して drift を防ぐ。
+ */
+export const REVISABLE_STATUSES = new Set([
+    'todo',
+    'in_progress',
+    'pending',
+    'done',
+]);
 export class TaskOpError extends Error {
     code;
     /** zod 由来の検証メッセージ (フィールド名 + 制約。本文は含まない) */
@@ -43,6 +56,22 @@ export class TaskOps {
     taskPath(id) {
         return path.join(this.tasksDir, `${id}.md`);
     }
+    /**
+     * 破壊的書込 (move / revise) の直前に現内容を `.kanban/.trash/<id>.<epoch_ms>.md` へコピー退避する
+     * 安全網 (ごみ箱)。HTTP ルート (app.ts) の snapshot ヘルパーと同型・同 trashKeep。
+     * ベストエフォート (退避失敗は本処理を止めない)。退避は元を消さない「コピー」。
+     */
+    async snapshot(id, currentContent) {
+        try {
+            const kanbanReal = await resolveKanbanReal(this.projectRoot);
+            const { config } = await loadConfig(this.projectRoot);
+            const keep = config.trashKeep ?? DEFAULT_TRASH_KEEP;
+            await snapshotToTrash(id, currentContent, this.kanbanDir, kanbanReal, keep);
+        }
+        catch {
+            // 退避はベストエフォート安全網。失敗しても本処理 (破壊的書込) は止めない
+        }
+    }
     /** 起票 (採番直列化・schema 検証・members 整合)。POST /api/tasks と同じロジック */
     async create(input) {
         // CLI は起票時の status を任意指定できる (HTTP POST は todo 固定だが、AI が backlog/proposed 等で
@@ -149,6 +178,7 @@ export class TaskOps {
             if (!check.success) {
                 throw new TaskOpError('invalid_input', 'ステータス変更後のタスクが不正', summarizeZodError(check.error));
             }
+            await this.snapshot(id, raw); // 旧版を .trash へ退避 (ベストエフォート)
             await safeWriteFile(filePath, patched, [this.kanbanDir]);
             return loadTaskView(this.projectRoot, filePath);
         });
@@ -157,6 +187,73 @@ export class TaskOps {
     async appendLog(id, member, message) {
         return this.appendToSection(id, member, message, 'log');
     }
+    /**
+     * やり直し依頼 (差し戻し)。todo/in_progress/pending/done → todo へ戻し、理由を作業ログに残す。
+     * HTTP の POST /api/tasks/:id/revise と同型の単一書込でアトミックに行う:
+     *   read → status を todo へ pinpoint (+ pending なら blocked_* を null へ) + 差し戻し理由を
+     *   作業ログへ追記 → 1 回の safeWriteFile。
+     * 旧実装は move(todo) + appendLog の 2 段書込 (別 enqueue) で、move 成功後 appendLog 失敗時に
+     * 「理由を失った差し戻し」部分状態を生みえた。HTTP 版と結果整合させ非アトミック性を解消する。
+     * proposed / backlog からの差し戻しは approve 承認フロー迂回を防ぐため conflict で弾く (app.ts と対称)。
+     */
+    async revise(id, input = {}) {
+        if (!taskIdSchema.safeParse(id).success) {
+            throw new TaskOpError('invalid_input', '不正なタスク ID');
+        }
+        const filePath = this.taskPath(id);
+        return this.enqueue(async () => {
+            let raw;
+            try {
+                raw = await fs.readFile(filePath, 'utf8');
+            }
+            catch {
+                throw new TaskOpError('not_found', `タスクが見つからない: ${id}`);
+            }
+            let current;
+            try {
+                current = parseTaskFile(raw);
+            }
+            catch (error) {
+                const message = error instanceof TaskFileParseError ? error.message : 'タスクファイルを解析できない';
+                throw new TaskOpError('conflict', `差し戻しできない (${message})`);
+            }
+            // 源 status ガード: proposed / backlog からの差し戻しは承認フロー迂回になるため弾く (app.ts と対称)
+            if (!REVISABLE_STATUSES.has(current.data.status)) {
+                throw new TaskOpError('conflict', 'この状態のタスクは差し戻せません');
+            }
+            // status を todo へ pinpoint (本文・他フィールドは保全)。pending から戻す場合は blocked_* も null へ
+            const patch = { status: 'todo', updated: nowIso() };
+            if (current.data.blocked_type != null || current.data.blocked_reason != null) {
+                patch.blocked_type = null;
+                patch.blocked_reason = null;
+            }
+            let patched;
+            let patchedParsed;
+            try {
+                patched = applyPinpointPatch(raw, patch);
+                patchedParsed = parseTaskFile(patched);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : '差し戻しに失敗';
+                throw new TaskOpError('conflict', `差し戻しできない (${message})`);
+            }
+            const drift = verifyPinpointResult(current, patchedParsed, patch);
+            if (drift !== null) {
+                throw new TaskOpError('conflict', `差し戻しできない (${drift})`);
+            }
+            const check = taskFrontmatterSchema.safeParse(patchedParsed.data);
+            if (!check.success) {
+                throw new TaskOpError('invalid_input', '差し戻し後のタスクが不正', summarizeZodError(check.error));
+            }
+            // 差し戻し理由を作業ログへ追記 (frontmatter は pinpoint 済みなので body だけ更新する)。
+            // status 変更と理由ログを 1 回の safeWriteFile で書く = アトミック (HTTP 版と同型)
+            const logLine = `${workLogTimestamp()} [human] ${reviseWorkLogText(input.reason)}`;
+            const finalRaw = replaceBody(patched, appendWorkLogLine(patchedParsed.body, logLine));
+            await this.snapshot(id, raw); // 旧版を .trash へ退避 (ベストエフォート)
+            await safeWriteFile(filePath, finalRaw, [this.kanbanDir]);
+            return loadTaskView(this.projectRoot, filePath);
+        });
+    }
     /** やりとり追記 (## やりとり に 1 行)。member は config.members 検証 */
     async appendComment(id, member, message) {
         const { config } = await loadConfig(this.projectRoot);
@@ -199,6 +296,9 @@ export class TaskOps {
             }
             const line = `${workLogTimestamp()} [${member}] ${message}`;
             const newBody = section === 'log' ? appendWorkLogLine(current.body, line) : appendCommentLine(current.body, line);
+            // SEC-N3: 追記も read→全文上書きのため、直前にディスク現内容を .trash へ退避する (move/revise と同様)。
+            // 外部編集と交錯して上書きで失われても復元できるようにする (ベストエフォート)。
+            await this.snapshot(id, raw);
             await safeWriteFile(filePath, replaceBody(raw, newBody), [this.kanbanDir]);
             return loadTaskView(this.projectRoot, filePath);
         });

package/dist/server/lib/trash.js

@@ -0,0 +1,122 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { collectKanbanFilesNoSymlink, FileExistsError, safeWriteFile } from './fs-safe.js';
+/**
+ * ごみ箱 (`.kanban/.trash/`): タスク本体を破壊的に書き換える前に旧版を `.trash/<id>.<epoch_ms>.md` へ
+ * コピー退避し、誤上書き / 誤操作からワンクリック復元できる安全網 (git commit していない限り
+ * 取り戻せない問題を塞ぐ。`.bak` は F-4 設定ファイル管理のみでタスクは無防備だった)。
+ *
+ * 設計の核:
+ * - **コピー退避 (rename でなく書込)**: 退避が失敗しても原本を失わない (ベストエフォート安全網)。
+ * - **N-2 厳守**: 退避先 (`.trash`) も `safeWriteFile([kanbanDir])` 経由で許可リスト封じ込め + symlink 非追従。
+ *   退避一覧・復元時の走査も `collectKanbanFilesNoSymlink` (realpath containment + symlink 非追従) を使う。
+ * - **世代の刈り取り**: 同 id の退避が trashKeep 件を超えたら古い順 (epoch 昇順) に削除する。
+ *
+ * `<epoch_ms>` は退避時刻のエポックミリ秒 (Date.now())。世代の新旧判定とファイル名の一意化を兼ねる。
+ */
+/** ごみ箱ディレクトリ名 (1 箇所集約) */
+export const TRASH_DIR = '.trash';
+/** 同 id あたりの退避世代の既定保持件数 (config.trashKeep で上書き可・コード 1 箇所集約) */
+export const DEFAULT_TRASH_KEEP = 20;
+/**
+ * 退避ファイル名 `<id>.<epoch_ms>.md` を {id, trashedAt} に分解する。
+ * 形式に合致しない (epoch が数字でない / .md でない) ファイルは null を返す (走査時に無視する)。
+ * id 自体に `.` を含みうる形式ではないが、保険として「末尾の <数字>.md」を epoch とみなし、
+ * その手前全てを id とする (id は `<prefix>-<digits>` なので `.` を含まない前提だが robust に切り出す)。
+ */
+export function parseTrashName(basename) {
+    if (!basename.endsWith('.md'))
+        return null;
+    const stem = basename.slice(0, -3); // ".md" を外す
+    const lastDot = stem.lastIndexOf('.');
+    if (lastDot <= 0 || lastDot >= stem.length - 1)
+        return null; // 区切りが無い / 端にある
+    const id = stem.slice(0, lastDot);
+    const epochStr = stem.slice(lastDot + 1);
+    if (!/^\d+$/.test(epochStr))
+        return null;
+    const trashedAt = Number(epochStr);
+    if (!Number.isFinite(trashedAt))
+        return null;
+    return { id, trashedAt };
+}
+/** 退避ファイル名を組み立てる (`<id>.<epoch_ms>.md`) */
+function trashName(id, trashedAt) {
+    return `${id}.${trashedAt}.md`;
+}
+/**
+ * `.trash/` 配下の退避ファイルを {id, trashedAt, absPath} の配列で列挙する (N-2 適用)。
+ * `collectKanbanFilesNoSymlink` で realpath containment + symlink 非追従に走査し、形式に合致する
+ * ファイルだけを返す。`.trash` 不在 / 空なら空配列。id 指定があればその id の世代だけに絞る。
+ */
+export async function listTrash(kanbanDir, kanbanReal, filterId) {
+    const trashRoot = path.join(kanbanDir, TRASH_DIR);
+    const files = await collectKanbanFilesNoSymlink(trashRoot, kanbanReal);
+    const entries = [];
+    for (const abs of files) {
+        const parsed = parseTrashName(path.basename(abs));
+        if (parsed === null)
+            continue;
+        if (filterId !== undefined && parsed.id !== filterId)
+            continue;
+        entries.push({ id: parsed.id, trashedAt: parsed.trashedAt, absPath: abs });
+    }
+    return entries;
+}
+/**
+ * タスクの現内容を `.trash/<id>.<epoch_ms>.md` へコピー退避する (破壊的書込の直前に呼ぶ)。
+ * - 退避は **コピー** (`safeWriteFile`)。rename でないので退避失敗で原本を失わない。
+ * - N-2: 書込は `safeWriteFile([kanbanDir])` (許可リスト封じ込め + symlink 非追従)。`.trash` は mkdir で用意する。
+ * - 退避後、同 id の世代が trashKeep を超えていれば古い順 (epoch 昇順) に削除する。
+ *
+ * 失敗時は呼び出し側 (try/catch) で握りつぶし本処理を止めない想定 (ベストエフォート安全網)。
+ * 退避できた絶対パスを返す。
+ */
+export async function snapshotToTrash(id, currentContent, kanbanDir, kanbanReal, trashKeep = DEFAULT_TRASH_KEEP) {
+    const trashRoot = path.join(kanbanDir, TRASH_DIR);
+    await fs.mkdir(trashRoot, { recursive: true });
+    // 同一ミリ秒・同 id で連続退避すると epoch_ms が衝突する。exclusive 書込が EEXIST (FileExistsError) なら
+    // epoch を 1 ずつ進めて空きを探す (退避は消失防止が目的なので既存世代を上書きしない)。
+    const base = Date.now();
+    let written = null;
+    for (let offset = 0; offset < 1000; offset++) {
+        const candidate = base + offset;
+        try {
+            written = await safeWriteFile(path.join(trashRoot, trashName(id, candidate)), currentContent, [kanbanDir], {
+                exclusive: true,
+            });
+            break;
+        }
+        catch (error) {
+            if (error instanceof FileExistsError)
+                continue; // 衝突 → 次の epoch を試す
+            throw error; // それ以外 (containment 違反等) は呼び出し側 (try/catch) へ
+        }
+    }
+    if (written === null) {
+        // 1000 連続衝突は現実的に起きないが、保険として通常書込で 1 回だけ救済する
+        written = await safeWriteFile(path.join(trashRoot, trashName(id, base + Date.now())), currentContent, [kanbanDir]);
+    }
+    await pruneTrash(id, kanbanDir, kanbanReal, trashKeep);
+    return written;
+}
+/**
+ * 同 id の退避世代が trashKeep を超えていれば古い順 (epoch 昇順) に削除する。
+ * trashKeep 以下なら何もしない。削除失敗 (残骸) はスキップして続行する (ベストエフォート)。
+ */
+export async function pruneTrash(id, kanbanDir, kanbanReal, trashKeep = DEFAULT_TRASH_KEEP) {
+    if (!Number.isFinite(trashKeep) || trashKeep < 1)
+        return; // 不正値は刈り取りしない (退避を消さない安全側)
+    const entries = (await listTrash(kanbanDir, kanbanReal, id)).sort((a, b) => a.trashedAt - b.trashedAt);
+    const excess = entries.length - trashKeep;
+    if (excess <= 0)
+        return;
+    for (const entry of entries.slice(0, excess)) {
+        try {
+            await fs.rm(entry.absPath, { force: true });
+        }
+        catch {
+            // 消せない残骸はスキップ
+        }
+    }
+}

package/dist/server/watcher.js

@@ -1,9 +1,22 @@
 import path from 'node:path';
 import { watch } from 'chokidar';
-/** 監視対象: タスクファイル (.md) と config.json のみ。アトミック書込の .tmp は無視する */
-function isWatchTarget(filePath) {
+/**
+ * 監視対象: タスクファイル (.md) と config.json のみ。アトミック書込の .tmp は無視する。
+ * watch ルート (.kanban) から見てドット始まりのディレクトリ配下 (例: ごみ箱 `.trash/<id>.<epoch>.md`)
+ * も無視する。退避コピーや世代刈り取りの unlink で SSE が誤発火し全量再取得が無駄に走るのを防ぐ
+ * (将来の内部 dir も同様に除外)。watch ルート自身が `.kanban` のため、ルート相対で判定する
+ * (絶対パスをそのまま見るとルートの `.kanban` 成分に引っかかり全ファイルが除外される)。
+ */
+export function isWatchTarget(rootDir, filePath) {
     const base = path.basename(filePath);
-    return base.endsWith('.md') || base === 'config.json';
+    if (!(base.endsWith('.md') || base === 'config.json'))
+        return false;
+    // ルート相対パスの中間ディレクトリ成分にドット始まりがあれば内部用とみなし除外する
+    const rel = path.relative(rootDir, filePath);
+    const dirSegments = rel.split(/[\\/]+/).slice(0, -1);
+    if (dirSegments.some((seg) => seg.startsWith('.')))
+        return false;
+    return true;
 }
 export function startWatcher(options) {
     const { kanbanDir, bus } = options;
@@ -11,7 +24,7 @@ export function startWatcher(options) {
     const watcher = watch(kanbanDir, { ignoreInitial: true });
     let timer = null;
     const onFsEvent = (filePath) => {
-        if (!isWatchTarget(filePath))
+        if (!isWatchTarget(kanbanDir, filePath))
             return;
         if (timer !== null)
             clearTimeout(timer);

package/dist/shared/board-diff.js

@@ -0,0 +1,48 @@
+/**
+ * ボード差分 (新着インジケータ用) の純関数。
+ * SSE で再取得した前後のタスク一覧を比べ、「人間が見ていない間に変わったタスク」を割り出す。
+ * AI → 人間の「何が変わったか」を画面内シグナルとして太くするための補助情報で、
+ * これ自体は正本性を持たない (既読マーカーは localStorage に置く・origin 分断は許容)。
+ *
+ * 純粋・副作用なし。server/web の双方が型を共有できるよう新データ源・新依存はゼロ。
+ */
+/**
+ * 前回スナップショット (prev) と最新 (next) を比べ、変化したタスクの id 集合を返す。
+ * - 新規 (prev に無い id) → newIds
+ * - updated が進んだ or status が変わった → updatedIds
+ * - 削除 (next に無い id) は無視する (消えたカードはハイライト対象にならない)
+ *
+ * updated は文字列比較ではなく時刻比較で「進んだ」を判定する (ISO 8601 の桁揃えに依存しない)。
+ * parse 不能な updated は文字列の不一致をもって変化とみなす (誤検知より取りこぼし回避を優先)。
+ */
+export function diffBoards(prev, next) {
+    const prevById = new Map();
+    for (const task of prev) {
+        prevById.set(task.id, task);
+    }
+    const newIds = [];
+    const updatedIds = [];
+    for (const task of next) {
+        const before = prevById.get(task.id);
+        if (before === undefined) {
+            newIds.push(task.id);
+            continue;
+        }
+        if (task.status !== before.status || isNewer(task.updated, before.updated)) {
+            updatedIds.push(task.id);
+        }
+    }
+    return { newIds, updatedIds, changedIds: new Set([...newIds, ...updatedIds]) };
+}
+/**
+ * next の updated が prev の updated より「新しい」かを判定する。
+ * 両方 parse できれば時刻で比較。どちらかが parse 不能なら文字列の不一致を変化とみなす。
+ */
+function isNewer(nextUpdated, prevUpdated) {
+    const nextMs = Date.parse(nextUpdated);
+    const prevMs = Date.parse(prevUpdated);
+    if (Number.isNaN(nextMs) || Number.isNaN(prevMs)) {
+        return nextUpdated !== prevUpdated;
+    }
+    return nextMs > prevMs;
+}

package/dist/shared/diff.js

@@ -3,15 +3,31 @@
  * PUT 競合 (409) 時にローカル編集とサーバー側内容の差分を提示するために使う。
  * 依存を追加せず ~50 行で実装する。server / web が共有する。
  */
+/**
+ * LCS の DP 行列サイズ (aLines.length × bLines.length) の上限。これを超えたら DP を回さず
+ * フォールバックする (長大な作業ログを持つタスクで行 LCS が O(n×m) で重くなるのを避ける)。
+ */
+export const DIFF_MAX_MATRIX = 250000;
 /**
  * 2 つのテキストを行単位で比較し、変更箇所を返す。
  * `equal` = 両方にある行、`remove` = a のみ (削除)、`add` = b のみ (追加)。
+ * 行数の積が DIFF_MAX_MATRIX を超える場合は DP を回さず、全体を「a 全削除 + b 全追加」の
+ * 1 つの変更ブロックとして返す (行単位の対応付けは諦める)。両 diff 利用箇所が恩恵を受ける。
  */
 export function diffLines(a, b) {
     const aLines = a.split('\n');
     const bLines = b.split('\n');
     const n = aLines.length;
     const m = bLines.length;
+    // サイズガード: DP 行列が大きすぎる場合は LCS を回さず粗いフォールバックを返す
+    if (n * m > DIFF_MAX_MATRIX) {
+        const result = [];
+        for (const text of aLines)
+            result.push({ op: 'remove', text });
+        for (const text of bLines)
+            result.push({ op: 'add', text });
+        return result;
+    }
     // LCS の長さ表 (動的計画法)。lcs[i][j] = aLines[i..], bLines[j..] の LCS 長
     const lcs = Array.from({ length: n + 1 }, () => new Array(m + 1).fill(0));
     for (let i = n - 1; i >= 0; i--) {