aizuchi 0.1.0 → 0.3.0

package/dist/server/lib/config-paths.js

@@ -1,19 +1,49 @@
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { hasSafeConfigExt, isHardDeniedConfigPath, isSecretPath, isStrictlyInside, PathValidationError, sanitizeConfigDirEntries, } from './fs-safe.js';
-/** 要求された相対パスが aiConfigPaths のどの許可に該当するかを判定し、正規化済み絶対パスを返す */
-export async function resolveConfigPath(projectRoot, config, requestedRelPath) {
-    const root = path.resolve(projectRoot);
-    // 要求パスを正規化し、プロジェクトルート配下であることを確認する (絶対パス / ../ を弾く)
+/**
+ * target の祖先のうち realpath できる最も近いものと、そこからの未作成 segment 列を返す。
+ * 未作成 segment は実体が無く symlink になり得ないため、containment 判定は実在祖先の realpath だけで足りる。
+ * これにより「許可リスト内だが親ディレクトリが未作成」のパスを、403 (PathValidationError) ではなく
+ * 呼び出し側の stat ENOENT → 404 として扱える (symlink トラバーサルは実在祖先の realpath で従来どおり検知)。
+ */
+async function resolveNearestExistingAncestor(target) {
+    const missing = [];
+    let cur = target;
+    for (;;) {
+        try {
+            return { real: await fs.realpath(cur), missing };
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT')
+                throw error;
+            const parent = path.dirname(cur);
+            if (parent === cur)
+                throw new PathValidationError('親ディレクトリが解決できません');
+            missing.unshift(path.basename(cur));
+            cur = parent;
+        }
+    }
+}
+/** 既定のグローバル browseDirs (~ からの相対)。グローバル skill/agent の閲覧・編集対象 (N-2 をホーム配下へ限定拡張) */
+export const GLOBAL_BROWSE_DIRS = ['.claude/skills', '.claude/agents'];
+/**
+ * root を基準に「完全一致ファイル + 接頭辞一致 browseDirs」の許可リスト検証を行う共通コア (N-2 の本丸)。
+ * プロジェクト (resolveConfigPath) とグローバル (resolveGlobalConfigPath) が同一のハードン済みロジックを共有する。
+ * 正規化 → root 配下か → 許可リスト該当か → deny-list (2 層) → 親 realpath containment → 対象 symlink 拒否。
+ */
+async function resolveAllowlistedPath(rootInput, exactFilesRel, browseDirsRel, requestedRelPath) {
+    const root = path.resolve(rootInput);
+    // 要求パスを正規化し、root 配下であることを確認する (絶対パス / ../ を弾く)
     const resolved = path.resolve(root, requestedRelPath);
     if (resolved !== root && !resolved.startsWith(root + path.sep)) {
-        throw new PathValidationError('プロジェクトルート外へのアクセスは許可されていません');
+        throw new PathValidationError('許可範囲外へのアクセスは許可されていません');
     }
-    // 許可リスト (config 由来) を正規化する。各エントリが root の真の配下であることを強制し
+    // 許可リストを正規化する。各エントリが root の真の配下であることを強制し
     // (`.` / `..` / 絶対パスで root 全域を許可リストに載せる攻撃を無効化)。deny-list はここでは効かせず、
     // 解決後パスに対して下のゲートで 2 層適用する (R14-1 再修正)。
-    const exactFiles = new Set(sanitizeConfigDirEntries(root, [...config.aiConfigPaths.settingsFiles, ...config.aiConfigPaths.rootFiles]));
-    const browseDirs = sanitizeConfigDirEntries(root, config.aiConfigPaths.browseDirs);
+    const exactFiles = new Set(sanitizeConfigDirEntries(root, exactFilesRel));
+    const browseDirs = sanitizeConfigDirEntries(root, browseDirsRel);
     let kind = null;
     if (exactFiles.has(resolved)) {
         kind = 'file';
@@ -22,24 +52,23 @@ export async function resolveConfigPath(projectRoot, config, requestedRelPath) {
         kind = 'dir';
     }
     if (kind === null) {
-        throw new PathValidationError('許可リスト (aiConfigPaths) 外へのアクセスは許可されていません');
+        throw new PathValidationError('許可リスト外へのアクセスは許可されていません');
     }
     // deny-list を解決後パス (lexical) に適用する (R14-1 再修正・残存脆弱性 #2/#4/#7)。
     // 強い deny (.git/** + 鍵類) は **完全一致 (exactFiles) でも** 遮断する (悪意 config が settingsFiles に
     // `.git/hooks/pre-commit` / `.env` / `id_rsa` を列挙しても read/write させない = RCE/N-8 防止)。
     assertNotDenied(resolved, kind);
-    // 親ディレクトリの realpath を解決し、symlink 経由で許可範囲の外へ出ていないか確認する
-    let parentReal;
-    try {
-        parentReal = await fs.realpath(path.dirname(resolved));
-    }
-    catch {
-        throw new PathValidationError('親ディレクトリが存在しません');
-    }
+    // 親ディレクトリの realpath を解決し、symlink 経由で許可範囲の外へ出ていないか確認する。
+    // 親 (や中間) が未作成なら「最も近い実在祖先」で containment を判定する: 実在しない segment は
+    // symlink になり得ないので安全で、かつ未作成ファイルを 403 でなく 404 (呼び出し側の stat ENOENT) に
+    // できる (許可リスト内なのに親未作成だけで 403 を返していた不整合の解消)。
     const rootReal = await fs.realpath(root).catch(() => root);
-    if (parentReal !== rootReal && !parentReal.startsWith(rootReal + path.sep)) {
-        throw new PathValidationError('symlink 経由でプロジェクトルート外を指しています');
+    const { real: ancestorReal, missing } = await resolveNearestExistingAncestor(path.dirname(resolved));
+    if (ancestorReal !== rootReal && !ancestorReal.startsWith(rootReal + path.sep)) {
+        throw new PathValidationError('symlink 経由で許可範囲外を指しています');
     }
+    // 親 canonical = 実在祖先 realpath + 未作成 segment (未作成部分は symlink 不可なので lexical 連結で安全)
+    const parentReal = missing.length > 0 ? path.join(ancestorReal, ...missing) : ancestorReal;
     // 接頭辞一致 (browseDirs) の場合、realpath 解決後も許可ディレクトリ配下か再確認する
     if (kind === 'dir') {
         const allowedReals = await Promise.all(browseDirs.map((dir) => fs.realpath(dir).catch(() => dir)));
@@ -68,6 +97,18 @@ export async function resolveConfigPath(projectRoot, config, requestedRelPath) {
     }
     return { absPath: canonical, kind };
 }
+/** プロジェクトの aiConfigPaths 許可リスト検証 (N-2)。完全一致 = settingsFiles/rootFiles、接頭辞 = browseDirs */
+export async function resolveConfigPath(projectRoot, config, requestedRelPath) {
+    return resolveAllowlistedPath(projectRoot, [...config.aiConfigPaths.settingsFiles, ...config.aiConfigPaths.rootFiles], config.aiConfigPaths.browseDirs, requestedRelPath);
+}
+/**
+ * グローバル (~/.claude) の skill/agent 許可リスト検証。プロジェクトと同一コアを root=home で再利用する。
+ * 対象は GLOBAL_BROWSE_DIRS (~/.claude/skills, ~/.claude/agents) の配下のみ。deny-list / 拡張子許可 / symlink 拒否は同一。
+ * requestedRelPath は home からの相対 (例: `.claude/skills/foo.md`)。
+ */
+export async function resolveGlobalConfigPath(homeDir, requestedRelPath) {
+    return resolveAllowlistedPath(homeDir, [], [...GLOBAL_BROWSE_DIRS], requestedRelPath);
+}
 /**
  * 解決後パスを allow-list (主ゲート) + deny-list (defense-in-depth) で検査する (R17-E + R14-1 再修正)。
  * - **allow-list (R17-E・#E-1)**: 拡張子が SAFE_CONFIG_EXT に無ければ完全一致 / 接頭辞一致を問わず拒否。

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/pinpoint.js

@@ -137,6 +137,56 @@ export function replaceDependsOnId(raw, oldId, newId) {
     }
     return changed ? bom + lines.join('\n') : raw;
 }
+/**
+ * member 移譲: 指定キーの frontmatter 行を `key: <to>` に置き換える (本文・他フィールドは保全)。
+ * どのキーを書き換えるかは呼び出し側が parse 済みの値 (=== from) で判定する (行置換は値を読まない)。
+ * 対象行が見つからない場合はそのキーを変更しない — 呼び出し側の verifyMemberRename が不一致を検出し
+ * 書込を拒否する (壊れた表記で silent に取りこぼさない)
+ */
+export function replaceMemberKeys(raw, keys, to) {
+    const bom = raw.startsWith('\uFEFF') ? '\uFEFF' : '';
+    const text = bom ? raw.slice(1) : raw;
+    const fm = frontmatterRange(text);
+    if (!fm)
+        return raw;
+    const { lines, close } = fm;
+    for (const key of keys) {
+        for (let i = 1; i < close; i++) {
+            const line = (lines[i] ?? '').replace(/\r$/, '');
+            if (line === `${key}:` || line.startsWith(`${key}: `) || line.startsWith(`${key}:\t`)) {
+                const rendered = `${key}: ${dumpScalar(to)}`;
+                lines[i] = (lines[i] ?? '').endsWith('\r') ? `${rendered}\r` : rendered;
+                break;
+            }
+        }
+    }
+    return bom + lines.join('\n');
+}
+/**
+ * verify-after-member-rename ガード (verifyPinpointResult と同じ思想)。
+ * 「指定キーだけが to に変わり、他フィールドと本文は不変」を patch 前後の再 parse で検証する。
+ * 不一致なら理由文字列 (呼び出し側で書込を拒否)、問題なければ null。
+ */
+export function verifyMemberRename(before, after, keys, to) {
+    const keySet = new Set(keys);
+    for (const key of keys) {
+        if (after.data[key] !== to) {
+            return `行置換が ${key} を正しく書き換えられなかった (この表記はピンポイント書換に未対応)`;
+        }
+    }
+    const allKeys = new Set([...Object.keys(before.data), ...Object.keys(after.data)]);
+    for (const key of allKeys) {
+        if (keySet.has(key))
+            continue;
+        if (!valuesEqual(before.data[key], after.data[key])) {
+            return `行置換が意図しないフィールド ${key} を変更した (この表記はピンポイント書換に未対応)`;
+        }
+    }
+    if (before.body !== after.body) {
+        return '行置換が本文を変更した (この表記はピンポイント書換に未対応)';
+    }
+    return null;
+}
 /**
  * verify-after-patch ガード (PM Round 1 #2/#3/#6 への包括対処)。
  *

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);