mmm-mcp-server 0.1.2 → 0.1.3

package/dist/src/domain/appendForest.js

@@ -1,5 +1,4 @@
 import { newDocId } from "./idGen.js";
-import { lastChildOf } from "./body.js";
 /** ネストしたツリー入力を、ID採番済み・prev/next/parent/child関係を組んだ配列に変換する。 */
 export function buildForestFromTree(roots) {
     const all = [];
@@ -31,52 +30,3 @@ export function buildForestFromTree(roots) {
     build(roots, null);
     return all;
 }
-/**
- * 組み立てたforest(森)を、既存の要素の[targetParentId]配下の末尾に連結する
- * ためのFirestore書き込み一覧を作る。auto_structure_thought /
- * import_markdown_context の両方から共通で使う。
- *
- * `isTodo`がfalseのマップでは、doneは常にfalseとして書き込む
- * (MatryoshkaModel.importMarkdownと同じ挙動)。
- */
-export function buildAppendWrites(bodiesPath, existingBodies, forest, targetParentId, isTodo) {
-    const roots = forest.filter((n) => n.parentId === null);
-    const last = lastChildOf(existingBodies, targetParentId);
-    if (roots.length > 0) {
-        roots[0].prevId = last;
-    }
-    const writes = forest.map((node) => ({
-        path: `${bodiesPath}/${node.id}`,
-        fields: {
-            detail: node.detail,
-            parent: node.parentId ?? targetParentId,
-            prev: node.prevId,
-            next: node.nextId,
-            child: node.childId,
-            done: isTodo ? node.done : false,
-        },
-    }));
-    if (roots.length > 0) {
-        if (last !== null) {
-            // 末尾要素のnextを書き換える。読み取り後に他の操作(並行するappendや
-            // アプリ操作)がこの要素を書き換えていた場合、requireUpdateTimeにより
-            // FAILED_PRECONDITIONで失敗する(呼び出し側はrunOptimisticで読み取り
-            // からやり直す)。
-            const lastBody = existingBodies.find((b) => b.id === last);
-            writes.push({
-                path: `${bodiesPath}/${last}`,
-                fields: { next: roots[0].id },
-                requireUpdateTime: lastBody?.updateTime,
-            });
-        }
-        else if (targetParentId !== null) {
-            const parentBody = existingBodies.find((b) => b.id === targetParentId);
-            writes.push({
-                path: `${bodiesPath}/${targetParentId}`,
-                fields: { child: roots[0].id },
-                requireUpdateTime: parentBody?.updateTime,
-            });
-        }
-    }
-    return { writes, createdIds: forest.map((n) => n.id) };
-}

package/dist/src/domain/levels.js

@@ -7,17 +7,7 @@
 // levelIdはマップ最上位が'root'、それ以外はその要素自身のid。配列の並び順が
 // そのまま兄弟順。子を持つ要素だけドキュメントが存在する(無ければ葉)。
 //
-// MCPは「新形式のみ対応」(移行ロジックはDart側だけに持たせる)。levels/root
-// が無いマップに対する操作は、切替前(bodiesとlevelsの両方へ書く間)だけ、
-// アプリで一度開いてもらうよう案内して止める。切替後は空のマップとして扱う
-// (levelsMode.tsのreadLevelsSnapshot)。
-export class LevelsNotInitializedError extends Error {
-    constructor(title) {
-        super(`「${title}」はまだ新形式(levels)のデータがありません。` +
-            "お手数ですが、アプリでこのマップを一度開いてから、もう一度お試しください。");
-        this.name = "LevelsNotInitializedError";
-    }
-}
+// 書き込みは levelsOps.ts が行う。ここはデータ形状の解釈と読み取りだけを持つ。
 function toEntry(raw) {
     if (typeof raw !== "object" || raw === null)
         return null;
@@ -51,33 +41,9 @@ export async function readAllLevelDocs(client, levelsPath) {
     }
     return result;
 }
-/** levels/rootが無ければ、アプリで開いてもらうよう案内して止める。 */
-export function assertLevelsInitialized(levelsById, mapTitle) {
-    if (!levelsById.has("root")) {
-        throw new LevelsNotInitializedError(mapTitle);
-    }
-}
-/**
- * [levelId]のlevelsドキュメントが存在するかだけを軽く確認する。
- * 「levels/rootが無ければ止める」ような存在チェックのためだけに
- * readAllLevelDocs(コレクション全体のページング読み取り)を使うのは、
- * 子を多く持つ大きなマップほど無駄が大きい。1件のgetDocumentで足りる
- * 場面(list_elementsのようにツリー全体が実際に必要な場合を除く)は
- * こちらを使うこと。
- */
-export async function levelsDocExists(client, levelsPath, levelId) {
-    return (await client.getDocument(`${levelsPath}/${levelId}`)) !== null;
-}
-/** [levelsDocExists]の結果を見て、levels/rootが無ければ止める。 */
-export function assertLevelsRootExists(rootExists, mapTitle) {
-    if (!rootExists) {
-        throw new LevelsNotInitializedError(mapTitle);
-    }
-}
 /**
- * 'root'から再帰的にlevelsを展開してツリーを組み立てる(bodies版buildTreeの
- * levels版)。levelsは配列そのものが順序を表すため、連結リストの再構築や
- * 分断の復元は不要。循環参照だけは防御的に検出して打ち切る。
+ * 'root'から再帰的にlevelsを展開してツリーを組み立てる。levelsは配列そのものが
+ * 順序を表すため、並び順の再構築は不要。循環参照だけは防御的に検出して打ち切る。
  */
 export function buildTreeFromLevels(levelsById) {
     function walk(levelId, parentId, ancestry) {
@@ -97,148 +63,3 @@ export function buildTreeFromLevels(levelsById) {
     }
     return walk("root", null, new Set());
 }
-/**
- * forest(bodies用のbuildAppendWritesと同じ入力)から、levels側の書き込み
- * 一覧を組み立てる。forest内で子を持つノードごとに levels/{id} を新規作成し、
- * forestの最上位(ルート)群は挿入先(targetParentId ?? 'root')の既存配列へ
- * 追記する。[targetHasExistingChildren]は、bodies側でlastChildOfが返した
- * 値がnullでなかったか(＝挿入先が既に子を持っていたか)をそのまま渡すこと。
- */
-export function buildAppendLevelWrites(levelsPath, forest, targetParentId, targetHasExistingChildren, isTodo) {
-    const writes = [];
-    const byParent = new Map();
-    for (const node of forest) {
-        const list = byParent.get(node.parentId) ?? [];
-        list.push(node);
-        byParent.set(node.parentId, list);
-    }
-    const entryOf = (node) => ({
-        id: node.id,
-        detail: node.detail,
-        done: isTodo ? node.done : false,
-    });
-    // forest内で子を持つノードは全て新規作成なので、既存のlevels/{id}と
-    // 衝突することはない(既存ドキュメントは無いはず)。
-    for (const [parentId, children] of byParent) {
-        if (parentId === null)
-            continue; // ルート群は下で挿入先へ追記する
-        writes.push({
-            path: `${levelsPath}/${parentId}`,
-            fields: { children: children.map(entryOf) },
-        });
-    }
-    const roots = byParent.get(null) ?? [];
-    if (roots.length > 0) {
-        const targetLevelId = targetParentId ?? "root";
-        if (targetHasExistingChildren) {
-            writes.push({
-                path: `${levelsPath}/${targetLevelId}`,
-                arrayUnion: { field: "children", values: roots.map(entryOf) },
-            });
-        }
-        else {
-            writes.push({
-                path: `${levelsPath}/${targetLevelId}`,
-                fields: { children: roots.map(entryOf) },
-            });
-        }
-    }
-    return writes;
-}
-/**
- * [levelId]のlevelsドキュメントのchildren配列から、idが[removeIds]に含まれる
- * エントリを取り除くFirestoreWriteを1件返す。ドキュメントが無ければ何もしない
- * (levelsはbest-effortの書き込みで、bodiesと食い違っていても実害は無いため)。
- * requireUpdateTimeで楽観的ロックする(呼び出し側はrunOptimisticで使うこと)。
- */
-export async function buildRemoveChildrenWrite(client, levelsPath, levelId, removeIds) {
-    const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-    if (!doc)
-        return null;
-    const children = childrenOf(doc.data).filter((c) => !removeIds.includes(c.id));
-    return { path: `${levelsPath}/${levelId}`, fields: { children }, requireUpdateTime: doc.updateTime };
-}
-/**
- * [levelId]のlevelsドキュメントのchildren配列の[afterId]の直後(nullなら先頭)に
- * [entry]を挿入するFirestoreWriteを1件返す。ドキュメントが無ければ新規作成する
- * (この場合はrequireUpdateTimeを付けない = 何も無い前提で作成する)。[afterId]が
- * 見つからない場合は末尾に足す(Dart版LevelsRepository.insertChildと同じ方針)。
- */
-/**
- * [levelId]のchildrenの中で[entry]を一度取り除いてから、[afterId]の直後
- * (nullなら先頭)へ入れ直す書き込みを作る。同じ親の中での並べ替え専用。
- *
- * **remove用とinsert用の書き込みを別々に作って両方commitしてはいけない。**
- * どちらも「元のchildren」を読んでから組み立てるため、同じドキュメントへの
- * 書き込みが2つできて後勝ちになり、要素が重複する。
- */
-export async function buildReorderChildWrite(client, levelsPath, levelId, entry, afterId) {
-    const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-    const children = (doc ? childrenOf(doc.data) : []).filter((c) => c.id !== entry.id);
-    const insertIndex = afterId === null
-        ? 0
-        : (() => {
-            const found = children.findIndex((c) => c.id === afterId);
-            return found === -1 ? children.length : found + 1;
-        })();
-    children.splice(Math.min(Math.max(insertIndex, 0), children.length), 0, entry);
-    return {
-        path: `${levelsPath}/${levelId}`,
-        fields: { children },
-        requireUpdateTime: doc?.updateTime,
-    };
-}
-export async function buildInsertChildWrite(client, levelsPath, levelId, entry, afterId) {
-    const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-    const children = doc ? childrenOf(doc.data) : [];
-    const insertIndex = afterId === null
-        ? 0
-        : (() => {
-            const found = children.findIndex((c) => c.id === afterId);
-            return found === -1 ? children.length : found + 1;
-        })();
-    children.splice(Math.min(Math.max(insertIndex, 0), children.length), 0, entry);
-    return {
-        path: `${levelsPath}/${levelId}`,
-        fields: { children },
-        requireUpdateTime: doc?.updateTime,
-    };
-}
-/**
- * update_task_status用。[updates]を親ごとにグループ化し、levelsドキュメントを
- * 親ごとに1回だけ読んで該当エントリを書き換えた配列を書き戻すFirestoreWrite[]
- * を組み立てる(Dart版LevelsRepository.updateChildと同じ「読んで置換」方式)。
- * 該当ドキュメントや該当エントリが見つからない場合は、その分だけ静かに
- * スキップする(levelsはbest-effortの書き込みで、失敗しても実害は無いため)。
- */
-export async function buildUpdateEntryWrites(client, levelsPath, updates) {
-    const byLevelId = new Map();
-    for (const update of updates) {
-        const levelId = update.parentId ?? "root";
-        const list = byLevelId.get(levelId) ?? [];
-        list.push({ elementId: update.elementId, patch: update.patch });
-        byLevelId.set(levelId, list);
-    }
-    const writes = [];
-    for (const [levelId, group] of byLevelId) {
-        const doc = await client.getDocument(`${levelsPath}/${levelId}`);
-        if (!doc)
-            continue;
-        const children = childrenOf(doc.data);
-        for (const { elementId, patch } of group) {
-            const index = children.findIndex((c) => c.id === elementId);
-            if (index === -1)
-                continue;
-            children[index] = { ...children[index], ...patch };
-        }
-        // requireUpdateTime: 読み取り後に他の操作がこのlevelsドキュメントを
-        // 書き換えていた場合、この書き込みはFAILED_PRECONDITIONで失敗する
-        // (呼び出し側はrunOptimisticで読み取りからやり直すこと)。
-        writes.push({
-            path: `${levelsPath}/${levelId}`,
-            fields: { children },
-            requireUpdateTime: doc.updateTime,
-        });
-    }
-    return writes;
-}

package/dist/src/domain/levelsOps.js

@@ -1,5 +1,4 @@
-// levels移行・切替後(config/app.migrationEnabled が true)の書き込み。
-// bodiesを一切読まず書かず、levelsコレクションだけで要素を探して書き換える。
+// levelsコレクションの読み取り結果から、要素を探して書き換える書き込みを組み立てる。
 //
 // どの操作も「levels全件の読み取り結果(LevelsSnapshot)」を受け取る純粋関数で、
 // 触った子一覧を作業用に複製して編集し、最後に元の状態との差分から
@@ -12,6 +11,15 @@ import { childrenOf } from "./levels.js";
 export function levelsSnapshotFromDocs(docs) {
     return new Map(docs.map((d) => [d.id, { children: childrenOf(d.data), updateTime: d.updateTime }]));
 }
+/**
+ * levels全件を読む。levels/rootが無いマップは空のマップとして扱う
+ * (rootへの最初の書き込みは、存在しないことを前提条件にした新規作成になる)。
+ * アプリで開いてもrootは作られないので、無いときに止めると中身の無い古い
+ * マップへ永久に書き込めなくなる。
+ */
+export async function readLevelsSnapshot(client, levelsPath) {
+    return levelsSnapshotFromDocs(await client.listDocuments(levelsPath));
+}
 /**
  * rootから辿れる要素だけを対象に、要素id -> 場所 の索引を作る。
  * どこからも辿れない子一覧ドキュメント(過去の不整合の残骸)の中身は数えない。

package/dist/src/domain/mapResolver.js

@@ -30,10 +30,7 @@ export async function resolveMap(client, session, mapId) {
     }
     throw new MapNotFoundError(mapId);
 }
-export function bodiesPathOf(map) {
-    return `users/${map.ownerUid}/headers/${map.headerId}/bodies`;
-}
-/** levels移行: bodiesPathOfと対になる、階層ごとの子一覧を配列で持つ新形式コレクション。 */
+/** マップの中身(階層ごとの子一覧を配列で持つコレクション)のパス。 */
 export function levelsPathOf(map) {
     return `users/${map.ownerUid}/headers/${map.headerId}/levels`;
 }

package/dist/src/domain/markdownParser.js

@@ -93,30 +93,29 @@ export function parseMarkdownForImport(markdownText, { headingsAsNodes }) {
     return { nodes, headingTitle, hasCheckbox };
 }
 function buildRelations(nodes) {
-    if (nodes.length === 0)
-        return;
-    const uniqueIndents = [...new Set(nodes.map((n) => n.rawIndent))].sort((a, b) => a - b);
-    const indentToDepth = new Map();
-    uniqueIndents.forEach((indent, i) => indentToDepth.set(indent, i));
-    const lastNodeAtDepth = new Map();
-    const byId = new Map(nodes.map((n) => [n.id, n]));
+    // 親は「自分より字下げが浅い直近の要素」とする。字下げの幅(2・4・タブ)は
+    // 浅い深いの比較にしか使わないので、刻み幅が混ざっても同じ結果になる。
+    // 段を飛ばした字下げ(`#`の直下の`-`、字下げのばらつき)でも必ず
+    // どこかへ繋がり、親も前の兄弟も無い要素ができない。
+    // 祖先の並び。末尾が直前の要素で、字下げは末尾ほど深い。
+    const ancestors = [];
+    // 親のID(最上位はnull)ごとの、いちばん後ろの子。
+    const lastChildOf = new Map();
     for (const node of nodes) {
-        const depth = indentToDepth.get(node.rawIndent) ?? 0;
-        if (depth > 0) {
-            node.parentId = lastNodeAtDepth.get(depth - 1) ?? null;
+        while (ancestors.length > 0 && ancestors[ancestors.length - 1].rawIndent >= node.rawIndent) {
+            ancestors.pop();
         }
-        const prevId = lastNodeAtDepth.get(depth);
-        if (prevId !== undefined) {
-            node.prevId = prevId;
-            byId.get(prevId).nextId = node.id;
+        const parent = ancestors.length > 0 ? ancestors[ancestors.length - 1] : null;
+        node.parentId = parent?.id ?? null;
+        const prev = lastChildOf.get(node.parentId);
+        if (prev !== undefined) {
+            node.prevId = prev.id;
+            prev.nextId = node.id;
         }
-        else if (node.parentId !== null) {
-            byId.get(node.parentId).childId = node.id;
-        }
-        lastNodeAtDepth.set(depth, node.id);
-        for (const key of [...lastNodeAtDepth.keys()]) {
-            if (key > depth)
-                lastNodeAtDepth.delete(key);
+        else if (parent !== null) {
+            parent.childId = node.id;
         }
+        lastChildOf.set(node.parentId, node);
+        ancestors.push(node);
     }
 }

package/dist/src/firestore/restClient.js

@@ -29,45 +29,6 @@ async function parseJsonResponse(res) {
 }
 /** Firestoreの1コミット(:commit)に含められる書き込み件数の上限(500)より余裕を持たせた値。 */
 const COMMIT_CHUNK_SIZE = 400;
-/**
- * 同じドキュメントを指す書き込みを1件にまとめる。
- *
- * **1回のcommitに同じpathの書き込みを2つ以上積んではいけない。** Firestoreは
- * エラーにせず順に適用するため、後の書き込みが前の書き込みを打ち消す。
- * 実データで2度踏んだ(move_elementで要素が重複、delete_elementsで存在しない
- * IDを指すポインタが残る)。writesを返す直前に必ずこれを通すこと。
- *
- * deleteが1つでもあればdeleteが勝つ(消すドキュメントへの部分更新は無意味)。
- * fields同士はマージし、requireUpdateTimeは最初に読み取った値を残す。
- */
-export function mergeWritesByPath(writes) {
-    const byPath = new Map();
-    const order = [];
-    for (const write of writes) {
-        const prev = byPath.get(write.path);
-        if (!prev) {
-            byPath.set(write.path, { ...write });
-            order.push(write.path);
-            continue;
-        }
-        if (write.delete || prev.delete) {
-            byPath.set(write.path, { path: write.path, delete: true });
-            continue;
-        }
-        if (write.arrayUnion || prev.arrayUnion) {
-            // 配列追記と通常の更新は混ぜられない。後から積んだ方を採る。
-            byPath.set(write.path, { ...write });
-            continue;
-        }
-        byPath.set(write.path, {
-            path: write.path,
-            fields: { ...(prev.fields ?? {}), ...(write.fields ?? {}) },
-            requireUpdateTime: prev.requireUpdateTime ?? write.requireUpdateTime,
-            requireMissing: prev.requireMissing ?? write.requireMissing,
-        });
-    }
-    return order.map((path) => byPath.get(path));
-}
 export class FirestoreRestClient {
     session;
     constructor(session) {

package/dist/src/server.js

@@ -12,7 +12,7 @@ import { registerDeleteElements } from "./tools/deleteElements.js";
 import { registerMoveElement } from "./tools/moveElement.js";
 const server = new McpServer({
     name: "matryoshka-mindmap",
-    version: "0.1.2",
+    version: "0.1.3",
 }, {
     instructions: "このサーバーはリアルタイム同期を行わない。各ツールは呼び出された瞬間の" +
         "Firestoreの状態を返すだけで、アプリ側でユーザーが直接行った変更は" +

package/dist/src/tools/autoStructureThought.js

@@ -1,12 +1,8 @@
 import { z } from "zod";
-import { mergeWritesByPath } from "../firestore/restClient.js";
 import { getContext } from "../mcpContext.js";
-import { isLevelsOnly, readLevelsSnapshot } from "../domain/levelsMode.js";
-import { ancestorDetailsInLevels, buildLevelsAppendWrites, locateInLevels } from "../domain/levelsOps.js";
-import { resolveMap, bodiesPathOf, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
-import { bodyFromFirestore, ancestorDetails } from "../domain/body.js";
-import { buildForestFromTree, buildAppendWrites } from "../domain/appendForest.js";
-import { assertLevelsRootExists, buildAppendLevelWrites, levelsDocExists } from "../domain/levels.js";
+import { ancestorDetailsInLevels, buildLevelsAppendWrites, locateInLevels, readLevelsSnapshot } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
+import { buildForestFromTree } from "../domain/appendForest.js";
 const treeNodeSchema = z.lazy(() => z.object({
     detail: z.string().min(1).describe("要素の本文"),
     done: z.boolean().optional().describe("TODOマップのときのチェック状態(省略時false)"),
@@ -29,57 +25,22 @@ export function registerAutoStructureThought(server) {
         const map = await resolveMap(client, session, mapId);
         assertCanEditMap(map, session);
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
         const targetParentId = parentElementId ?? null;
         const forest = buildForestFromTree(nodes);
-        if (await isLevelsOnly(client)) {
-            let levelsPathResult = "";
-            await client.runOptimistic(async () => {
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                if (targetParentId !== null && !locateInLevels(snapshot, targetParentId)) {
-                    throw new Error(`parentElementId(${targetParentId})がこのマップに見つかりません。list_elementsで確認してください。`);
-                }
-                levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, targetParentId));
-                return buildLevelsAppendWrites(levelsPath, snapshot, forest, targetParentId, map.header.isTodo);
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ path: levelsPathResult, addedElementCount: forest.length }, null, 2),
-                    },
-                ],
-            };
-        }
-        // 読み取り(bodies一覧・levels存在確認)から書き込みまでを楽観的
-        // ロックでまとめる。読み取り後に対象ドキュメントが他から変更される
-        // とコミットがFAILED_PRECONDITIONになり、読み取りからやり直す。
-        let createdIds = [];
-        let existingBodiesForPath = [];
+        let levelsPathResult = "";
         await client.runOptimistic(async () => {
-            assertLevelsRootExists(await levelsDocExists(client, levelsPath, "root"), map.header.title);
-            const existingDocs = await client.listDocuments(bodiesPath);
-            const existingBodies = existingDocs.map((d) => bodyFromFirestore(d.id, d.data, d.updateTime));
-            existingBodiesForPath = existingBodies;
-            if (targetParentId !== null && !existingBodies.some((b) => b.id === targetParentId)) {
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
+            if (targetParentId !== null && !locateInLevels(snapshot, targetParentId)) {
                 throw new Error(`parentElementId(${targetParentId})がこのマップに見つかりません。list_elementsで確認してください。`);
             }
-            const { writes, createdIds: ids } = buildAppendWrites(bodiesPath, existingBodies, forest, targetParentId, map.header.isTodo);
-            createdIds = ids;
-            // 挿入先のlevelsドキュメントが実際に存在するかを直接確認する
-            // (bodies側の状態から推測すると、levelsとbodiesが食い違っている
-            // 場合にarrayUnion書き込みが「ドキュメントが無い」で失敗しうるため)。
-            const targetLevelId = targetParentId ?? "root";
-            const targetHasLevelsDoc = targetLevelId === "root" || (await levelsDocExists(client, levelsPath, targetLevelId));
-            const levelWrites = buildAppendLevelWrites(levelsPath, forest, targetParentId, targetHasLevelsDoc, map.header.isTodo);
-            return mergeWritesByPath([...writes, ...levelWrites]);
+            levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, targetParentId));
+            return buildLevelsAppendWrites(levelsPath, snapshot, forest, targetParentId, map.header.isTodo);
         });
-        const path = formatPath(map.header.title, ancestorDetails(existingBodiesForPath, targetParentId));
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({ path, addedElementCount: createdIds.length }, null, 2),
+                    text: JSON.stringify({ path: levelsPathResult, addedElementCount: forest.length }, null, 2),
                 },
             ],
         };

package/dist/src/tools/createMap.js

@@ -12,12 +12,8 @@ export function registerCreateMap(server) {
         const { client, session } = getContext();
         const existing = await client.listDocuments(`users/${session.uid}/headers`);
         const maxOrder = existing.reduce((max, doc) => Math.max(max, Number(doc.data.order ?? 0)), 0);
-        // levels移行: 自前でIDを採番し、header本体と空のlevels/rootを1回の
-        // commitWritesにまとめて作る。levels/rootを最初から持たせておくことで、
-        // 直後に書き込み系ツールを呼んでも「アプリで一度開いてください」で
-        // 弾かれない(移行ではなく単なる初期化なので問題ない)。
-        // migratedはアプリの新規作成(header_add_model.dart)と揃える。無いと、
-        // 切替前のアプリが開いたときに未移行とみなしてbodiesから作り直してしまう。
+        // 自前でIDを採番し、header本体と空のlevels/rootを1回のcommitWritesに
+        // まとめて作る(アプリの新規作成 header_add_model.dart と揃える)。
         const headerId = newDocId();
         const headerPath = `users/${session.uid}/headers/${headerId}`;
         await client.commitWrites([
@@ -25,7 +21,7 @@ export function registerCreateMap(server) {
                 path: headerPath,
                 fields: { title, order: maxOrder + 1, isTodo, editors: [], viewers: [] },
             },
-            { path: `${headerPath}/levels/root`, fields: { children: [], migrated: true } },
+            { path: `${headerPath}/levels/root`, fields: { children: [] } },
         ]);
         return {
             content: [