mmm-mcp-server 0.1.2 → 0.2.0

package/dist/src/tools/deleteElements.js

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { getContext } from "../mcpContext.js";
-import { isLevelsOnly, readLevelsSnapshot } from "../domain/levelsMode.js";
-import { ancestorDetailsInLevels, buildLevelsDeleteWrites, locateInLevels, subtreeIdsInLevels } from "../domain/levelsOps.js";
-import { resolveMap, bodiesPathOf, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
-import { bodyFromFirestore, ancestorDetails, collectSubtreeIds } from "../domain/body.js";
-import { assertLevelsRootExists, levelsDocExists } from "../domain/levels.js";
-import { buildDeleteElementWrites } from "../domain/deleteElements.js";
+import { ancestorDetailsInLevels, buildLevelsDeleteWrites, locateInLevels, subtreeIdsInLevels, readLevelsSnapshot, withLinkSummary, } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, headerPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
 export function registerDeleteElements(server) {
     server.tool("delete_elements", "既存マップから要素を削除する。指定した要素とその配下(子孫)を丸ごと削除する。" +
         "削除は取り返しがつかないため、まずconfirmedを省略(またはfalse)で呼び、" +
@@ -22,88 +18,20 @@ export function registerDeleteElements(server) {
         const map = await resolveMap(client, session, mapId);
         assertCanEditMap(map, session);
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
-        // 切替後はrootが無いマップを空のマップとして扱うので、この確認は切替前だけ。
-        const levelsOnly = await isLevelsOnly(client);
-        if (!levelsOnly) {
-            assertLevelsRootExists(await levelsDocExists(client, levelsPath, "root"), map.header.title);
-        }
-        if (levelsOnly) {
-            if (confirmed !== true) {
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                const allTargets = new Set();
-                const targets = [];
-                for (const elementId of elementIds) {
-                    if (!locateInLevels(snapshot, elementId)) {
-                        throw new Error(`elementId(${elementId})がこのマップに見つかりません。list_elementsで確認してください。`);
-                    }
-                    const subtree = subtreeIdsInLevels(snapshot, elementId);
-                    for (const id of subtree)
-                        allTargets.add(id);
-                    targets.push({
-                        elementId,
-                        path: formatPath(map.header.title, ancestorDetailsInLevels(snapshot, elementId)),
-                        subtreeCount: subtree.length,
-                    });
-                }
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify({
-                                confirmationRequired: true,
-                                message: "削除は取り返しがつきません。以下の内容をユーザーに提示して明示的な同意を得てから、" +
-                                    "confirmed: trueで呼び直してください。",
-                                targets,
-                                totalElementCount: allTargets.size,
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            const levelsDeleted = [];
-            let levelsTotal = 0;
-            await client.runOptimistic(async () => {
-                levelsDeleted.length = 0;
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                for (const elementId of elementIds) {
-                    if (!locateInLevels(snapshot, elementId))
-                        continue; // 既に削除済み(リトライ時など)
-                    levelsDeleted.push({
-                        elementId,
-                        path: formatPath(map.header.title, ancestorDetailsInLevels(snapshot, elementId)),
-                        subtreeCount: subtreeIdsInLevels(snapshot, elementId).length,
-                    });
-                }
-                const { writes, deletedIds } = buildLevelsDeleteWrites(levelsPath, snapshot, elementIds);
-                levelsTotal = deletedIds.size;
-                return writes;
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({ deleted: levelsDeleted, totalElementCount: levelsTotal }, null, 2),
-                    },
-                ],
-            };
-        }
         if (confirmed !== true) {
-            const existingDocs = await client.listDocuments(bodiesPath);
-            const existingBodies = existingDocs.map((d) => bodyFromFirestore(d.id, d.data, d.updateTime));
-            const byId = new Map(existingBodies.map((b) => [b.id, b]));
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
             const allTargets = new Set();
             const targets = [];
             for (const elementId of elementIds) {
-                if (!byId.has(elementId)) {
+                if (!locateInLevels(snapshot, elementId)) {
                     throw new Error(`elementId(${elementId})がこのマップに見つかりません。list_elementsで確認してください。`);
                 }
-                const subtree = collectSubtreeIds(existingBodies, elementId);
+                const subtree = subtreeIdsInLevels(snapshot, elementId);
                 for (const id of subtree)
                     allTargets.add(id);
                 targets.push({
                     elementId,
-                    path: formatPath(map.header.title, ancestorDetails(existingBodies, elementId)),
+                    path: formatPath(map.header.title, ancestorDetailsInLevels(snapshot, elementId)),
                     subtreeCount: subtree.length,
                 });
             }
@@ -122,31 +50,30 @@ export function registerDeleteElements(server) {
                 ],
             };
         }
-        const deletedPaths = [];
-        let totalDeleted = 0;
+        const levelsDeleted = [];
+        let levelsTotal = 0;
         await client.runOptimistic(async () => {
-            deletedPaths.length = 0;
-            totalDeleted = 0;
-            const currentDocs = await client.listDocuments(bodiesPath);
-            const currentBodies = currentDocs.map((d) => bodyFromFirestore(d.id, d.data, d.updateTime));
+            levelsDeleted.length = 0;
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
             for (const elementId of elementIds) {
-                if (!currentBodies.some((b) => b.id === elementId))
+                if (!locateInLevels(snapshot, elementId))
                     continue; // 既に削除済み(リトライ時など)
-                deletedPaths.push({
+                levelsDeleted.push({
                     elementId,
-                    path: formatPath(map.header.title, ancestorDetails(currentBodies, elementId)),
-                    subtreeCount: collectSubtreeIds(currentBodies, elementId).length,
+                    path: formatPath(map.header.title, ancestorDetailsInLevels(snapshot, elementId)),
+                    subtreeCount: subtreeIdsInLevels(snapshot, elementId).length,
                 });
             }
-            const { writes, deletedIds } = await buildDeleteElementWrites(client, bodiesPath, levelsPath, currentBodies, elementIds);
-            totalDeleted = deletedIds.size;
-            return writes;
+            const { writes, deletedIds } = buildLevelsDeleteWrites(levelsPath, snapshot, elementIds);
+            levelsTotal = deletedIds.size;
+            // リンクの要約(header の linkCounts)が変わるときだけ、同じコミットで書き直す
+            return withLinkSummary(headerPathOf(map), levelsPath, snapshot, writes);
         });
         return {
             content: [
                 {
                     type: "text",
-                    text: JSON.stringify({ deleted: deletedPaths, totalElementCount: totalDeleted }, null, 2),
+                    text: JSON.stringify({ deleted: levelsDeleted, totalElementCount: levelsTotal }, null, 2),
                 },
             ],
         };

package/dist/src/tools/editElement.js

@@ -1,65 +1,37 @@
 import { z } from "zod";
 import { getContext } from "../mcpContext.js";
-import { isLevelsOnly, readLevelsSnapshot } from "../domain/levelsMode.js";
-import { ancestorDetailsInLevels, buildLevelsPatchWrites } from "../domain/levelsOps.js";
-import { resolveMap, bodiesPathOf, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
-import { bodyFromFirestore, ancestorDetails } from "../domain/body.js";
-import { mergeWritesByPath } from "../firestore/restClient.js";
-import { assertLevelsRootExists, buildUpdateEntryWrites, levelsDocExists } from "../domain/levels.js";
+import { assertDetailLengths } from "../domain/detailLimit.js";
+import { ancestorDetailsInLevels, buildLevelsPatchWrites, readLevelsSnapshot } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
 export function registerEditElement(server) {
     server.tool("edit_element", "既存マップの要素1件の本文(detail)を書き換える。要素の追加はauto_structure_thought・" +
         "import_markdown_contextを、チェック状態の変更はupdate_task_statusを使うこと。", {
         mapId: z.string().describe("list_mapsで得たマップのID"),
         elementId: z.string().describe("list_elementsで得た要素のID"),
-        detail: z.string().min(1).describe("書き換え後の本文"),
+        detail: z.string().min(1).describe("書き換え後の本文(1要素5000文字まで)"),
     }, async ({ mapId, elementId, detail }) => {
+        assertDetailLengths([detail]);
         const { client, session } = getContext();
         const map = await resolveMap(client, session, mapId);
         assertCanEditMap(map, session);
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
-        if (await isLevelsOnly(client)) {
-            let levelsPathResult = null;
-            await client.runOptimistic(async () => {
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                const { writes, found } = buildLevelsPatchWrites(levelsPath, snapshot, [
-                    { elementId, patch: { detail } },
-                ]);
-                if (!found.has(elementId)) {
-                    throw new Error(`elementId(${elementId})がこのマップに見つかりません。list_elementsで確認してください。`);
-                }
-                levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, elementId));
-                return writes;
-            });
-            return {
-                content: [{ type: "text", text: JSON.stringify({ path: levelsPathResult }, null, 2) }],
-            };
-        }
-        assertLevelsRootExists(await levelsDocExists(client, levelsPath, "root"), map.header.title);
-        let path = null;
+        let levelsPathResult = null;
         await client.runOptimistic(async () => {
-            const bodyDoc = await client.getDocument(`${bodiesPath}/${elementId}`);
-            if (!bodyDoc) {
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
+            const { writes, found } = buildLevelsPatchWrites(levelsPath, snapshot, [
+                { elementId, patch: { detail } },
+            ]);
+            if (!found.has(elementId)) {
                 throw new Error(`elementId(${elementId})がこのマップに見つかりません。list_elementsで確認してください。`);
             }
-            const body = bodyFromFirestore(elementId, bodyDoc.data, bodyDoc.updateTime);
-            const existingDocs = await client.listDocuments(bodiesPath);
-            const existingBodies = existingDocs.map((d) => bodyFromFirestore(d.id, d.data, d.updateTime));
-            path = formatPath(map.header.title, ancestorDetails(existingBodies, elementId));
-            const writes = [
-                {
-                    path: `${bodiesPath}/${elementId}`,
-                    fields: { detail },
-                    requireUpdateTime: body.updateTime,
-                },
-            ];
-            const levelWrites = await buildUpdateEntryWrites(client, levelsPath, [
-                { parentId: body.parent, elementId, patch: { detail } },
-            ]);
-            return mergeWritesByPath([...writes, ...levelWrites]);
+            // snapshotは書き込み前なので、末尾(この要素自身)だけ書き換え後の本文にする。
+            const chain = ancestorDetailsInLevels(snapshot, elementId);
+            chain[chain.length - 1] = detail;
+            levelsPathResult = formatPath(map.header.title, chain);
+            return writes;
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ path }, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify({ path: levelsPathResult }, null, 2) }],
         };
     });
 }

package/dist/src/tools/importMarkdownContext.js

@@ -1,13 +1,9 @@
 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 { buildAppendWrites } from "../domain/appendForest.js";
+import { ancestorDetailsInLevels, buildLevelsAppendWrites, locateInLevels, readLevelsSnapshot } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
 import { parseMarkdownForImport } from "../domain/markdownParser.js";
-import { assertLevelsRootExists, buildAppendLevelWrites, levelsDocExists } from "../domain/levels.js";
+import { assertDetailLengths } from "../domain/detailLimit.js";
 export function registerImportMarkdownContext(server) {
     server.tool("import_markdown_context", "任意の深さのMarkdown(インデントで階層を表現したリスト、見出しは`#`)を組み立てて、" +
         "既存のマップに流し込む。見出しも1つの要素として取り込む。" +
@@ -15,7 +11,7 @@ export function registerImportMarkdownContext(server) {
         "チェック状態も反映されない(アプリ本体の挙動と同じ)。" +
         "対象は既存マップのみ(新規作成が必要ならcreate_mapを先に呼ぶ)。", {
         mapId: z.string().describe("list_mapsで得たマップのID"),
-        markdown: z.string().min(1).describe("取り込むMarkdownテキスト"),
+        markdown: z.string().min(1).describe("取り込むMarkdownテキスト(1要素5000文字まで。超える要素があれば何も書かない)。要素の1行目に「📅 2026-10-15」(期日)・「🛫 2026-10-12」(着手日)と書くと日付として取り込む。時刻付きは「📅 2026-10-15 09:00」(このPCの現地時刻)"),
         parentElementId: z
             .string()
             .nullable()
@@ -26,66 +22,28 @@ export function registerImportMarkdownContext(server) {
         const map = await resolveMap(client, session, mapId);
         assertCanEditMap(map, session);
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
         const targetParentId = parentElementId ?? null;
         const parsed = parseMarkdownForImport(markdown, { headingsAsNodes: true });
         if (parsed.nodes.length === 0) {
             throw new Error("Markdownからリスト項目・見出しが見つかりませんでした。");
         }
-        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, parsed.nodes, targetParentId, map.header.isTodo);
-            });
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            path: levelsPathResult,
-                            addedElementCount: parsed.nodes.length,
-                            checkboxIgnored: !map.header.isTodo && parsed.hasCheckbox,
-                        }, null, 2),
-                    },
-                ],
-            };
-        }
-        // 読み取り(bodies一覧・levels存在確認)から書き込みまでを楽観的
-        // ロックでまとめる。読み取り後に対象ドキュメントが他から変更される
-        // とコミットがFAILED_PRECONDITIONになり、読み取りからやり直す。
-        let createdIds = [];
-        let existingBodiesForPath = [];
+        assertDetailLengths(parsed.nodes.map((node) => node.detail));
+        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, parsed.nodes, 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, parsed.nodes, targetParentId, targetHasLevelsDoc, map.header.isTodo);
-            return mergeWritesByPath([...writes, ...levelWrites]);
+            levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, targetParentId));
+            return buildLevelsAppendWrites(levelsPath, snapshot, parsed.nodes, targetParentId, map.header.isTodo);
         });
