aizuchi 0.1.0

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

@@ -0,0 +1,206 @@
+import { promises as fs } from 'node:fs';
+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 { applyPinpointPatch, verifyPinpointResult } from './pinpoint.js';
+import { appendCommentLine, appendWorkLogLine, replaceBody } from './proposal.js';
+import { parseTaskFile, serializeTaskFile, TaskFileParseError } from './task-file.js';
+import { nowIso, workLogTimestamp } from './time.js';
+/**
+ * タスク操作のコアロジック (AI 用 CLI F-6-3 が使う)。
+ *
+ * 既存の shared / server プリミティブ (schema 検証・採番直列化・pinpoint + verify・パス検証・
+ * 作業ログ追記) を組み合わせるだけの薄い orchestration。HTTP を経由せずファイルを直接操作する
+ * (serve 不要)。HTTP ルート (app.ts) と同じ不変条件を満たす (zod 検証 / 直列化 / verify-after-patch)。
+ *
+ * エラーは TaskOpError (code 付き) で投げる。N-8: メッセージにファイル本文・設定内容を含めない。
+ */
+const NEW_TASK_STATUS_DEFAULT = 'todo';
+export class TaskOpError extends Error {
+    code;
+    /** zod 由来の検証メッセージ (フィールド名 + 制約。本文は含まない) */
+    issues;
+    constructor(code, message, issues) {
+        super(message);
+        this.name = 'TaskOpError';
+        this.code = code;
+        this.issues = issues;
+    }
+}
+/** 1 プロジェクトに対するタスク操作。CLI は projectRoot 解決後にこのクラスを使う */
+export class TaskOps {
+    projectRoot;
+    kanbanDir;
+    tasksDir;
+    enqueue = createSerialQueue();
+    constructor(projectRoot) {
+        this.projectRoot = path.resolve(projectRoot);
+        this.kanbanDir = path.join(this.projectRoot, '.kanban');
+        this.tasksDir = path.join(this.kanbanDir, 'tasks');
+    }
+    taskPath(id) {
+        return path.join(this.tasksDir, `${id}.md`);
+    }
+    /** 起票 (採番直列化・schema 検証・members 整合)。POST /api/tasks と同じロジック */
+    async create(input) {
+        // CLI は起票時の status を任意指定できる (HTTP POST は todo 固定だが、AI が backlog/proposed 等で
+        // 起票したいケースに対応)。status は newTaskInputSchema (.strict) の対象外なので分離してから検証する
+        const { status: requestedStatus, ...rest } = input;
+        const status = requestedStatus ?? NEW_TASK_STATUS_DEFAULT;
+        const parsed = newTaskInputSchema.safeParse(rest);
+        if (!parsed.success) {
+            throw new TaskOpError('invalid_input', '入力が不正', summarizeZodError(parsed.error));
+        }
+        const { config } = await loadConfig(this.projectRoot);
+        const violations = findMemberViolations({ created_by: parsed.data.created_by, assignee: parsed.data.assignee ?? null }, config);
+        if (violations.length > 0) {
+            throw new TaskOpError('unregistered_member', violations.join(' / '));
+        }
+        return this.enqueue(async () => {
+            const MAX_RETRY = 5;
+            for (let attempt = 0;; attempt++) {
+                const id = await allocateNextId(this.kanbanDir, config.idPrefix);
+                const now = nowIso();
+                const fmInput = {
+                    id,
+                    title: parsed.data.title,
+                    status,
+                    assignee: parsed.data.assignee ?? null,
+                    created_by: parsed.data.created_by,
+                    priority: parsed.data.priority ?? 'medium',
+                    labels: parsed.data.labels ?? [],
+                    blocked_type: null,
+                    blocked_reason: null,
+                    created: now,
+                    updated: now,
+                };
+                const fmResult = taskFrontmatterSchema.safeParse(fmInput);
+                if (!fmResult.success) {
+                    // pending を blocked_* 無しで起票しようとした等 (CLI の add では pending を避ける想定)
+                    throw new TaskOpError('invalid_input', '起票内容が不正', summarizeZodError(fmResult.error));
+                }
+                const filePath = this.taskPath(id);
+                try {
+                    await safeWriteFile(filePath, serializeTaskFile(fmResult.data, NEW_TASK_BODY), [this.kanbanDir], {
+                        exclusive: true,
+                    });
+                    return loadTaskView(this.projectRoot, filePath);
+                }
+                catch (error) {
+                    if (error instanceof FileExistsError && attempt < MAX_RETRY)
+                        continue;
+                    throw error;
+                }
+            }
+        });
+    }
+    /** ステータス変更 (pinpoint + verify)。PATCH /api/tasks/:id と同じロジック */
+    async move(id, input) {
+        if (!taskIdSchema.safeParse(id).success) {
+            throw new TaskOpError('invalid_input', '不正なタスク ID');
+        }
+        const parsed = moveInputSchema.safeParse(input);
+        if (!parsed.success) {
+            throw new TaskOpError('invalid_input', '入力が不正', summarizeZodError(parsed.error));
+        }
+        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})`);
+            }
+            const patch = { status: parsed.data.status, updated: nowIso() };
+            if (parsed.data.status === 'pending') {
+                patch.blocked_type = parsed.data.blocked_type ?? null;
+                patch.blocked_reason = parsed.data.blocked_reason ?? null;
+            }
+            else 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));
+            }
+            await safeWriteFile(filePath, patched, [this.kanbanDir]);
+            return loadTaskView(this.projectRoot, filePath);
+        });
+    }
+    /** 作業ログ追記 (## 作業ログ に 1 行)。frontmatter はバイト保全 */
+    async appendLog(id, member, message) {
+        return this.appendToSection(id, member, message, 'log');
+    }
+    /** やりとり追記 (## やりとり に 1 行)。member は config.members 検証 */
+    async appendComment(id, member, message) {
+        const { config } = await loadConfig(this.projectRoot);
+        if (!config.members.some((m) => m.id === member)) {
+            throw new TaskOpError('unregistered_member', `member "${member}" は config.members に未登録`);
+        }
+        return this.appendToSection(id, member, message, 'comment');
+    }
+    async appendToSection(id, member, message, section) {
+        if (!taskIdSchema.safeParse(id).success) {
+            throw new TaskOpError('invalid_input', '不正なタスク ID');
+        }
+        if (member.length === 0 || /[\r\n]/.test(member) || message.length === 0 || /[\r\n]/.test(message)) {
+            throw new TaskOpError('invalid_input', 'member / message は改行を含まない非空の値が必要');
+        }
+        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 m = error instanceof TaskFileParseError ? error.message : 'タスクファイルを解析できない';
+                throw new TaskOpError('conflict', `追記できない (${m})`);
+            }
+            // R9-1: 末尾の loadTaskView が taskFrontmatterSchema.parse() で raw ZodError を投げると、
+            // 「書込は成功済みなのに exit≠0」となり呼び出し側が再実行 → 同じ行が二重追記される。
+            // move/create と同じく「書込前に safeParse で弾く」対称性を取り、不正な frontmatter
+            // (status enum 外・未知キー等の AI 生編集 typo) は書込前に一貫した TaskOpError にする。
+            const fmCheck = taskFrontmatterSchema.safeParse(current.data);
+            if (!fmCheck.success) {
+                throw new TaskOpError('invalid_input', '追記前のタスクの frontmatter が不正', summarizeZodError(fmCheck.error));
+            }
+            const line = `${workLogTimestamp()} [${member}] ${message}`;
+            const newBody = section === 'log' ? appendWorkLogLine(current.body, line) : appendCommentLine(current.body, line);
+            await safeWriteFile(filePath, replaceBody(raw, newBody), [this.kanbanDir]);
+            return loadTaskView(this.projectRoot, filePath);
+        });
+    }
+}

package/dist/server/lib/time.js

@@ -0,0 +1,24 @@
+/**
+ * タイムゾーン付き ISO 8601 文字列の生成 (要件 §5.3: created / updated)。
+ * UTC へ変換せず、ローカルタイムゾーンのオフセット表記 (例: 2026-06-10T14:30:00+09:00) で出力する。
+ */
+export function nowIso(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, '0');
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? '+' : '-';
+    const absOffset = Math.abs(offsetMinutes);
+    return (`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}` +
+        `T${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}` +
+        `${sign}${pad(Math.floor(absOffset / 60))}:${pad(absOffset % 60)}`);
+}
+/** アーカイブ先の月別フォルダ名 `YYYY-MM` (アーカイブ操作を実行した月基準、要件 §5.1) */
+export function archiveMonth(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, '0');
+    return `${date.getFullYear()}-${pad(date.getMonth() + 1)}`;
+}
+/** 作業ログ行の時刻表記 `YYYY-MM-DD HH:mm` (ローカル時刻、§5.3 の作業ログ書式) */
+export function workLogTimestamp(date = new Date()) {
+    const pad = (value) => String(value).padStart(2, '0');
+    return (`${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ` +
+        `${pad(date.getHours())}:${pad(date.getMinutes())}`);
+}

package/dist/server/overview.js

@@ -0,0 +1,119 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { streamSSE } from 'hono/streaming';
+import { applySecurityMiddleware } from './app.js';
+import { loadBoard } from './board.js';
+import { createEventBus } from './events.js';
+/** 表示用 dir 名 (basename)。同名ルートは " (2)" 連番で一意化する */
+export function displayDirNames(roots) {
+    const seen = new Map();
+    return roots.map((root) => {
+        const base = path.basename(root);
+        const count = (seen.get(base) ?? 0) + 1;
+        seen.set(base, count);
+        return count === 1 ? base : `${base} (${count})`;
+    });
+}
+const ATTENTION_STATUSES = ['in_progress', 'pending', 'proposed'];
+function isAttentionStatus(status) {
+    return ATTENTION_STATUSES.includes(status);
+}
+/** 1 ルート分のサマリ + 注目タスクを loadBoard から導出する */
+async function summarizeRoot(root, dir) {
+    const board = await loadBoard(root);
+    const statusCounts = { proposed: 0, backlog: 0, todo: 0, in_progress: 0, pending: 0, done: 0 };
+    for (const task of board.tasks) {
+        statusCounts[task.frontmatter.status] += 1;
+    }
+    // WIP 超過: wipLimit のあるカラムで status 件数 > wipLimit (web の Column.tsx と同じ判定)
+    const countFor = (statusId) => board.tasks.filter((t) => t.frontmatter.status === statusId).length;
+    const wipExceeded = board.config.columns.some((col) => col.wipLimit !== undefined && countFor(col.id) > col.wipLimit);
+    // 表示名: config.projectName。config が「有効に読めていない」場合は dir basename にフォールバック (R12-3)。
+    // (1) config.json 不在 (loadConfig は不在でも既定値 "project" を返すため、不在判定はファイル存在で行う)
+    // (2) config.json は存在するが JSON 破損 / schema 不正 (loadBoard の warnings に config.json 由来の
+    //     invalid_config が載る。tasks ディレクトリ不在の invalid_config と区別するため path で絞る)
+    let configValid = true;
+    try {
+        await fs.access(path.join(root, '.kanban', 'config.json'));
+    }
+    catch {
+        configValid = false;
+    }
+    if (configValid && board.warnings.some((w) => w.kind === 'invalid_config' && w.path.endsWith('config.json'))) {
+        configValid = false;
+    }
+    const name = configValid ? board.config.projectName : path.basename(root);
+    const tasks = board.tasks
+        .filter((task) => isAttentionStatus(task.frontmatter.status))
+        .map((task) => ({
+        id: task.frontmatter.id,
+        title: task.frontmatter.title,
+        status: task.frontmatter.status,
+        assignee: task.frontmatter.assignee,
+        blocked_type: task.frontmatter.blocked_type,
+        blocked_reason: task.frontmatter.blocked_reason,
+        project: dir,
+    }));
+    return {
+        project: { name, dir, root, statusCounts, warningCount: board.warnings.length, wipExceeded },
+        tasks,
+    };
+}
+/** 注目タスクの表示順: in_progress → pending → proposed、同順位は project → id 昇順 */
+const ATTENTION_ORDER = { in_progress: 0, pending: 1, proposed: 2 };
+export async function buildOverview(roots) {
+    const dirs = displayDirNames(roots);
+    const projects = [];
+    const attention = [];
+    for (let i = 0; i < roots.length; i++) {
+        const { project, tasks } = await summarizeRoot(roots[i], dirs[i]);
+        projects.push(project);
+        attention.push(...tasks);
+    }
+    attention.sort((a, b) => ATTENTION_ORDER[a.status] - ATTENTION_ORDER[b.status] ||
+        a.project.localeCompare(b.project) ||
+        a.id.localeCompare(b.id, 'en', { numeric: true }));
+    return { projects, attention };
+}
+export function createOverviewApp(options) {
+    const projectRoots = options.projectRoots.map((root) => path.resolve(root));
+    const bus = options.bus ?? createEventBus();
+    const app = new Hono();
+    // セキュリティミドルウェア (CSP / Host / CSRF / bodyLimit) は board と共通 (R14-5)。
+    // overview は現状 GET のみだが CSRF 等の非対称を避けるため board と同一にする (LEARN#8b で共通化)
+    applySecurityMiddleware(app);
+    app.onError((error, c) => {
+        if (error instanceof HTTPException) {
+            return error.getResponse();
+        }
+        // N-8: タスク本文・設定内容・エラー詳細はログに出さない (種別のみ)
+        console.error('[aizuchi:overview]', c.req.method, c.req.path, error.name);
+        return c.json({ error: 'サーバー内部エラー' }, 500);
+    });
+    // GET /api/mode — SPA の起動時分岐用
+    app.get('/api/mode', (c) => {
+        return c.json({ mode: 'overview' });
+    });
+    // GET /api/overview — 全ルートのサマリ + 注目タスク (read-only)
+    app.get('/api/overview', async (c) => {
+        return c.json(await buildOverview(projectRoots));
+    });
+    // GET /api/events — SSE (通知のみ。クライアントは /api/overview を全量再取得する)
+    app.get('/api/events', (c) => {
+        return streamSSE(c, async (stream) => {
+            let unsubscribe = () => { };
+            const closed = new Promise((resolve) => {
+                stream.onAbort(() => resolve());
+            });
+            unsubscribe = bus.subscribe((event) => {
+                void stream.writeSSE({ data: JSON.stringify(event) });
+            });
+            await stream.writeSSE({ data: JSON.stringify({ type: 'connected' }) });
+            await closed;
+            unsubscribe();
+        });
+    });
+    return { app, bus };
+}

package/dist/server/static.js

@@ -0,0 +1,71 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+/**
+ * ビルド済み SPA (dist/web) の静的配信。serve コマンドが API ルートの後段に取り付ける。
+ * アセットはパッケージ内ディレクトリにあるため、cwd 基準の serveStatic は使わず
+ * 自前でパス検証 (traversal 拒否) 付きの配信を行う。
+ */
+const CONTENT_TYPES = {
+    '.html': 'text/html; charset=utf-8',
+    '.js': 'text/javascript; charset=utf-8',
+    '.css': 'text/css; charset=utf-8',
+    '.svg': 'image/svg+xml',
+    '.png': 'image/png',
+    '.ico': 'image/x-icon',
+    '.json': 'application/json; charset=utf-8',
+    '.map': 'application/json',
+    '.woff2': 'font/woff2',
+    '.woff': 'font/woff',
+};
+export function attachStaticAssets(app, webDistDir) {
+    const root = path.resolve(webDistDir);
+    // favicon は dist/web に同梱しないため、無ければ 204 を返してブラウザの 404 連発を避ける
+    // (dist/web/favicon.* があれば下の catch-all がそちらを配信する)
+    app.get('/favicon.ico', async (c, next) => {
+        try {
+            await fs.access(path.join(root, 'favicon.ico'));
+            return next();
+        }
+        catch {
+            return c.body(null, 204);
+        }
+    });
+    app.get('*', async (c) => {
+        // 不正な %エンコード (例: "/%") は decodeURIComponent が URIError を投げる。
+        // 500 に丸めず、トラバーサル拒否と同じく notFound に倒す
+        let urlPath;
+        try {
+            urlPath = decodeURIComponent(new URL(c.req.url).pathname);
+        }
+        catch {
+            return c.notFound();
+        }
+        if (urlPath.startsWith('/api/')) {
+            return c.notFound();
+        }
+        const rel = urlPath === '/' ? 'index.html' : urlPath.replace(/^\/+/, '');
+        const resolved = path.resolve(root, rel);
+        // 配信対象を dist/web 配下に限定する (パストラバーサル対策)
+        if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+            return c.notFound();
+        }
+        try {
+            const data = await fs.readFile(resolved);
+            const type = CONTENT_TYPES[path.extname(resolved).toLowerCase()] ?? 'application/octet-stream';
+            return c.body(new Uint8Array(data), 200, { 'content-type': type });
+        }
+        catch {
+            // SPA fallback: 拡張子の無いパスは index.html を返す (クライアント側ルーティング用)
+            if (path.extname(rel) === '') {
+                try {
+                    const html = await fs.readFile(path.join(root, 'index.html'), 'utf8');
+                    return c.html(html);
+                }
+                catch {
+                    return c.text('Web UI が未ビルドです。パッケージ開発中の場合は `npm run build` を実行してください。', 503);
+                }
+            }
+            return c.notFound();
+        }
+    });
+}

package/dist/server/watcher.js

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { watch } from 'chokidar';
+/** 監視対象: タスクファイル (.md) と config.json のみ。アトミック書込の .tmp は無視する */
+function isWatchTarget(filePath) {
+    const base = path.basename(filePath);
+    return base.endsWith('.md') || base === 'config.json';
+}
+export function startWatcher(options) {
+    const { kanbanDir, bus } = options;
+    const debounceMs = options.debounceMs ?? 200;
+    const watcher = watch(kanbanDir, { ignoreInitial: true });
+    let timer = null;
+    const onFsEvent = (filePath) => {
+        if (!isWatchTarget(filePath))
+            return;
+        if (timer !== null)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = null;
+            bus.broadcast({ type: 'change' });
+        }, debounceMs);
+    };
+    watcher.on('add', onFsEvent);
+    watcher.on('change', onFsEvent);
+    watcher.on('unlink', onFsEvent);
+    // error listener 不在だと EventEmitter が同期 throw して serve プロセスごと落ちる。
+    // watch 不能は SSE 通知が止まるだけ (手動リロードで回復可能) なので握って継続する
+    watcher.on('error', () => { });
+    return {
+        async close() {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            await watcher.close();
+        },
+    };
+}

package/dist/shared/critical-path.js

@@ -0,0 +1,128 @@
+/**
+ * クリティカルパス分析 (CP ビュー、波 II)。依存追加なしの純関数。
+ *
+ * 入力: 未完了タスクの id と depends_on の辺。done / archive 済みは呼び出し側で除外する。
+ * 出力: トポロジカル深さ (level)・クリティカルパス (最長依存鎖)・循環依存。
+ *
+ * 日付・期間は一切扱わない (RYU 指示: AI 開発では日程が無意味、依存の重要経路だけを見る)。
+ *
+ * 辺の向き: 「A depends_on B」= B が先・A が後。B を A の prerequisite (先行) とする。
+ * level(node) = その node に至る最長の先行鎖の長さ (先行なし = 0)。
+ * クリティカルパス = level が最大のノードへ至る最長鎖 (= プロジェクト完了を律速する依存連鎖)。
+ */
+/**
+ * 依存グラフを解析する。グラフに存在しない id への depends_on は辺として無視する
+ * (done で除外済みの先行・タイプミス等)。
+ */
+export function analyzeCriticalPath(input) {
+    const ids = new Set(input.map((n) => n.id));
+    // グラフ内に存在する辺だけ採用する (存在しない先行は無視)
+    const prereqs = new Map();
+    for (const n of input) {
+        prereqs.set(n.id, n.dependsOn.filter((d) => ids.has(d) && d !== n.id));
+    }
+    // 循環検出 (DFS 3 色)。循環に関与する全ノードを集める
+    const WHITE = 0;
+    const GRAY = 1;
+    const BLACK = 2;
+    const color = new Map();
+    const cycleNodes = new Set();
+    for (const id of ids)
+        color.set(id, WHITE);
+    const stack = [];
+    const onStack = new Set();
+    const dfs = (id) => {
+        color.set(id, GRAY);
+        stack.push(id);
+        onStack.add(id);
+        for (const dep of prereqs.get(id) ?? []) {
+            if (color.get(dep) === GRAY) {
+                // dep から id までが循環。stack 上の dep..top を循環ノードに
+                const start = stack.indexOf(dep);
+                for (let i = start; i < stack.length; i++)
+                    cycleNodes.add(stack[i]);
+            }
+            else if (color.get(dep) === WHITE) {
+                dfs(dep);
+            }
+        }
+        color.set(id, BLACK);
+        stack.pop();
+        onStack.delete(id);
+    };
+    for (const id of ids) {
+        if (color.get(id) === WHITE)
+            dfs(id);
+    }
+    // level 計算: 循環に関与しないノードのみ。level(n) = max(level(prereq)) + 1 (先行なし=0)。
+    // メモ化 DFS。循環ノードに触れたら null
+    const levelMemo = new Map();
+    const computing = new Set();
+    const computeLevel = (id) => {
+        if (cycleNodes.has(id))
+            return null;
+        if (levelMemo.has(id))
+            return levelMemo.get(id) ?? null;
+        if (computing.has(id))
+            return null; // 念のための保険 (循環検出済みなら通らない)
+        computing.add(id);
+        let max = -1;
+        for (const dep of prereqs.get(id) ?? []) {
+            const dl = computeLevel(dep);
+            if (dl === null) {
+                computing.delete(id);
+                levelMemo.set(id, null);
+                return null;
+            }
+            if (dl > max)
+                max = dl;
+        }
+        computing.delete(id);
+        const level = max + 1;
+        levelMemo.set(id, level);
+        return level;
+    };
+    let maxLevel = -1;
+    for (const id of ids) {
+        const lv = computeLevel(id);
+        if (lv !== null && lv > maxLevel)
+            maxLevel = lv;
+    }
+    // tie-break は数値考慮の ID 昇順で統一する (nodes / cycleNodes と一致させる R7)
+    const byNumericId = (a, b) => a.localeCompare(b, 'en', { numeric: true });
+    // クリティカルパス: level 最大のノードから先行を最長にたどる (level が 1 ずつ減る鎖)
+    let criticalPath = [];
+    if (maxLevel >= 0) {
+        // level 最大のノードを終点候補にする (複数あれば数値考慮 id 昇順で決定的に最初の 1 つ)
+        const endpoints = [...ids].filter((id) => levelMemo.get(id) === maxLevel).sort(byNumericId);
+        if (endpoints.length > 0) {
+            const path = [];
+            let cur = endpoints[0];
+            while (cur !== undefined) {
+                path.push(cur);
+                const curLevel = levelMemo.get(cur);
+                // level が 1 小さい先行を選ぶ (最長鎖を構成する辺)
+                const next = (prereqs.get(cur) ?? [])
+                    .filter((d) => levelMemo.get(d) === (curLevel ?? 0) - 1)
+                    .sort(byNumericId);
+                cur = next[0];
+            }
+            criticalPath = path.reverse(); // 先行 → 後続の順
+        }
+    }
+    const cpSet = new Set(criticalPath);
+    const nodes = input
+        .map((n) => ({
+        id: n.id,
+        level: levelMemo.get(n.id) ?? null,
+        dependsOn: prereqs.get(n.id) ?? [],
+        onCriticalPath: cpSet.has(n.id),
+    }))
+        .sort((a, b) => a.id.localeCompare(b.id, 'en', { numeric: true }));
+    return {
+        nodes,
+        criticalPath,
+        cycleNodes: [...cycleNodes].sort((a, b) => a.localeCompare(b, 'en', { numeric: true })),
+        maxLevel,
+    };
+}

package/dist/shared/diff.js

@@ -0,0 +1,46 @@
+/**
+ * 行単位の LCS (最長共通部分列) diff (技術決定⑦)。
+ * PUT 競合 (409) 時にローカル編集とサーバー側内容の差分を提示するために使う。
+ * 依存を追加せず ~50 行で実装する。server / web が共有する。
+ */
+/**
+ * 2 つのテキストを行単位で比較し、変更箇所を返す。
+ * `equal` = 両方にある行、`remove` = a のみ (削除)、`add` = b のみ (追加)。
+ */
+export function diffLines(a, b) {
+    const aLines = a.split('\n');
+    const bLines = b.split('\n');
+    const n = aLines.length;
+    const m = bLines.length;
+    // 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--) {
+        for (let j = m - 1; j >= 0; j--) {
+            lcs[i][j] = aLines[i] === bLines[j] ? lcs[i + 1][j + 1] + 1 : Math.max(lcs[i + 1][j], lcs[i][j + 1]);
+        }
+    }
+    // 表をたどって diff を組み立てる
+    const result = [];
+    let i = 0;
+    let j = 0;
+    while (i < n && j < m) {
+        if (aLines[i] === bLines[j]) {
+            result.push({ op: 'equal', text: aLines[i] });
+            i++;
+            j++;
+        }
+        else if (lcs[i + 1][j] >= lcs[i][j + 1]) {
+            result.push({ op: 'remove', text: aLines[i] });
+            i++;
+        }
+        else {
+            result.push({ op: 'add', text: bLines[j] });
+            j++;
+        }
+    }
+    while (i < n)
+        result.push({ op: 'remove', text: aLines[i++] });
+    while (j < m)
+        result.push({ op: 'add', text: bLines[j++] });
+    return result;
+}