-        const path = formatPath(map.header.title, ancestorDetails(existingBodiesForPath, targetParentId));
         return {
             content: [
                 {
                     type: "text",
                     text: JSON.stringify({
-                        path,
-                        addedElementCount: createdIds.length,
+                        path: levelsPathResult,
+                        addedElementCount: parsed.nodes.length,
                         checkboxIgnored: !map.header.isTodo && parsed.hasCheckbox,
                     }, null, 2),
                 },

package/dist/src/tools/listElements.js

@@ -1,14 +1,17 @@
 import { z } from "zod";
 import { getContext } from "../mcpContext.js";
 import { resolveMap, levelsPathOf } from "../domain/mapResolver.js";
-import { isLevelsOnly } from "../domain/levelsMode.js";
-import { assertLevelsInitialized, buildTreeFromLevels, readAllLevelDocs, } from "../domain/levels.js";
+import { elementTreeOf, readLevelsSnapshot } from "../domain/levelsOps.js";
+import { formatScheduleDate } from "../domain/scheduleText.js";
 // ElementNodeの`done`を`checked`という名前で公開する(仕様書の用語に合わせる)。
 function toChecked(nodes) {
     return nodes.map((n) => ({
         id: n.id,
         detail: n.detail,
         checked: n.done,
+        // 日付は付いているときだけ返す(docs/schedule.md §3 MCP)
+        ...(n.schedule?.due ? { due: formatScheduleDate(n.schedule.due) } : {}),
+        ...(n.schedule?.start ? { start: formatScheduleDate(n.schedule.start) } : {}),
         children: toChecked(n.children),
     }));
 }
@@ -38,21 +41,24 @@ class AiReadDeniedError extends Error {
     }
 }
 export function registerListElements(server) {
-    server.tool("list_elements", "指定したマップ内の全要素と親子関係、チェック状態(checked)を返す。" +
+    server.tool("list_elements", "指定したマップ内の全要素と親子関係、チェック状態(checked)、期日(due)・着手日(start)を返す。" +
+        "dueとstartは付いている要素にだけあり、終日なら\"YYYY-MM-DD\"、時刻付きなら" +
+        "\"YYYY-MM-DD HH:mm\"(このPCの現地時刻)。" +
         "checkedは各要素にFirestoreへ実際に保存されている生の値であり、" +
         "「祖先がチェック済みなら配下も完了とみなす」という加工は行っていない。" +
         "そう解釈したい場合は、返ってきたツリーを見てこちら(呼び出す側)で判断すること。" +
-        "マップの中身には秘匿情報が含まれ得るため、初めて読むマップでは呼び出し前に" +
-        "ユーザー本人の許可が必要。confirmed: trueを付けずに呼ぶと、このツールは" +
-        "実データを返す代わりに確認を促すメッセージだけを返すので、その指示に従って" +
-        "ユーザーに直接確認してからconfirmed: trueで呼び直すこと。" +
+        "呼ぶ前にユーザーへ確認しないこと。まずconfirmedを付けずに呼ぶ。" +
+        "アプリでAIからの読み取りを「常に許可」にしたマップは、そのまま実データを返す。" +
+        "それ以外のマップは、実データの代わりに確認を促すメッセージだけを返すので、" +
+        "そのときに限りユーザーに直接確認してからconfirmed: trueで呼び直すこと。" +
         "アプリ側での直接の編集はこのツールを呼ぶまで反映されないため、" +
         "ユーザーから進捗や状態を尋ねられたときは記憶に頼らず必ず呼び直すこと。", {
         mapId: z.string().describe("list_mapsで得たマップのID"),
         confirmed: z
             .boolean()
             .optional()
-            .describe("ユーザー本人に直接「中身を確認してよいか」と尋ね、同意を得てからtrueを付けて呼ぶこと。" +
+            .describe("最初は付けない。確認を促すメッセージが返ったときだけ、ユーザー本人に直接" +
+            "「中身を確認してよいか」と尋ね、同意を得てからtrueを付けて呼び直す。" +
             "確認前にtrueを付けてはならない。"),
     }, async ({ mapId, confirmed }) => {
         const { client, session } = getContext();
@@ -78,13 +84,8 @@ export function registerListElements(server) {
                 return { content: [{ type: "text", text: buildConfirmationRequestText(map.header.title) }] };
             }
         }
-        const levelsById = await readAllLevelDocs(client, levelsPathOf(map));
-        // 切替前はrootが無ければ未移行(bodiesに中身があり得る)なので止める。
-        // 切替後はアプリで開いてもrootが作られないので、空のマップとして返す。
-        if (!(await isLevelsOnly(client))) {
-            assertLevelsInitialized(levelsById, map.header.title);
-        }
-        const tree = buildTreeFromLevels(levelsById);
+        // levels/rootが無いマップは空のマップとして返す(アプリで開いてもrootは作られない)。
+        const tree = elementTreeOf(await readLevelsSnapshot(client, levelsPathOf(map)));
         return {
             content: [
                 {

package/dist/src/tools/moveElement.js

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { getContext } from "../mcpContext.js";
-import { isLevelsOnly, readLevelsSnapshot } from "../domain/levelsMode.js";
-import { ancestorDetailsInLevels, buildLevelsMoveWrites, locateInLevels } from "../domain/levelsOps.js";
-import { resolveMap, bodiesPathOf, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
-import { bodyFromFirestore, ancestorDetails } from "../domain/body.js";
-import { assertLevelsRootExists, levelsDocExists } from "../domain/levels.js";
-import { buildMoveElementWrites } from "../domain/moveElement.js";
+import { ancestorDetailsInLevels, buildLevelsMoveWrites, locateInLevels, readLevelsSnapshot, withLinkSummary, } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, headerPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
 export function registerMoveElement(server) {
     server.tool("move_element", "既存マップの要素1件(配下ごと)を、同じマップ内の別の場所へ移動する。" +
         "階層をまたいだ移動(昇格・降格)も、同じ階層内の並べ替えも、これ1つで行える。", {
@@ -24,62 +20,25 @@ export function registerMoveElement(server) {
         const map = await resolveMap(client, session, mapId);
         assertCanEditMap(map, session);
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
-        // 切替後はrootが無いマップを空のマップとして扱うので、この確認は切替前だけ。
-        const levelsOnly = await isLevelsOnly(client);
-        if (!levelsOnly) {
-            assertLevelsRootExists(await levelsDocExists(client, levelsPath, "root"), map.header.title);
-        }
         if (elementId === newParentElementId) {
             throw new Error("要素を自分自身の子にすることはできません。");
         }
         if (elementId === afterElementId) {
             throw new Error("afterElementIdにelementId自身は指定できません。");
         }
-        if (levelsOnly) {
-            let levelsPathResult = null;
-            await client.runOptimistic(async () => {
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                if (afterElementId !== null && !locateInLevels(snapshot, afterElementId)) {
-                    throw new Error(`afterElementId(${afterElementId})がこのマップに見つかりません。`);
-                }
-                const writes = buildLevelsMoveWrites(levelsPath, snapshot, elementId, newParentElementId, afterElementId);
-                levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, newParentElementId));
-                return writes;
-            });
-            return {
-                content: [{ type: "text", text: JSON.stringify({ path: levelsPathResult }, null, 2) }],
-            };
-        }
-        let path = null;
+        let levelsPathResult = null;
         await client.runOptimistic(async () => {
-            const existingDocs = await client.listDocuments(bodiesPath);
-            const existingBodies = existingDocs.map((d) => bodyFromFirestore(d.id, d.data, d.updateTime));
-            const byId = new Map(existingBodies.map((b) => [b.id, b]));
-            const body = byId.get(elementId);
-            if (!body) {
-                throw new Error(`elementId(${elementId})がこのマップに見つかりません。list_elementsで確認してください。`);
-            }
-            if (newParentElementId !== null && !byId.has(newParentElementId)) {
-                throw new Error(`newParentElementId(${newParentElementId})がこのマップに見つかりません。`);
-            }
-            if (afterElementId !== null && !byId.has(afterElementId)) {
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
+            if (afterElementId !== null && !locateInLevels(snapshot, afterElementId)) {
                 throw new Error(`afterElementId(${afterElementId})がこのマップに見つかりません。`);
             }
-            // 移動先が自分自身の配下(子孫)だと、木構造が壊れる(循環になる)。
-            for (let cur = newParentElementId; cur !== null; cur = byId.get(cur)?.parent ?? null) {
-                if (cur === elementId) {
-                    throw new Error("要素を自分自身の配下(子孫)の中へ移動することはできません。");
-                }
-            }
-            const writes = await buildMoveElementWrites(client, bodiesPath, levelsPath, existingBodies, elementId, newParentElementId, afterElementId);
-            path = formatPath(map.header.title, newParentElementId === null
-                ? []
-                : ancestorDetails(existingBodies, newParentElementId));
-            return writes;
+            const writes = buildLevelsMoveWrites(levelsPath, snapshot, elementId, newParentElementId, afterElementId);
+            levelsPathResult = formatPath(map.header.title, ancestorDetailsInLevels(snapshot, newParentElementId));
+            // リンクの要約(header の linkCounts)が変わるときだけ、同じコミットで書き直す
+            return withLinkSummary(headerPathOf(map), levelsPath, snapshot, writes);
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ path }, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify({ path: levelsPathResult }, null, 2) }],
         };
     });
 }

package/dist/src/tools/setSchedule.js

@@ -0,0 +1,54 @@
+import { z } from "zod";
+import { getContext } from "../mcpContext.js";
+import { ancestorDetailsInLevels, buildLevelsScheduleWrites, readLevelsSnapshot, } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, formatPath, assertCanEditMap } from "../domain/mapResolver.js";
+import { parseScheduleDate } from "../domain/scheduleText.js";
+const dateSchema = z
+    .string()
+    .nullable()
+    .optional()
+    .describe("終日なら\"YYYY-MM-DD\"、時刻付きなら\"YYYY-MM-DD HH:mm\"(このPCの現地時刻)。" +
+    "nullで外す。省略するとその日付には触れない");
+export function registerSetSchedule(server) {
+    server.tool("set_schedule", "要素の期日(due)と着手日(start)を付ける・外す。1件でも複数件でもよい。" +
+        "親の日付を子に引き継ぐことはしない(親と子の日付は独立している)。" +
+        "今の日付はlist_elementsで確認できる。", {
+        mapId: z.string().describe("list_mapsで得たマップのID"),
+        updates: z
+            .array(z.object({
+            elementId: z.string().describe("list_elementsで得た要素のID"),
+            due: dateSchema,
+            start: dateSchema,
+        }))
+            .min(1),
+    }, async ({ mapId, updates }) => {
+        // 日付の書き方の誤りは、何も読まないうちに返す
+        const parsed = updates.map((u) => ({
+            elementId: u.elementId,
+            due: u.due == null ? u.due : parseScheduleDate(u.due),
+            start: u.start == null ? u.start : parseScheduleDate(u.start),
+        }));
+        const { client, session } = getContext();
+        const map = await resolveMap(client, session, mapId);
+        assertCanEditMap(map, session);
+        const levelsPath = levelsPathOf(map);
+        let results = [];
+        await client.runOptimistic(async () => {
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
+            const { writes, found } = buildLevelsScheduleWrites(levelsPath, snapshot, parsed);
+            results = updates.map((u) => ({
+                elementId: u.elementId,
+                path: found.has(u.elementId)
+                    ? formatPath(map.header.title, ancestorDetailsInLevels(snapshot, u.elementId))
+                    : null,
+                ...(u.due !== undefined ? { due: u.due } : {}),
+                ...(u.start !== undefined ? { start: u.start } : {}),
+                found: found.has(u.elementId),
+            }));
+            return writes;
+        });
+        return {
+            content: [{ type: "text", text: JSON.stringify({ results }, null, 2) }],
+        };
+    });
+}

package/dist/src/tools/updateTaskStatus.js

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { getContext } from "../mcpContext.js";
-import { isLevelsOnly, readLevelsSnapshot } from "../domain/levelsMode.js";
-import { ancestorDetailsInLevels, buildLevelsPatchWrites } from "../domain/levelsOps.js";
-import { resolveMap, bodiesPathOf, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
-import { bodyFromFirestore, ancestorDetails } from "../domain/body.js";
-import { mergeWritesByPath } from "../firestore/restClient.js";
-import { assertLevelsRootExists, buildUpdateEntryWrites, levelsDocExists } from "../domain/levels.js";
+import { ancestorDetailsInLevels, buildLevelsPatchWrites, readLevelsSnapshot } from "../domain/levelsOps.js";
+import { resolveMap, levelsPathOf, formatPath, assertCanEditMap, } from "../domain/mapResolver.js";
 export function registerUpdateTaskStatus(server) {
     server.tool("update_task_status", "TODOマップの要素のチェック状態を書き換える。1件でも複数件でもよい。" +
         "「親をチェックすると配下も完了扱いになる」というアプリ内の表示上の挙動は" +
@@ -26,62 +22,22 @@ export function registerUpdateTaskStatus(server) {
             throw new Error(`「${map.header.title}」はTODOマップではないため、チェック状態を持ちません。`);
         }
         const levelsPath = levelsPathOf(map);
-        const bodiesPath = bodiesPathOf(map);
-        if (await isLevelsOnly(client)) {
-            let levelsResults = [];
-            await client.runOptimistic(async () => {
-                const snapshot = await readLevelsSnapshot(client, levelsPath);
-                const { writes, found } = buildLevelsPatchWrites(levelsPath, snapshot, updates.map((u) => ({ elementId: u.elementId, patch: { done: u.checked } })));
-                levelsResults = updates.map((u) => ({
-                    elementId: u.elementId,
-                    path: found.has(u.elementId)
-                        ? formatPath(map.header.title, ancestorDetailsInLevels(snapshot, u.elementId))
-                        : null,
-                    checked: u.checked,
-                    found: found.has(u.elementId),
-                }));
-                return writes;
-            });
-            return {
-                content: [{ type: "text", text: JSON.stringify({ results: levelsResults }, null, 2) }],
-            };
-        }
-        // 読み取り(bodies一覧・levelsの該当ドキュメント)から書き込みまでを
-        // 楽観的ロックでまとめる。読み取り後に他の操作が同じlevelsドキュメントを
-        // 書き換えていた場合はコミットがFAILED_PRECONDITIONになり、
-        // 読み取りからやり直す(runOptimisticが自動でリトライする)。
-        let results = [];
+        let levelsResults = [];
         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));
-            const byId = new Map(existingBodies.map((b) => [b.id, b]));
-            const writes = [];
-            const levelUpdates = [];
-            results = [];
-            for (const update of updates) {
-                const body = byId.get(update.elementId);
-                if (!body) {
-                    results.push({ elementId: update.elementId, path: null, checked: update.checked, found: false });
-                    continue;
-                }
-                writes.push({
-                    path: `${bodiesPath}/${update.elementId}`,
-                    fields: { done: update.checked },
-                });
-                levelUpdates.push({
-                    parentId: body.parent,
-                    elementId: update.elementId,
-                    patch: { done: update.checked },
-                });
-                const path = formatPath(map.header.title, ancestorDetails(existingBodies, update.elementId));
-                results.push({ elementId: update.elementId, path, checked: update.checked, found: true });
-            }
-            const levelWrites = await buildUpdateEntryWrites(client, levelsPath, levelUpdates);
-            return mergeWritesByPath([...writes, ...levelWrites]);
+            const snapshot = await readLevelsSnapshot(client, levelsPath);
+            const { writes, found } = buildLevelsPatchWrites(levelsPath, snapshot, updates.map((u) => ({ elementId: u.elementId, patch: { done: u.checked } })));
+            levelsResults = updates.map((u) => ({
+                elementId: u.elementId,
+                path: found.has(u.elementId)
+                    ? formatPath(map.header.title, ancestorDetailsInLevels(snapshot, u.elementId))
+                    : null,
+                checked: u.checked,
+                found: found.has(u.elementId),
+            }));
+            return writes;
         });
         return {
-            content: [{ type: "text", text: JSON.stringify({ results }, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify({ results: levelsResults }, null, 2) }],
         };
     });
 }