@tomingtoming/kioq 0.7.0

package/dist/src/noteStore.js

@@ -0,0 +1,3270 @@
+import path from "node:path";
+const EXPLORATION_TAG_STOPWORDS = new Set([
+    "flow",
+    "stock",
+    "general",
+    "index",
+    "moc",
+    "memory",
+    "note",
+    "notes",
+]);
+const MARKDOWN_EXTENSION = ".md";
+const MAX_SIGNAL_ITEMS = 20;
+const SEARCH_TERM_LIMIT = 48;
+const SEARCH_NGRAM_LIMIT = 64;
+const MEMORY_CONTRACT_VERSION = "1.12.0";
+const MEMORY_CONTRACT_REQUIRED_FRONTMATTER = ["type", "tags", "created", "updated", "permalink"];
+const MEMORY_CONTRACT_FLOW_REQUIRED_FRONTMATTER = ["memory_kind", "flow_state", "question", "next_action", "parent_stock"];
+const MEMORY_CONTRACT_REQUIREMENTS = {
+    minResolvedLinks: 2,
+    minBacklinks: 1,
+    minParentLinks: 1,
+    minRelatedLinks: 1,
+    maxUnresolvedLinks: 0,
+    minTags: 1,
+};
+const MEMORY_CONTRACT_FLOW_REQUIREMENTS = {
+    minResolvedLinks: 2,
+    minBacklinks: 0,
+    minParentLinks: 1,
+    minRelatedLinks: 1,
+    maxUnresolvedLinks: 0,
+    minTags: 1,
+};
+const MEMORY_CONTRACT_PARENT_MARKERS = ["親", "parent", "上位", "moc", "index", "インデックス"];
+const PARENT_LINE_PATTERN = /(?:\bparent\b|親|上位|moc|index|インデックス)/i;
+const INDEX_TAG_MARKERS = ["index", "moc", "索引"];
+const INDEX_TITLE_PATTERN = /(?:\bindex\b|\bmoc\b|インデックス|索引)/i;
+const INDEX_SECTION_HEADINGS = ["目的", "テーマ別入口", "まず何を読むか"];
+const INDEX_NAVIGATION_POLICY = {
+    excludedMemoryKinds: ["flow"],
+    signals: [
+        { code: "index_tag", weight: 70, description: "tags に index / moc / 索引 を含む" },
+        { code: "title_marker", weight: 45, description: "title に index marker を含む" },
+        { code: "permalink_marker", weight: 35, description: "permalink に index marker を含む" },
+        { code: "path_marker", weight: 25, description: "relative path に index marker を含む" },
+        { code: "section:*", weight: 20, description: "index section を 1 件含むごとに加点する" },
+        { code: "multi_index_sections", weight: 20, description: "index section が 2 件以上ある" },
+        { code: "link_hub", weight: 10, description: "WikiLink が 4 件以上ある" },
+    ],
+    thresholds: {
+        scoreAtLeast: 70,
+        indexSectionsAtLeast: 2,
+    },
+    configurableVia: {
+        env: ["KIOQ_INDEX_SCORE_THRESHOLD", "KIOQ_INDEX_SECTION_THRESHOLD"],
+        cli: ["--index-score-threshold", "--index-section-threshold"],
+    },
+    rules: [
+        "flow は title や section が index っぽくても index_like にしない",
+        "index_like_reasons には実際に発火した signal code だけを返す",
+        "この policy は導線用ヒューリスティクスであり、厳密な note type 判定ではない",
+    ],
+};
+const FLOW_STATES = new Set(["capture", "active", "blocked", "done", "promoted", "dropped"]);
+const STALE_FLOW_STATES = new Set(["capture", "active", "blocked"]);
+const SINGLE_USE_TAG_EXACT_IGNORES = new Set(["kioq", "flow", "stock", "general", "index", "moc"]);
+const SINGLE_USE_TAG_PATTERN_IGNORES = [/^batch-\d+$/];
+const TITLE_BODY_EXACT_IGNORES = new Set(["抽出", "原則", "体験", "メモ", "体験メモ", "インデックス", "仕様化", "シグナル", "レビュー", "監査", "ガイド", "ノート", "再訪", "flow", "stock"]);
+const CLARITY_SUMMARY_HEADINGS = new Set(["summary", "要約", "結論", "目的", "概要", "tl dr", "tl;dr"]);
+const CLARITY_LOW_LIST_RATIO_THRESHOLD = 0.15;
+const CLARITY_MIN_CONTENT_LINES_FOR_LIST_CHECK = 8;
+const CLARITY_LONG_SENTENCE_THRESHOLD = 120;
+const CLARITY_LONG_SENTENCE_ATTENTION_COUNT = 2;
+const TECHNICAL_DEBT_POLICY = {
+    signals: [
+        "unresolved_wikilinks_delta",
+        "stale_flow_count",
+        "cleanup_ratio",
+        "cleanup_ready_count",
+        "attention_note_count",
+        "dependency_direction_violation_count",
+        "single_use_tag_candidate_count",
+        "title_body_mismatch_candidate_count",
+    ],
+    staleFlowAgeBuckets: {
+        nearThreshold: "threshold..threshold+6 days",
+        aging: "threshold+7..threshold+22 days",
+        longStale: "threshold+23 days or more",
+    },
+    cleanupRatioDefinition: "今すぐ cleanup 不要なノート数 / 全ノート数",
+    cleanupReadyCountDefinition: "今すぐ cleanup 不要なノート数",
+    attentionNoteCountDefinition: "何らかの cleanup が必要なノート数",
+    dependencyDirectionViolationCountDefinition: "stock ノートが parent として flow を指している件数",
+    singleUseTagCandidateCountDefinition: "非 flow ノートで単発 tag を 2 件以上持つノート候補数（運用タグは除外）",
+    titleBodyMismatchCandidateCountDefinition: "非 flow ノートで title の中核語が本文見出し/要約に現れないノート候補数",
+    unresolvedWikilinksDeltaStatus: "requires_history",
+    configurableVia: {
+        env: ["KIOQ_STALE_FLOW_DAYS"],
+        cli: ["--stale-flow-days"],
+    },
+};
+const RESPONSE_MODE_POLICY = {
+    supportedTools: {
+        read: ["recent_notes", "search_notes", "read_note", "resolve_links", "list_backlinks", "context_bundle"],
+        audit: ["memory_contract", "lint_structure"],
+    },
+    modes: {
+        minimal: "summary と件数中心。cold start や高速周回向け",
+        standard: "既定。通常判断に必要な policy / breakdown を返す",
+        verbose: "詳細診断や sample template 本文まで返す",
+    },
+    rules: [
+        "まず minimal か standard で始め、必要になったときだけ verbose へ上げる",
+        "recommended_response_mode が返ったら、それを優先して detail level を上げる",
+        "sample template 本文や issue suggestion 全文が必要なときだけ verbose を使う",
+    ],
+};
+const FLOW_DEFAULT_DIRECTORY = "Flow";
+const STOCK_DEFAULT_DIRECTORY = "Stock";
+const RESERVED_FRONTMATTER_KEYS = new Set(["title", "type", "permalink", "tags", "created", "updated"]);
+const FLOW_QUESTION_HEADING_PATTERN = /^##\s+Question\s*$/im;
+const FLOW_NEXT_ACTION_HEADING_PATTERN = /^##\s+Next Action\s*$/im;
+const FLOW_PARENT_LINE_PATTERN = /^-\s*(?:親|parent):\s*\[\[/im;
+const TOKEN_SPLIT_PATTERN = /[\s\p{P}\p{S}]+/u;
+const HAS_TOKEN_CHAR_PATTERN = /[\p{L}\p{N}]/u;
+const CJK_TOKEN_PATTERN = /^[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}]+$/u;
+const JA_WORD_SEGMENTER = (() => {
+    try {
+        return new Intl.Segmenter("ja", { granularity: "word" });
+    }
+    catch {
+        return undefined;
+    }
+})();
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}
+function formatLocalDate(date) {
+    return `${date.getFullYear()}-${pad2(date.getMonth() + 1)}-${pad2(date.getDate())}`;
+}
+function formatLocalTimestamp(date) {
+    const offsetMinutes = -date.getTimezoneOffset();
+    const sign = offsetMinutes >= 0 ? "+" : "-";
+    const absoluteOffset = Math.abs(offsetMinutes);
+    const offsetHours = Math.floor(absoluteOffset / 60);
+    const offsetRemainderMinutes = absoluteOffset % 60;
+    return `${formatLocalDate(date)}T${pad2(date.getHours())}:${pad2(date.getMinutes())}:${pad2(date.getSeconds())}${sign}${pad2(offsetHours)}:${pad2(offsetRemainderMinutes)}`;
+}
+function nowDate() {
+    return formatLocalDate(new Date());
+}
+function nowTimestamp() {
+    return formatLocalTimestamp(new Date());
+}
+function parseDateOnly(value) {
+    const trimmed = value?.trim();
+    if (!trimmed || !/^\d{4}-\d{2}-\d{2}$/.test(trimmed)) {
+        return undefined;
+    }
+    const timestamp = Date.parse(`${trimmed}T00:00:00Z`);
+    return Number.isFinite(timestamp) ? timestamp : undefined;
+}
+function daysBetween(startDate, endDate) {
+    const start = parseDateOnly(startDate);
+    const end = parseDateOnly(endDate);
+    if (start === undefined || end === undefined) {
+        return undefined;
+    }
+    return Math.floor((end - start) / 86_400_000);
+}
+function stripQuotes(value) {
+    if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+        return value.slice(1, -1);
+    }
+    return value;
+}
+function emptyStaleFlowAgeBuckets() {
+    return {
+        nearThreshold: 0,
+        aging: 0,
+        longStale: 0,
+    };
+}
+function sanitizeRelativePath(value) {
+    if (!value) {
+        return "";
+    }
+    const normalized = value
+        .replace(/\\/g, "/")
+        .split("/")
+        .map((part) => part.trim())
+        .filter((part) => part.length > 0)
+        .join("/");
+    if (normalized.length === 0) {
+        return "";
+    }
+    const segments = normalized.split("/");
+    if (segments.some((segment) => segment === "." || segment === "..")) {
+        throw new Error(`invalid relative path: ${value}`);
+    }
+    return segments.join("/");
+}
+function sanitizeFileBase(title) {
+    const trimmed = title.trim();
+    const replaced = trimmed
+        .replace(/[\\/:*?"<>|]/g, "-")
+        .replace(/\s+/g, " ")
+        .replace(/^\.+/, "")
+        .replace(/\.+$/, "")
+        .trim();
+    if (replaced.length === 0) {
+        return "untitled";
+    }
+    return replaced;
+}
+function inferTitleFromIdentifier(identifier) {
+    const trimmed = identifier.trim();
+    if (trimmed.length === 0) {
+        return "untitled";
+    }
+    const normalized = trimmed.replace(/\\/g, "/");
+    const last = normalized.split("/").filter((part) => part.length > 0).pop() ?? normalized;
+    const withoutExtension = last.replace(/\.md$/i, "").trim();
+    return withoutExtension.length > 0 ? withoutExtension : "untitled";
+}
+function isInsideDirectory(baseDir, targetPath) {
+    const normalizedBase = path.resolve(baseDir);
+    const normalizedTarget = path.resolve(targetPath);
+    return normalizedTarget === normalizedBase || normalizedTarget.startsWith(`${normalizedBase}${path.sep}`);
+}
+function parseFrontmatterBlock(block) {
+    const result = {};
+    const lines = block.split(/\r?\n/);
+    let currentArrayKey;
+    for (const line of lines) {
+        const listMatch = line.match(/^\s*-\s*(.+)$/);
+        if (listMatch && currentArrayKey) {
+            const current = result[currentArrayKey];
+            if (Array.isArray(current)) {
+                current.push(stripQuotes(listMatch[1].trim()));
+            }
+            continue;
+        }
+        currentArrayKey = undefined;
+        const keyValueMatch = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!keyValueMatch) {
+            continue;
+        }
+        const key = keyValueMatch[1];
+        const rawValue = keyValueMatch[2].trim();
+        if (rawValue.length === 0) {
+            result[key] = [];
+            currentArrayKey = key;
+            continue;
+        }
+        if (rawValue.startsWith("[") && rawValue.endsWith("]")) {
+            const inner = rawValue.slice(1, -1).trim();
+            result[key] = inner.length === 0
+                ? []
+                : inner.split(",").map((item) => stripQuotes(item.trim())).filter((item) => item.length > 0);
+            continue;
+        }
+        result[key] = stripQuotes(rawValue);
+    }
+    return result;
+}
+function splitFrontmatter(raw) {
+    if (!raw.startsWith("---\n")) {
+        return { frontmatter: {}, body: raw };
+    }
+    const separatorIndex = raw.indexOf("\n---\n", 4);
+    if (separatorIndex < 0) {
+        return { frontmatter: {}, body: raw };
+    }
+    const block = raw.slice(4, separatorIndex);
+    const body = raw.slice(separatorIndex + 5);
+    return {
+        frontmatter: parseFrontmatterBlock(block),
+        body,
+    };
+}
+function formatFrontmatterValue(value) {
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            return "[]";
+        }
+        return `\n${value.map((item) => `- ${JSON.stringify(item)}`).join("\n")}`;
+    }
+    if (/^[A-Za-z0-9_./:-]+$/.test(value)) {
+        return value;
+    }
+    return JSON.stringify(value);
+}
+function buildFrontmatter(frontmatter) {
+    const preferredOrder = [
+        "title",
+        "type",
+        "memory_kind",
+        "flow_state",
+        "permalink",
+        "parent_stock",
+        "tags",
+        "created",
+        "updated",
+    ];
+    const orderedKeys = [
+        ...preferredOrder.filter((key) => key in frontmatter),
+        ...Object.keys(frontmatter).filter((key) => !preferredOrder.includes(key)),
+    ];
+    const lines = orderedKeys.map((key) => `${key}: ${formatFrontmatterValue(frontmatter[key])}`);
+    return `---\n${lines.join("\n")}\n---`;
+}
+function ensureTrailingNewline(text) {
+    return text.endsWith("\n") ? text : `${text}\n`;
+}
+function normalizeContent(text) {
+    return text.replace(/\r\n/g, "\n");
+}
+function normalizeLookup(value) {
+    return value.toLowerCase().replace(/[\s._/-]+/g, "");
+}
+function katakanaToHiragana(value) {
+    return Array.from(value)
+        .map((char) => {
+        const code = char.charCodeAt(0);
+        if (code >= 0x30A1 && code <= 0x30F6) {
+            return String.fromCharCode(code - 0x60);
+        }
+        return char;
+    })
+        .join("");
+}
+function normalizeForSearch(value) {
+    return katakanaToHiragana(value.normalize("NFKC"))
+        .toLowerCase()
+        .replace(/\s+/g, " ")
+        .trim();
+}
+function compactSearchText(value) {
+    return value.replace(/\s+/g, "");
+}
+function stringLength(value) {
+    return Array.from(value).length;
+}
+function isCjkToken(value) {
+    return value.length > 0 && CJK_TOKEN_PATTERN.test(value);
+}
+function cjkNgrams(value, minLength, maxLength, limit) {
+    const chars = Array.from(value);
+    if (chars.length < minLength) {
+        return [];
+    }
+    const grams = [];
+    for (let size = minLength; size <= maxLength; size += 1) {
+        if (size > chars.length) {
+            continue;
+        }
+        for (let index = 0; index <= chars.length - size; index += 1) {
+            grams.push(chars.slice(index, index + size).join(""));
+            if (grams.length >= limit) {
+                return grams;
+            }
+        }
+    }
+    return grams;
+}
+function searchTerms(query) {
+    const normalized = normalizeForSearch(query);
+    if (normalized.length === 0) {
+        return [];
+    }
+    const terms = [];
+    const seen = new Set();
+    const pushTerm = (term) => {
+        const cleaned = term.trim();
+        if (cleaned.length === 0) {
+            return;
+        }
+        if (!HAS_TOKEN_CHAR_PATTERN.test(cleaned)) {
+            return;
+        }
+        if (seen.has(cleaned)) {
+            return;
+        }
+        seen.add(cleaned);
+        terms.push(cleaned);
+    };
+    pushTerm(normalized);
+    normalized
+        .split(TOKEN_SPLIT_PATTERN)
+        .filter((token) => token.length > 0)
+        .forEach(pushTerm);
+    if (JA_WORD_SEGMENTER) {
+        for (const piece of JA_WORD_SEGMENTER.segment(normalized)) {
+            const segment = piece.segment.trim();
+            if (segment.length === 0) {
+                continue;
+            }
+            const wordLike = "isWordLike" in piece ? Boolean(piece.isWordLike) : true;
+            if (!wordLike) {
+                continue;
+            }
+            pushTerm(segment);
+        }
+    }
+    const hasMultiCharTerm = terms.some((term) => stringLength(term) >= 2);
+    const filteredTerms = hasMultiCharTerm ? terms.filter((term) => stringLength(term) >= 2) : terms;
+    const ngrams = [];
+    const ngramSeen = new Set();
+    for (const term of filteredTerms) {
+        if (!isCjkToken(term) || stringLength(term) < 3) {
+            continue;
+        }
+        for (const gram of cjkNgrams(term, 2, 3, SEARCH_NGRAM_LIMIT)) {
+            if (ngramSeen.has(gram)) {
+                continue;
+            }
+            if (seen.has(gram)) {
+                continue;
+            }
+            ngramSeen.add(gram);
+            ngrams.push(gram);
+            if (ngrams.length >= SEARCH_NGRAM_LIMIT) {
+                break;
+            }
+        }
+        if (ngrams.length >= SEARCH_NGRAM_LIMIT) {
+            break;
+        }
+    }
+    return [...filteredTerms, ...ngrams].slice(0, SEARCH_TERM_LIMIT);
+}
+function safeString(value) {
+    return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
+}
+function safeStringArray(value) {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function normalizeFrontmatterPatch(input) {
+    if (!input) {
+        return {};
+    }
+    const normalized = {};
+    for (const [key, value] of Object.entries(input)) {
+        const trimmedKey = key.trim();
+        if (!trimmedKey) {
+            continue;
+        }
+        if (Array.isArray(value)) {
+            const next = value.map((item) => item.trim()).filter((item) => item.length > 0);
+            normalized[trimmedKey] = next;
+            continue;
+        }
+        const next = value.trim();
+        if (next.length === 0) {
+            continue;
+        }
+        normalized[trimmedKey] = next;
+    }
+    return normalized;
+}
+function normalizeWikiTargetInput(value) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return "";
+    }
+    let inner = trimmed;
+    if (inner.startsWith("[[") && inner.endsWith("]]")) {
+        inner = inner.slice(2, -2).trim();
+    }
+    const pipeIndex = inner.indexOf("|");
+    if (pipeIndex >= 0) {
+        inner = inner.slice(0, pipeIndex).trim();
+    }
+    return splitWikiTarget(inner).base;
+}
+function uniqueStrings(values) {
+    return Array.from(new Set(values));
+}
+function intersectCount(left, right) {
+    let count = 0;
+    for (const value of left) {
+        if (right.has(value)) {
+            count += 1;
+        }
+    }
+    return count;
+}
+function extractSectionBody(markdown, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const pattern = new RegExp(`^##\\s+${escaped}\\s*$`, "im");
+    const startMatch = pattern.exec(markdown);
+    if (!startMatch) {
+        return "";
+    }
+    const afterHeading = markdown.slice(startMatch.index + startMatch[0].length).replace(/^\n+/, "");
+    const nextHeadingMatch = /^##\s+/m.exec(afterHeading);
+    const section = nextHeadingMatch ? afterHeading.slice(0, nextHeadingMatch.index) : afterHeading;
+    return section.trim();
+}
+function excerptBody(markdown, maxLines, maxChars) {
+    const lines = normalizeContent(markdown)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !line.startsWith("#"))
+        .filter((line) => !line.startsWith("- 親:"))
+        .filter((line) => !line.startsWith("- 関連:"));
+    const picked = [];
+    let total = 0;
+    for (const line of lines) {
+        const nextLength = total + line.length + (picked.length > 0 ? 1 : 0);
+        if (picked.length >= maxLines || nextLength > maxChars) {
+            break;
+        }
+        picked.push(line);
+        total = nextLength;
+    }
+    return picked.join("\n").trim();
+}
+function markdownHeadings(markdown) {
+    const headings = [];
+    const pattern = /^##+\s+(.+?)\s*$/gm;
+    let match;
+    while ((match = pattern.exec(normalizeContent(markdown))) !== null) {
+        const heading = match[1]?.trim();
+        if (heading) {
+            headings.push(heading);
+        }
+    }
+    return headings;
+}
+function clarityContentLines(markdown) {
+    return normalizeContent(markdown)
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0)
+        .filter((line) => !line.startsWith("#"))
+        .filter((line) => !line.startsWith("- 親:"))
+        .filter((line) => !line.startsWith("- 関連:"));
+}
+function summaryHeadingPresent(markdown) {
+    return markdownHeadings(markdown).some((heading) => {
+        const normalized = normalizeForSearch(heading).replace(/\s+/g, " ").trim();
+        return CLARITY_SUMMARY_HEADINGS.has(normalized);
+    });
+}
+function listRatioForMarkdown(markdown) {
+    const lines = clarityContentLines(markdown);
+    if (lines.length === 0) {
+        return 0;
+    }
+    const listCount = lines.filter((line) => /^[-*]\s+/.test(line) || /^\d+\.\s+/.test(line)).length;
+    return Number((listCount / lines.length).toFixed(3));
+}
+function longSentenceCountForMarkdown(markdown) {
+    const text = clarityContentLines(markdown)
+        .filter((line) => !/^[-*]\s+/.test(line))
+        .filter((line) => !/^\d+\.\s+/.test(line))
+        .join(" ")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (!text) {
+        return 0;
+    }
+    return text
+        .split(/[。！？.!?]+/u)
+        .map((sentence) => sentence.trim())
+        .filter((sentence) => sentence.length >= CLARITY_LONG_SENTENCE_THRESHOLD)
+        .length;
+}
+function titleBodySemanticTerms(value) {
+    const normalized = normalizeForSearch(value)
+        .replace(/\b\d{4}-\d{2}-\d{2}\b/g, " ")
+        .replace(/[_/.-]+/g, " ")
+        .trim();
+    if (!normalized) {
+        return [];
+    }
+    const rawTerms = [];
+    const pushTerm = (term) => {
+        const cleaned = term.trim();
+        if (!cleaned || !HAS_TOKEN_CHAR_PATTERN.test(cleaned)) {
+            return;
+        }
+        if (/^\d+$/.test(cleaned)) {
+            return;
+        }
+        if (TITLE_BODY_EXACT_IGNORES.has(cleaned)) {
+            return;
+        }
+        const length = stringLength(cleaned);
+        if (isCjkToken(cleaned) ? length < 2 : length < 2) {
+            return;
+        }
+        rawTerms.push(cleaned);
+    };
+    if (JA_WORD_SEGMENTER) {
+        for (const piece of JA_WORD_SEGMENTER.segment(normalized)) {
+            const segment = piece.segment.trim();
+            const wordLike = "isWordLike" in piece ? Boolean(piece.isWordLike) : true;
+            if (!wordLike) {
+                continue;
+            }
+            pushTerm(segment);
+        }
+    }
+    else {
+        normalized
+            .split(TOKEN_SPLIT_PATTERN)
+            .filter((token) => token.length > 0)
+            .forEach(pushTerm);
+    }
+    return uniqueStrings(rawTerms);
+}
+function countOccurrences(text, query) {
+    if (!query || !text) {
+        return 0;
+    }
+    let count = 0;
+    let index = 0;
+    while (true) {
+        const foundIndex = text.indexOf(query, index);
+        if (foundIndex < 0) {
+            return count;
+        }
+        count += 1;
+        index = foundIndex + query.length;
+    }
+}
+function identifierMatchScore(key, query) {
+    const keyLower = key.toLowerCase();
+    const queryLower = query.toLowerCase();
+    if (!keyLower || !queryLower) {
+        return 0;
+    }
+    if (keyLower === queryLower) {
+        return 1000;
+    }
+    const keyNormalized = normalizeLookup(keyLower);
+    const queryNormalized = normalizeLookup(queryLower);
+    if (keyNormalized.length > 0 && keyNormalized === queryNormalized) {
+        return 900;
+    }
+    if (keyLower.includes(queryLower)) {
+        return Math.max(400, 700 - Math.max(0, keyLower.length - queryLower.length));
+    }
+    if (queryLower.includes(keyLower) && keyLower.length >= 4) {
+        return Math.max(250, 420 - Math.max(0, queryLower.length - keyLower.length));
+    }
+    if (queryNormalized.length > 0 && keyNormalized.includes(queryNormalized)) {
+        return Math.max(220, 520 - Math.max(0, keyNormalized.length - queryNormalized.length));
+    }
+    if (keyNormalized.length >= 4 && queryNormalized.includes(keyNormalized)) {
+        return Math.max(140, 320 - Math.max(0, queryNormalized.length - keyNormalized.length));
+    }
+    return 0;
+}
+function normalizeHintKey(value) {
+    return normalizeLookup(normalizeForSearch(value));
+}
+function levenshteinDistance(left, right, maxDistance) {
+    const leftChars = Array.from(left);
+    const rightChars = Array.from(right);
+    if (Math.abs(leftChars.length - rightChars.length) > maxDistance) {
+        return undefined;
+    }
+    let previous = Array.from({ length: rightChars.length + 1 }, (_, index) => index);
+    let current = new Array(rightChars.length + 1).fill(0);
+    for (let i = 1; i <= leftChars.length; i += 1) {
+        current[0] = i;
+        let rowMin = current[0];
+        for (let j = 1; j <= rightChars.length; j += 1) {
+            const cost = leftChars[i - 1] === rightChars[j - 1] ? 0 : 1;
+            const value = Math.min(previous[j] + 1, current[j - 1] + 1, previous[j - 1] + cost);
+            current[j] = value;
+            rowMin = Math.min(rowMin, value);
+        }
+        if (rowMin > maxDistance) {
+            return undefined;
+        }
+        [previous, current] = [current, previous];
+    }
+    const distance = previous[rightChars.length];
+    return distance <= maxDistance ? distance : undefined;
+}
+function fuzzyIdentifierScore(key, query) {
+    const keyNormalized = normalizeHintKey(key);
+    const queryNormalized = normalizeHintKey(query);
+    if (keyNormalized.length === 0 || queryNormalized.length === 0) {
+        return 0;
+    }
+    if (keyNormalized === queryNormalized) {
+        return 780;
+    }
+    const keyLength = stringLength(keyNormalized);
+    const queryLength = stringLength(queryNormalized);
+    const maxLength = Math.max(keyLength, queryLength);
+    if (maxLength < 3) {
+        return 0;
+    }
+    const maxDistance = Math.max(1, Math.floor(maxLength * 0.34));
+    const distance = levenshteinDistance(keyNormalized, queryNormalized, maxDistance);
+    if (distance === undefined) {
+        return 0;
+    }
+    const similarity = 1 - distance / maxLength;
+    let score = 0;
+    if (similarity >= 0.92) {
+        score = 520;
+    }
+    else if (similarity >= 0.84) {
+        score = 420;
+    }
+    else if (similarity >= 0.74) {
+        score = 300;
+    }
+    else if (similarity >= 0.64) {
+        score = 200;
+    }
+    else {
+        return 0;
+    }
+    if (keyNormalized.startsWith(queryNormalized) || queryNormalized.startsWith(keyNormalized)) {
+        score += 30;
+    }
+    return score;
+}
+function splitWikiTarget(targetRaw) {
+    const trimmed = targetRaw.trim();
+    if (trimmed.length === 0) {
+        return { base: "", suffix: "" };
+    }
+    const hashIndex = trimmed.indexOf("#");
+    const blockIndex = trimmed.indexOf("^");
+    let splitIndex = -1;
+    if (hashIndex >= 0 && blockIndex >= 0) {
+        splitIndex = Math.min(hashIndex, blockIndex);
+    }
+    else if (hashIndex >= 0) {
+        splitIndex = hashIndex;
+    }
+    else if (blockIndex >= 0) {
+        splitIndex = blockIndex;
+    }
+    if (splitIndex < 0) {
+        return { base: trimmed, suffix: "" };
+    }
+    return {
+        base: trimmed.slice(0, splitIndex).trim(),
+        suffix: trimmed.slice(splitIndex),
+    };
+}
+function extractWikiLinks(text) {
+    const pattern = /\[\[([^\]\n]+)\]\]/g;
+    const tokens = [];
+    let match;
+    while ((match = pattern.exec(text)) !== null) {
+        const raw = match[0];
+        const inner = match[1].trim();
+        const pipeIndex = inner.indexOf("|");
+        const targetRaw = (pipeIndex >= 0 ? inner.slice(0, pipeIndex) : inner).trim();
+        const alias = pipeIndex >= 0 ? inner.slice(pipeIndex + 1) : undefined;
+        const { base, suffix } = splitWikiTarget(targetRaw);
+        tokens.push({
+            raw,
+            inner,
+            targetRaw,
+            targetBase: base,
+            suffix,
+            alias,
+            start: match.index,
+            end: match.index + raw.length,
+        });
+    }
+    return tokens;
+}
+function renderWikiLink(targetBase, suffix, alias) {
+    const target = `${targetBase}${suffix}`;
+    if (alias === undefined) {
+        return `[[${target}]]`;
+    }
+    return `[[${target}|${alias}]]`;
+}
+function rewriteWikiLinks(text, replacer) {
+    const tokens = extractWikiLinks(text);
+    if (tokens.length === 0) {
+        return { text, replaced: 0 };
+    }
+    let out = "";
+    let replaced = 0;
+    let lastIndex = 0;
+    for (const token of tokens) {
+        out += text.slice(lastIndex, token.start);
+        const next = replacer(token);
+        if (next !== undefined && next !== token.raw) {
+            out += next;
+            replaced += 1;
+        }
+        else {
+            out += token.raw;
+        }
+        lastIndex = token.end;
+    }
+    out += text.slice(lastIndex);
+    return { text: out, replaced };
+}
+function lineAtOffset(text, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, text.length));
+    const lineStart = text.lastIndexOf("\n", safeOffset - 1);
+    const lineEnd = text.indexOf("\n", safeOffset);
+    const start = lineStart >= 0 ? lineStart + 1 : 0;
+    const end = lineEnd >= 0 ? lineEnd : text.length;
+    return text.slice(start, end).trim();
+}
+function linePrefixAtOffset(text, offset) {
+    const safeOffset = Math.max(0, Math.min(offset, text.length));
+    const lineStart = text.lastIndexOf("\n", safeOffset - 1);
+    const start = lineStart >= 0 ? lineStart + 1 : 0;
+    return text.slice(start, safeOffset).trim();
+}
+function uniqueByFilePath(notes) {
+    const seen = new Set();
+    const unique = [];
+    for (const note of notes) {
+        if (seen.has(note.filePath)) {
+            continue;
+        }
+        seen.add(note.filePath);
+        unique.push(note);
+    }
+    return unique;
+}
+export class LocalNoteStore {
+    config;
+    storage;
+    root;
+    projectName;
+    constructor(config, storage) {
+        this.config = config;
+        this.storage = storage;
+        this.root = config.root;
+        this.projectName = path.basename(this.root);
+    }
+    identifierKeys(note) {
+        const relativeNoExt = note.relativePath.endsWith(MARKDOWN_EXTENSION)
+            ? note.relativePath.slice(0, -MARKDOWN_EXTENSION.length)
+            : note.relativePath;
+        return [
+            note.title,
+            note.permalink,
+            note.relativePath,
+            relativeNoExt,
+            path.basename(note.filePath, MARKDOWN_EXTENSION),
+        ];
+    }
+    candidateKeysFromTarget(targetBase) {
+        const trimmed = targetBase.trim();
+        if (trimmed.length === 0) {
+            return [];
+        }
+        const normalizedPath = trimmed.replace(/\\/g, "/").replace(/^\.\//, "");
+        const withoutExtension = normalizedPath.endsWith(MARKDOWN_EXTENSION)
+            ? normalizedPath.slice(0, -MARKDOWN_EXTENSION.length)
+            : normalizedPath;
+        const baseNoExt = path.posix.basename(withoutExtension);
+        const baseWithExt = path.posix.basename(normalizedPath);
+        return Array.from(new Set([normalizedPath, withoutExtension, baseNoExt, baseWithExt].filter((key) => key.length > 0)));
+    }
+    addToLookup(map, key, note) {
+        const normalizedKey = key.trim();
+        if (normalizedKey.length === 0) {
+            return;
+        }
+        const current = map.get(normalizedKey) ?? [];
+        if (!current.some((item) => item.filePath === note.filePath)) {
+            current.push(note);
+            map.set(normalizedKey, current);
+        }
+    }
+    buildLookup(notes) {
+        const exact = new Map();
+        const normalized = new Map();
+        for (const note of notes) {
+            const keys = this.identifierKeys(note);
+            for (const key of keys) {
+                this.addToLookup(exact, key.toLowerCase(), note);
+                this.addToLookup(normalized, normalizeLookup(key), note);
+            }
+        }
+        return { exact, normalized };
+    }
+    resolveWikiTarget(targetBase, lookup) {
+        const keys = this.candidateKeysFromTarget(targetBase);
+        if (keys.length === 0) {
+            return { status: "unresolved", reason: "empty_target" };
+        }
+        const exactCandidates = [];
+        for (const key of keys) {
+            exactCandidates.push(...(lookup.exact.get(key.toLowerCase()) ?? []));
+        }
+        const uniqueExact = uniqueByFilePath(exactCandidates);
+        if (uniqueExact.length === 1) {
+            return { status: "resolved", note: uniqueExact[0] };
+        }
+        if (uniqueExact.length > 1) {
+            return { status: "ambiguous", reason: "multiple_exact_matches" };
+        }
+        const normalizedCandidates = [];
+        for (const key of keys) {
+            normalizedCandidates.push(...(lookup.normalized.get(normalizeLookup(key)) ?? []));
+        }
+        const uniqueNormalized = uniqueByFilePath(normalizedCandidates);
+        if (uniqueNormalized.length === 1) {
+            return { status: "resolved", note: uniqueNormalized[0] };
+        }
+        if (uniqueNormalized.length > 1) {
+            return { status: "ambiguous", reason: "multiple_normalized_matches" };
+        }
+        return { status: "unresolved", reason: "target_not_found" };
+    }
+    resolveWikiLinksForText(text, lookup) {
+        const tokens = extractWikiLinks(text);
+        return tokens.map((token) => {
+            const resolved = this.resolveWikiTarget(token.targetBase, lookup);
+            if (resolved.status === "resolved" && resolved.note) {
+                return {
+                    raw: token.raw,
+                    target: token.targetBase,
+                    resolved: true,
+                    resolvedTitle: resolved.note.title,
+                    resolvedPermalink: resolved.note.permalink,
+                    resolvedFilePath: resolved.note.relativePath,
+                };
+            }
+            return {
+                raw: token.raw,
+                target: token.targetBase,
+                resolved: false,
+                reason: resolved.reason ?? resolved.status,
+            };
+        });
+    }
+    linkHealthFromResolutions(resolutions) {
+        const total = resolutions.length;
+        const unresolved = resolutions.filter((item) => !item.resolved).length;
+        return {
+            total,
+            resolved: total - unresolved,
+            unresolved,
+        };
+    }
+    unresolvedTargetsFromResolutions(resolutions) {
+        const unresolved = new Set();
+        for (const item of resolutions) {
+            if (!item.resolved) {
+                unresolved.add(item.target || item.raw);
+            }
+        }
+        return Array.from(unresolved.values()).sort((left, right) => left.localeCompare(right, "ja"));
+    }
+    linkSuggestionsForTarget(target, notes, limit) {
+        const candidates = [];
+        const normalizedTargetPath = target.replace(/\\/g, "/").replace(/\.md$/i, "").trim();
+        const targetDir = normalizedTargetPath.includes("/") ? path.posix.dirname(normalizedTargetPath) : "";
+        const targetBase = path.posix.basename(normalizedTargetPath);
+        const targetBaseNormalized = normalizeHintKey(targetBase);
+        for (const note of notes) {
+            let identifierScore = 0;
+            let fuzzyScore = 0;
+            for (const key of this.identifierKeys(note)) {
+                identifierScore = Math.max(identifierScore, identifierMatchScore(key, target));
+                fuzzyScore = Math.max(fuzzyScore, fuzzyIdentifierScore(key, target));
+            }
+            let score = Math.max(identifierScore, fuzzyScore);
+            if (score <= 0) {
+                continue;
+            }
+            const reasons = [];
+            if (identifierScore > 0) {
+                reasons.push("identifier_match");
+            }
+            if (fuzzyScore > 0) {
+                reasons.push("edit_distance");
+            }
+            const noteDir = path.posix.dirname(note.relativePath);
+            if (targetDir.length > 0 && targetDir !== ".") {
+                if (noteDir === targetDir) {
+                    score += 60;
+                    reasons.push("same_directory");
+                }
+                else if (noteDir.startsWith(`${targetDir}/`)) {
+                    score += 35;
+                    reasons.push("near_directory");
+                }
+            }
+            if (targetBaseNormalized.length > 0) {
+                const noteBase = path.posix.basename(note.relativePath, MARKDOWN_EXTENSION);
+                const noteBaseNormalized = normalizeHintKey(noteBase);
+                if (noteBaseNormalized === targetBaseNormalized) {
+                    score += 50;
+                    reasons.push("basename_exact");
+                }
+                else if (noteBaseNormalized.includes(targetBaseNormalized)
+                    || targetBaseNormalized.includes(noteBaseNormalized)) {
+                    score += 20;
+                    reasons.push("basename_partial");
+                }
+            }
+            candidates.push({
+                note,
+                score,
+                reasons: Array.from(new Set(reasons)),
+            });
+        }
+        candidates.sort((left, right) => {
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            if (right.note.updated !== left.note.updated) {
+                return right.note.updated.localeCompare(left.note.updated);
+            }
+            return left.note.title.localeCompare(right.note.title, "ja");
+        });
+        return candidates.slice(0, limit).map((item) => ({
+            title: item.note.title,
+            permalink: item.note.permalink,
+            filePath: item.note.relativePath,
+            score: item.score,
+            reasons: item.reasons,
+        }));
+    }
+    unresolvedHintsFromResolutions(resolutions, notes) {
+        return this.unresolvedTargetsFromResolutions(resolutions).map((target) => ({
+            target,
+            suggestions: this.linkSuggestionsForTarget(target, notes, 3),
+        }));
+    }
+    duplicateWarningsForNote(note, notes) {
+        const byTitle = notes.filter((item) => item.filePath !== note.filePath && item.title === note.title);
+        const byPermalink = notes.filter((item) => item.filePath !== note.filePath && item.permalink === note.permalink);
+        const warnings = [];
+        if (byTitle.length > 0) {
+            warnings.push({
+                kind: "title",
+                value: note.title,
+                count: byTitle.length,
+                examples: byTitle.slice(0, 3).map((item) => `${item.title} (${item.relativePath})`),
+            });
+        }
+        if (byPermalink.length > 0) {
+            warnings.push({
+                kind: "permalink",
+                value: note.permalink,
+                count: byPermalink.length,
+                examples: byPermalink.slice(0, 3).map((item) => `${item.title} (${item.relativePath})`),
+            });
+        }
+        return warnings;
+    }
+    backlinkCountForTarget(target, notes, lookup) {
+        let count = 0;
+        for (const source of notes) {
+            if (source.filePath === target.filePath) {
+                continue;
+            }
+            const links = this.resolveWikiLinksForText(source.body, lookup);
+            count += links.filter((link) => link.resolved && link.resolvedFilePath === target.relativePath).length;
+        }
+        return count;
+    }
+    memoryContractSpec() {
+        return {
+            version: MEMORY_CONTRACT_VERSION,
+            requiredFrontmatter: [...MEMORY_CONTRACT_REQUIRED_FRONTMATTER],
+            flowRequiredFrontmatter: [...MEMORY_CONTRACT_FLOW_REQUIRED_FRONTMATTER],
+            requirements: {
+                minResolvedLinks: MEMORY_CONTRACT_REQUIREMENTS.minResolvedLinks,
+                minBacklinks: MEMORY_CONTRACT_REQUIREMENTS.minBacklinks,
+                minParentLinks: MEMORY_CONTRACT_REQUIREMENTS.minParentLinks,
+                minRelatedLinks: MEMORY_CONTRACT_REQUIREMENTS.minRelatedLinks,
+                maxUnresolvedLinks: MEMORY_CONTRACT_REQUIREMENTS.maxUnresolvedLinks,
+                minTags: MEMORY_CONTRACT_REQUIREMENTS.minTags,
+            },
+            flowRequirements: {
+                minResolvedLinks: MEMORY_CONTRACT_FLOW_REQUIREMENTS.minResolvedLinks,
+                minBacklinks: MEMORY_CONTRACT_FLOW_REQUIREMENTS.minBacklinks,
+                minParentLinks: MEMORY_CONTRACT_FLOW_REQUIREMENTS.minParentLinks,
+                minRelatedLinks: MEMORY_CONTRACT_FLOW_REQUIREMENTS.minRelatedLinks,
+                maxUnresolvedLinks: MEMORY_CONTRACT_FLOW_REQUIREMENTS.maxUnresolvedLinks,
+                minTags: MEMORY_CONTRACT_FLOW_REQUIREMENTS.minTags,
+            },
+            parentLinkMarkers: [...MEMORY_CONTRACT_PARENT_MARKERS],
+            optionalSourceMetadata: {
+                canonicalField: "source_ref",
+                auxiliaryFields: ["source_id", "source_root_ref"],
+                rules: [
+                    "source metadata は任意であり必須 frontmatter ではない",
+                    "source_ref を canonical とし、source_id は補助キーとして扱う",
+                    "absolute path は保存しない",
+                    "source metadata があっても本文は source 非依存で読める状態を優先する",
+                ],
+            },
+            indexNavigationPolicy: {
+                excludedMemoryKinds: [...INDEX_NAVIGATION_POLICY.excludedMemoryKinds],
+                signals: INDEX_NAVIGATION_POLICY.signals.map((signal) => ({ ...signal })),
+                thresholds: {
+                    scoreAtLeast: this.config.indexNavigation.scoreThreshold,
+                    indexSectionsAtLeast: this.config.indexNavigation.sectionThreshold,
+                },
+                configurableVia: {
+                    env: [...INDEX_NAVIGATION_POLICY.configurableVia.env],
+                    cli: [...INDEX_NAVIGATION_POLICY.configurableVia.cli],
+                },
+                rules: [...INDEX_NAVIGATION_POLICY.rules],
+            },
+            technicalDebtPolicy: {
+                signals: [...TECHNICAL_DEBT_POLICY.signals],
+                staleFlowStates: Array.from(STALE_FLOW_STATES),
+                thresholds: {
+                    staleFlowDays: this.config.technicalDebt.staleFlowDays,
+                },
+                staleFlowAgeBuckets: {
+                    nearThreshold: TECHNICAL_DEBT_POLICY.staleFlowAgeBuckets.nearThreshold,
+                    aging: TECHNICAL_DEBT_POLICY.staleFlowAgeBuckets.aging,
+                    longStale: TECHNICAL_DEBT_POLICY.staleFlowAgeBuckets.longStale,
+                },
+                cleanupRatioDefinition: TECHNICAL_DEBT_POLICY.cleanupRatioDefinition,
+                cleanupReadyCountDefinition: TECHNICAL_DEBT_POLICY.cleanupReadyCountDefinition,
+                attentionNoteCountDefinition: TECHNICAL_DEBT_POLICY.attentionNoteCountDefinition,
+                dependencyDirectionViolationCountDefinition: TECHNICAL_DEBT_POLICY.dependencyDirectionViolationCountDefinition,
+                singleUseTagCandidateCountDefinition: TECHNICAL_DEBT_POLICY.singleUseTagCandidateCountDefinition,
+                titleBodyMismatchCandidateCountDefinition: TECHNICAL_DEBT_POLICY.titleBodyMismatchCandidateCountDefinition,
+                unresolvedWikilinksDeltaStatus: TECHNICAL_DEBT_POLICY.unresolvedWikilinksDeltaStatus,
+                configurableVia: {
+                    env: [...TECHNICAL_DEBT_POLICY.configurableVia.env],
+                    cli: [...TECHNICAL_DEBT_POLICY.configurableVia.cli],
+                },
+            },
+            responseModePolicy: {
+                supportedTools: {
+                    read: [...RESPONSE_MODE_POLICY.supportedTools.read],
+                    audit: [...RESPONSE_MODE_POLICY.supportedTools.audit],
+                },
+                modes: {
+                    minimal: RESPONSE_MODE_POLICY.modes.minimal,
+                    standard: RESPONSE_MODE_POLICY.modes.standard,
+                    verbose: RESPONSE_MODE_POLICY.modes.verbose,
+                },
+                rules: [...RESPONSE_MODE_POLICY.rules],
+            },
+            sampleTemplates: {
+                stock: [
+                    "---",
+                    "type: note",
+                    "tags:",
+                    "  - topic",
+                    "created: <YYYY-MM-DD>",
+                    "updated: <YYYY-MM-DD>",
+                    "permalink: <slug>",
+                    "---",
+                    "- 親: [[上位ノート]]",
+                    "- 関連: [[関連ノートA]]",
+                    "- 関連: [[関連ノートB]]",
+                    "",
+                    "## 要点",
+                    "",
+                    "- 何を残すノートか",
+                    "",
+                    "## 詳細",
+                    "",
+                    "- 再利用したい知識を書く",
+                ],
+                flow: [
+                    "---",
+                    "type: flow",
+                    "tags:",
+                    "  - topic",
+                    "created: <YYYY-MM-DD>",
+                    "updated: <YYYY-MM-DD>",
+                    "permalink: <slug>",
+                    "memory_kind: flow",
+                    "flow_state: active",
+                    "question: <いま答えたい問い>",
+                    "next_action: <次にやる具体行動>",
+                    "parent_stock: <既存 stock の title or permalink>",
+                    "---",
+                    "- 親: [[親テーマ or MOC]]",
+                    "- 関連: [[関連Flow or Stock]]",
+                    "",
+                    "## Notes",
+                    "",
+                    "- 判断材料、障害、進捗を書く",
+                ],
+                index: [
+                    "---",
+                    "type: note",
+                    "tags:",
+                    "  - index",
+                    "created: <YYYY-MM-DD>",
+                    "updated: <YYYY-MM-DD>",
+                    "permalink: <slug>",
+                    "---",
+                    "- 親: [[上位計画 or MOC]]",
+                    "- 関連: [[関連Flow or 監査ノート]]",
+                    "",
+                    "## 目的",
+                    "",
+                    "- 何の入口かを書く",
+                    "",
+                    "## テーマ別入口",
+                    "",
+                    "- [[代表ノートA]]",
+                    "- [[代表ノートB]]",
+                    "",
+                    "## まず何を読むか",
+                    "",
+                    "1. [[最初に読むノート]]",
+                ],
+            },
+        };
+    }
+    contractLinkSignals(note, lookup) {
+        const parentTargets = new Set();
+        const relatedTargets = new Set();
+        const tokens = extractWikiLinks(note.body);
+        for (const token of tokens) {
+            const resolved = this.resolveWikiTarget(token.targetBase, lookup);
+            if (resolved.status !== "resolved" || !resolved.note) {
+                continue;
+            }
+            const linePrefix = linePrefixAtOffset(note.body, token.start);
+            const target = resolved.note.relativePath;
+            if (PARENT_LINE_PATTERN.test(linePrefix)) {
+                parentTargets.add(target);
+            }
+            else {
+                relatedTargets.add(target);
+            }
+        }
+        return {
+            parentLinks: parentTargets.size,
+            relatedLinks: relatedTargets.size,
+        };
+    }
+    parentLinkTargets(note, lookup) {
+        const targets = new Set();
+        const tokens = extractWikiLinks(note.body);
+        for (const token of tokens) {
+            const linePrefix = linePrefixAtOffset(note.body, token.start);
+            if (!PARENT_LINE_PATTERN.test(linePrefix)) {
+                continue;
+            }
+            const resolved = this.resolveWikiTarget(token.targetBase, lookup);
+            if (resolved.status === "resolved" && resolved.note) {
+                targets.add(resolved.note.relativePath);
+            }
+        }
+        return targets;
+    }
+    resolvedLinkTargets(note, lookup) {
+        const targets = new Set();
+        const resolutions = this.resolveWikiLinksForText(note.body, lookup);
+        for (const resolution of resolutions) {
+            if (!resolution.resolved || !resolution.resolvedFilePath) {
+                continue;
+            }
+            targets.add(resolution.resolvedFilePath);
+        }
+        return targets;
+    }
+    indexSignalsForNote(note) {
+        if (this.memoryKindForNote(note) === "flow") {
+            return { score: 0, reasons: [], indexLike: false };
+        }
+        let score = 0;
+        const reasons = [];
+        const normalizedTags = new Set(safeStringArray(note.frontmatter.tags).map((tag) => normalizeLookup(tag)));
+        if (INDEX_TAG_MARKERS.some((tag) => normalizedTags.has(tag))) {
+            score += INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "index_tag").weight;
+            reasons.push("index_tag");
+        }
+        if (INDEX_TITLE_PATTERN.test(note.title)) {
+            score += INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "title_marker").weight;
+            reasons.push("title_marker");
+        }
+        if (INDEX_TITLE_PATTERN.test(note.permalink)) {
+            score += INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "permalink_marker").weight;
+            reasons.push("permalink_marker");
+        }
+        if (INDEX_TITLE_PATTERN.test(note.relativePath)) {
+            score += INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "path_marker").weight;
+            reasons.push("path_marker");
+        }
+        let sectionCount = 0;
+        for (const heading of INDEX_SECTION_HEADINGS) {
+            if (extractSectionBody(note.body, heading).length > 0) {
+                sectionCount += 1;
+                reasons.push(`section:${heading}`);
+            }
+        }
+        if (sectionCount > 0) {
+            score += sectionCount * INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "section:*").weight;
+        }
+        if (sectionCount >= INDEX_NAVIGATION_POLICY.thresholds.indexSectionsAtLeast) {
+            score += INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "multi_index_sections").weight;
+            reasons.push("multi_index_sections");
+        }
+        const wikiLinkCount = extractWikiLinks(note.body).length;
+        if (wikiLinkCount >= 4) {
+            score += INDEX_NAVIGATION_POLICY.signals.find((signal) => signal.code === "link_hub").weight;
+            reasons.push("link_hub");
+        }
+        return {
+            score,
+            reasons: uniqueStrings(reasons),
+            indexLike: score >= this.config.indexNavigation.scoreThreshold ||
+                sectionCount >= this.config.indexNavigation.sectionThreshold,
+        };
+    }
+    indexMetaForNote(note) {
+        const signals = this.indexSignalsForNote(note);
+        return {
+            indexLike: signals.indexLike,
+            indexReasons: signals.indexLike ? signals.reasons : [],
+        };
+    }
+    finalizeIndexCandidates(candidates, limit) {
+        candidates.sort((left, right) => {
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            if (right.note.updated !== left.note.updated) {
+                return right.note.updated.localeCompare(left.note.updated);
+            }
+            return left.note.title.localeCompare(right.note.title, "ja");
+        });
+        return candidates.slice(0, limit).map((item) => ({
+            title: item.note.title,
+            permalink: item.note.permalink,
+            filePath: item.note.relativePath,
+            score: item.score,
+            reasons: item.reasons,
+        }));
+    }
+    recentIndexCandidates(notes, directoryPrefix, limit) {
+        const candidates = [];
+        for (const note of notes) {
+            if (directoryPrefix.length > 0) {
+                const matchPrefix = `${directoryPrefix}/`;
+                if (!note.relativePath.startsWith(matchPrefix)) {
+                    continue;
+                }
+            }
+            const signals = this.indexSignalsForNote(note);
+            if (!signals.indexLike) {
+                continue;
+            }
+            candidates.push({
+                note,
+                score: signals.score,
+                reasons: signals.reasons,
+            });
+        }
+        return this.finalizeIndexCandidates(candidates, limit);
+    }
+    searchIndexCandidates(notes, query, afterDate, limit) {
+        const candidates = [];
+        for (const note of notes) {
+            if (afterDate && note.updated < afterDate) {
+                continue;
+            }
+            const signals = this.indexSignalsForNote(note);
+            if (!signals.indexLike) {
+                continue;
+            }
+            const queryScore = this.noteScore(note, query);
+            if (queryScore <= 0) {
+                continue;
+            }
+            candidates.push({
+                note,
+                score: signals.score + queryScore,
+                reasons: uniqueStrings([...signals.reasons, "query_match"]),
+            });
+        }
+        return this.finalizeIndexCandidates(candidates, limit);
+    }
+    relatedIndexCandidates(sourceNote, notes, limit) {
+        const lookup = this.buildLookup(notes);
+        const sourceOutgoing = this.resolvedLinkTargets(sourceNote, lookup);
+        const sourceParents = this.parentLinkTargets(sourceNote, lookup);
+        const sourceTags = new Set(safeStringArray(sourceNote.frontmatter.tags).map((tag) => normalizeLookup(tag)));
+        const sourceDir = path.posix.dirname(sourceNote.relativePath);
+        const candidates = [];
+        for (const candidate of notes) {
+            if (candidate.filePath === sourceNote.filePath) {
+                continue;
+            }
+            const signals = this.indexSignalsForNote(candidate);
+            if (!signals.indexLike) {
+                continue;
+            }
+            const reasons = [...signals.reasons];
+            let score = signals.score;
+            const candidateOutgoing = this.resolvedLinkTargets(candidate, lookup);
+            if (sourceParents.has(candidate.relativePath)) {
+                score += 180;
+                reasons.push("source_parent_index");
+            }
+            if (sourceOutgoing.has(candidate.relativePath)) {
+                score += 110;
+                reasons.push("source_links_index");
+            }
+            if (candidateOutgoing.has(sourceNote.relativePath)) {
+                score += 160;
+                reasons.push("index_links_source");
+            }
+            const candidateTags = new Set(safeStringArray(candidate.frontmatter.tags).map((tag) => normalizeLookup(tag)));
+            const sharedTags = intersectCount(sourceTags, candidateTags);
+            if (sharedTags > 0) {
+                score += Math.min(60, sharedTags * 20);
+                reasons.push(`shared_tags:${sharedTags}`);
+            }
+            const candidateDir = path.posix.dirname(candidate.relativePath);
+            if (candidateDir === sourceDir) {
+                score += 20;
+                reasons.push("same_directory");
+            }
+            candidates.push({
+                note: candidate,
+                score,
+                reasons: uniqueStrings(reasons),
+            });
+        }
+        return this.finalizeIndexCandidates(candidates, limit);
+    }
+    explorationDirectoryHint(notes) {
+        if (notes.length < 2) {
+            return undefined;
+        }
+        const exactCounts = new Map();
+        const topLevelCounts = new Map();
+        for (const note of notes) {
+            const directory = path.posix.dirname(note.relativePath);
+            if (directory !== ".") {
+                exactCounts.set(directory, (exactCounts.get(directory) ?? 0) + 1);
+            }
+            const topLevel = note.relativePath.split("/")[0]?.trim();
+            if (topLevel) {
+                topLevelCounts.set(topLevel, (topLevelCounts.get(topLevel) ?? 0) + 1);
+            }
+        }
+        const bestExact = [...exactCounts.entries()]
+            .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0], "ja"))[0];
+        if (bestExact && bestExact[1] >= 2) {
+            return {
+                directory: bestExact[0],
+                suggestedTool: "recent_notes",
+                reason: `clustered_directory:${bestExact[0]}(${bestExact[1]}/${notes.length})`,
+            };
+        }
+        const bestTopLevel = [...topLevelCounts.entries()]
+            .sort((left, right) => right[1] - left[1] || left[0].localeCompare(right[0], "ja"))[0];
+        if (bestTopLevel && bestTopLevel[1] >= 2 && bestTopLevel[0] !== ".") {
+            return {
+                directory: bestTopLevel[0],
+                suggestedTool: "recent_notes",
+                reason: `clustered_root_directory:${bestTopLevel[0]}(${bestTopLevel[1]}/${notes.length})`,
+            };
+        }
+        return undefined;
+    }
+    explorationTagPresets(allNotes, candidateNotes, baseQuery, reasonPrefix) {
+        if (candidateNotes.length < 2) {
+            return [];
+        }
+        const excludedTerms = new Set(searchTerms(baseQuery).map((term) => normalizeLookup(term)));
+        const globalCounts = new Map();
+        const labels = new Map();
+        for (const note of allNotes) {
+            const noteTags = new Set();
+            for (const tag of safeStringArray(note.frontmatter.tags)) {
+                const normalized = normalizeLookup(tag);
+                if (!normalized || EXPLORATION_TAG_STOPWORDS.has(normalized) || normalized.startsWith("batch")) {
+                    continue;
+                }
+                noteTags.add(normalized);
+                if (!labels.has(normalized)) {
+                    labels.set(normalized, tag);
+                }
+            }
+            noteTags.forEach((tag) => {
+                globalCounts.set(tag, (globalCounts.get(tag) ?? 0) + 1);
+            });
+        }
+        const localCounts = new Map();
+        for (const note of candidateNotes) {
+            const noteTags = new Set();
+            for (const tag of safeStringArray(note.frontmatter.tags)) {
+                const normalized = normalizeLookup(tag);
+                if (!normalized || excludedTerms.has(normalized) || EXPLORATION_TAG_STOPWORDS.has(normalized) || normalized.startsWith("batch")) {
+                    continue;
+                }
+                noteTags.add(normalized);
+                if (!labels.has(normalized)) {
+                    labels.set(normalized, tag);
+                }
+            }
+            noteTags.forEach((tag) => {
+                localCounts.set(tag, (localCounts.get(tag) ?? 0) + 1);
+            });
+        }
+        return [...localCounts.entries()]
+            .filter(([, localCount]) => localCount >= 2)
+            .map(([tag, localCount]) => ({
+            tag,
+            label: labels.get(tag) ?? tag,
+            localCount,
+            globalCount: globalCounts.get(tag) ?? localCount,
+        }))
+            .filter((item) => item.globalCount <= item.localCount * 4)
+            .sort((left, right) => right.localCount - left.localCount || left.globalCount - right.globalCount || left.label.localeCompare(right.label, "ja"))
+            .slice(0, 2)
+            .map((item) => ({
+            query: `${baseQuery} ${item.label}`.trim(),
+            reason: `${reasonPrefix}:${item.label}(${item.localCount}/${item.globalCount})`,
+        }));
+    }
+    searchExplorationGuidance(allNotes, rankedNotes, query) {
+        const topNotes = rankedNotes.slice(0, 5);
+        return {
+            directoryScopeHint: this.explorationDirectoryHint(topNotes),
+            queryPresets: this.explorationTagPresets(allNotes, topNotes, query, "shared_result_tag"),
+        };
+    }
+    contextExplorationGuidance(allNotes, sourceNote, rankedNotes) {
+        const topNotes = rankedNotes.slice(0, 5);
+        return {
+            directoryScopeHint: this.explorationDirectoryHint([sourceNote, ...topNotes]),
+            queryPresets: this.explorationTagPresets(allNotes, [sourceNote, ...topNotes], sourceNote.title, "shared_context_tag"),
+        };
+    }
+    indexNavigationForNote(note, notes, limit) {
+        const meta = this.indexMetaForNote(note);
+        return {
+            indexLike: meta.indexLike,
+            indexReasons: meta.indexReasons,
+            indexNoteCandidates: this.relatedIndexCandidates(note, notes, limit),
+        };
+    }
+    memoryKindForNote(note) {
+        const explicit = safeString(note.frontmatter.memory_kind)?.toLowerCase();
+        if (explicit === "flow") {
+            return "flow";
+        }
+        if (explicit === "stock") {
+            return "stock";
+        }
+        if (safeString(note.frontmatter.flow_state)) {
+            return "flow";
+        }
+        if (/^flow(\/|$)/i.test(note.relativePath)) {
+            return "flow";
+        }
+        return "stock";
+    }
+    boundaryWarningsForNote(note) {
+        if (this.memoryKindForNote(note) === "flow") {
+            const indexBoundaryWarning = this.indexBoundaryWarningForFlow(note);
+            return indexBoundaryWarning ? [indexBoundaryWarning] : [];
+        }
+        const typeLooksFlow = safeString(note.frontmatter.type)?.toLowerCase() === "flow";
+        const hasFlowFrontmatter = Boolean(safeString(note.frontmatter.flow_state))
+            || Boolean(safeString(note.frontmatter.parent_stock))
+            || Boolean(safeString(note.frontmatter.question))
+            || Boolean(safeString(note.frontmatter.next_action));
+        const hasFlowSections = FLOW_QUESTION_HEADING_PATTERN.test(note.body)
+            && FLOW_NEXT_ACTION_HEADING_PATTERN.test(note.body)
+            && FLOW_PARENT_LINE_PATTERN.test(note.body);
+        if (!typeLooksFlow && !hasFlowFrontmatter && !hasFlowSections) {
+            return [];
+        }
+        return [
+            {
+                code: "flow_like_content_in_generic_note",
+                message: "flow 形の内容が generic note として保存されている",
+                suggestion: "進行中の問いなら write_flow_note に移し、確定知識は stock ノートへ分離する",
+            },
+        ];
+    }
+    indexBoundaryWarningForFlow(note) {
+        const normalizedTags = new Set(safeStringArray(note.frontmatter.tags).map((tag) => normalizeLookup(tag)));
+        const hasIndexTag = INDEX_TAG_MARKERS.some((tag) => normalizedTags.has(tag));
+        const hasTitleMarker = INDEX_TITLE_PATTERN.test(note.title) ||
+            INDEX_TITLE_PATTERN.test(note.permalink) ||
+            INDEX_TITLE_PATTERN.test(note.relativePath);
+        let sectionCount = 0;
+        for (const heading of INDEX_SECTION_HEADINGS) {
+            if (extractSectionBody(note.body, heading).length > 0) {
+                sectionCount += 1;
+            }
+        }
+        const wikiLinkCount = extractWikiLinks(note.body).length;
+        const looksIndexLike = hasIndexTag ||
+            sectionCount >= this.config.indexNavigation.sectionThreshold ||
+            (hasTitleMarker && sectionCount >= 1 && wikiLinkCount >= 4);
+        if (!looksIndexLike) {
+            return undefined;
+        }
+        return {
+            code: "index_like_content_in_flow_note",
+            message: "index/MOC 形の入口ノートが flow として保存されている",
+            suggestion: "再訪入口なら stock/index ノートへ移し、未完了の問いと next_action だけを flow に残す",
+        };
+    }
+    isStaleFlow(note, referenceDate = nowDate()) {
+        const staleDays = this.staleFlowAgeDays(note, referenceDate);
+        return staleDays !== undefined && staleDays >= this.config.technicalDebt.staleFlowDays;
+    }
+    staleFlowAgeDays(note, referenceDate = nowDate()) {
+        if (this.memoryKindForNote(note) !== "flow") {
+            return undefined;
+        }
+        const flowState = safeString(note.frontmatter.flow_state)?.toLowerCase();
+        if (!flowState || !STALE_FLOW_STATES.has(flowState)) {
+            return undefined;
+        }
+        return daysBetween(note.updated, referenceDate);
+    }
+    staleFlowAgeBucket(staleDays) {
+        const threshold = this.config.technicalDebt.staleFlowDays;
+        if (staleDays >= threshold + 23) {
+            return "longStale";
+        }
+        if (staleDays >= threshold + 7) {
+            return "aging";
+        }
+        return "nearThreshold";
+    }
+    isSingleUseTagCandidateIgnored(normalizedTag) {
+        if (SINGLE_USE_TAG_EXACT_IGNORES.has(normalizedTag)) {
+            return true;
+        }
+        return SINGLE_USE_TAG_PATTERN_IGNORES.some((pattern) => pattern.test(normalizedTag));
+    }
+    singleUseTagCandidates(notes) {
+        const usage = new Map();
+        for (const note of notes) {
+            if (this.memoryKindForNote(note) === "flow") {
+                continue;
+            }
+            const seenInNote = new Set();
+            for (const tag of safeStringArray(note.frontmatter.tags)) {
+                const normalizedTag = normalizeLookup(tag);
+                if (!normalizedTag || seenInNote.has(normalizedTag) || this.isSingleUseTagCandidateIgnored(normalizedTag)) {
+                    continue;
+                }
+                seenInNote.add(normalizedTag);
+                const existing = usage.get(normalizedTag);
+                if (existing) {
+                    existing.count += 1;
+                    continue;
+                }
+                usage.set(normalizedTag, {
+                    tag,
+                    note,
+                    count: 1,
+                });
+            }
+        }
+        const candidatesByFilePath = new Map();
+        for (const candidate of usage.values()) {
+            if (candidate.count !== 1) {
+                continue;
+            }
+            const existing = candidatesByFilePath.get(candidate.note.filePath);
+            if (existing) {
+                existing.tags.push(candidate.tag);
+                continue;
+            }
+            candidatesByFilePath.set(candidate.note.filePath, {
+                note: candidate.note,
+                tags: [candidate.tag],
+            });
+        }
+        return Array.from(candidatesByFilePath.values())
+            .filter((candidate) => candidate.tags.length >= 2)
+            .sort((left, right) => {
+            const byCount = right.tags.length - left.tags.length;
+            if (byCount !== 0) {
+                return byCount;
+            }
+            return left.note.title.localeCompare(right.note.title, "ja");
+        });
+    }
+    titleBodyMismatchCandidates(notes) {
+        const candidates = [];
+        for (const note of notes) {
+            if (this.memoryKindForNote(note) === "flow") {
+                continue;
+            }
+            const titleTerms = titleBodySemanticTerms(note.title);
+            if (titleTerms.length < 2) {
+                continue;
+            }
+            const headingTerms = markdownHeadings(note.body).flatMap((heading) => titleBodySemanticTerms(heading));
+            const bodyTerms = titleBodySemanticTerms(excerptBody(note.body, 6, 420));
+            const contentTerms = new Set([...headingTerms, ...bodyTerms]);
+            if (contentTerms.size === 0) {
+                continue;
+            }
+            const overlap = titleTerms.filter((term) => contentTerms.has(term));
+            if (overlap.length > 0) {
+                continue;
+            }
+            candidates.push({
+                note,
+                titleTerms: titleTerms.slice(0, 3),
+            });
+        }
+        return candidates.sort((left, right) => left.note.title.localeCompare(right.note.title, "ja"));
+    }
+    dependencyDirectionViolations(notes, lookup) {
+        const noteByRelativePath = new Map(notes.map((note) => [note.relativePath, note]));
+        const candidates = [];
+        for (const note of notes) {
+            if (this.memoryKindForNote(note) !== "stock") {
+                continue;
+            }
+            const parentFlowTargets = [...this.parentLinkTargets(note, lookup)]
+                .map((relativePath) => noteByRelativePath.get(relativePath))
+                .filter((candidate) => Boolean(candidate))
+                .filter((candidate) => this.memoryKindForNote(candidate) === "flow");
+            if (parentFlowTargets.length === 0) {
+                continue;
+            }
+            candidates.push({
+                note,
+                parentFlowTargets,
+            });
+        }
+        return candidates.sort((left, right) => left.note.title.localeCompare(right.note.title, "ja"));
+    }
+    orphanRepairQueueItem(note, notes) {
+        const indexCandidates = this.relatedIndexCandidates(note, notes, 1);
+        const suggestedParent = indexCandidates[0];
+        if (suggestedParent) {
+            return {
+                noteTitle: note.title,
+                notePath: note.relativePath,
+                category: "index_parent_available",
+                impact: "medium",
+                suggestedParent: {
+                    title: suggestedParent.title,
+                    permalink: suggestedParent.permalink,
+                    filePath: suggestedParent.filePath,
+                    reasons: suggestedParent.reasons,
+                },
+            };
+        }
+        return {
+            noteTitle: note.title,
+            notePath: note.relativePath,
+            category: "manual_linking_needed",
+            impact: "medium",
+        };
+    }
+    memoryContractForNote(args) {
+        const spec = this.memoryContractSpec();
+        const violations = [];
+        const memoryKind = this.memoryKindForNote(args.note);
+        const requirements = memoryKind === "flow" ? spec.flowRequirements : spec.requirements;
+        const hasFrontmatterValue = (key) => {
+            if (!(key in args.note.frontmatter)) {
+                return false;
+            }
+            const value = args.note.frontmatter[key];
+            if (Array.isArray(value)) {
+                return value.length > 0;
+            }
+            return value.trim().length > 0;
+        };
+        const missingFrontmatter = spec.requiredFrontmatter.filter((key) => !hasFrontmatterValue(key));
+        for (const key of missingFrontmatter) {
+            violations.push({
+                code: "missing_frontmatter_key",
+                message: `frontmatter key が不足: ${key}`,
+                suggestion: `frontmatter に ${key} を追加する`,
+            });
+        }
+        if (memoryKind === "flow") {
+            for (const key of spec.flowRequiredFrontmatter) {
+                if (hasFrontmatterValue(key)) {
+                    continue;
+                }
+                violations.push({
+                    code: "missing_flow_field",
+                    message: `flow 用 frontmatter が不足: ${key}`,
+                    suggestion: `frontmatter に ${key} を追加する`,
+                });
+            }
+        }
+        const tagsCount = safeStringArray(args.note.frontmatter.tags).length;
+        if (tagsCount < requirements.minTags) {
+            violations.push({
+                code: "missing_tags",
+                message: `tags が不足: ${tagsCount}件`,
+                suggestion: `frontmatter の tags を ${requirements.minTags} 件以上にする`,
+            });
+        }
+        if (args.linkHealth.unresolved > requirements.maxUnresolvedLinks) {
+            violations.push({
+                code: "too_many_unresolved_links",
+                message: `未解決リンクが多い: ${args.linkHealth.unresolved}件`,
+                suggestion: "未解決 WikiLink を修正する",
+            });
+        }
+        if (args.linkHealth.resolved < requirements.minResolvedLinks) {
+            violations.push({
+                code: "insufficient_resolved_links",
+                message: `解決済みリンクが不足: ${args.linkHealth.resolved}件`,
+                suggestion: `解決済み WikiLink を ${requirements.minResolvedLinks} 件以上にする`,
+            });
+        }
+        if (args.backlinkCount < requirements.minBacklinks) {
+            violations.push({
+                code: "insufficient_backlinks",
+                message: `バックリンクが不足: ${args.backlinkCount}件`,
+                suggestion: `関連ノートからの被リンクを ${requirements.minBacklinks} 件以上にする`,
+            });
+        }
+        const linkSignals = this.contractLinkSignals(args.note, args.lookup);
+        if (linkSignals.parentLinks < requirements.minParentLinks) {
+            violations.push({
+                code: "missing_parent_link",
+                message: `親リンクが不足: ${linkSignals.parentLinks}件`,
+                suggestion: "本文に `- 親: [[...]]` 形式の上位リンクを追加する",
+            });
+        }
+        if (linkSignals.relatedLinks < requirements.minRelatedLinks) {
+            violations.push({
+                code: "missing_related_link",
+                message: `関連リンクが不足: ${linkSignals.relatedLinks}件`,
+                suggestion: "本文に `- 関連: [[...]]` 形式の関連リンクを追加する",
+            });
+        }
+        if (memoryKind === "flow") {
+            const flowState = safeString(args.note.frontmatter.flow_state)?.toLowerCase();
+            if (flowState && !FLOW_STATES.has(flowState)) {
+                violations.push({
+                    code: "missing_flow_field",
+                    message: `flow_state が不正: ${flowState}`,
+                    suggestion: `flow_state を ${Array.from(FLOW_STATES).join(" / ")} のいずれかにする`,
+                });
+            }
+            const parentStock = safeString(args.note.frontmatter.parent_stock);
+            if (parentStock) {
+                const parentResolved = this.resolveWikiTarget(parentStock, args.lookup);
+                if (parentResolved.status !== "resolved" || !parentResolved.note) {
+                    violations.push({
+                        code: "invalid_parent_stock",
+                        message: `parent_stock が解決できない: ${parentStock}`,
+                        suggestion: "parent_stock を既存の stock ノートに更新する",
+                    });
+                }
+                else if (this.memoryKindForNote(parentResolved.note) !== "stock") {
+                    violations.push({
+                        code: "invalid_parent_stock",
+                        message: `parent_stock が stock 以外を指している: ${parentResolved.note.title}`,
+                        suggestion: "parent_stock を stock ノートへ修正する",
+                    });
+                }
+            }
+        }
+        return {
+            version: spec.version,
+            status: violations.length === 0 ? "pass" : "fail",
+            signals: {
+                resolvedLinks: args.linkHealth.resolved,
+                unresolvedLinks: args.linkHealth.unresolved,
+                backlinks: args.backlinkCount,
+                parentLinks: linkSignals.parentLinks,
+                relatedLinks: linkSignals.relatedLinks,
+                tags: tagsCount,
+            },
+            violations,
+        };
+    }
+    getMemoryContract() {
+        return this.memoryContractSpec();
+    }
+    structureScoreForNote(args) {
+        let score = 0;
+        const nextActions = [];
+        if (args.linkHealth.resolved > 0) {
+            score += 20;
+        }
+        else {
+            nextActions.push("既存ノートへの WikiLink を1件以上追加する");
+        }
+        if (args.backlinkCount > 0) {
+            score += 20;
+        }
+        else {
+            nextActions.push("関連ノートからこのノートへの WikiLink を追加する");
+        }
+        if (args.unresolvedWikiLinks.length === 0) {
+            score += 25;
+        }
+        else {
+            const sample = args.unresolvedWikiLinks.slice(0, 2).join(", ");
+            nextActions.push(`未解決 WikiLink を修正する: ${sample}`);
+        }
+        if (args.duplicateWarnings.length === 0) {
+            score += 15;
+        }
+        else {
+            nextActions.push("title/permalink の重複を解消する");
+        }
+        if (safeString(args.note.frontmatter.type)) {
+            score += 10;
+        }
+        else {
+            nextActions.push("frontmatter に type を追加する");
+        }
+        if (safeStringArray(args.note.frontmatter.tags).length > 0) {
+            score += 10;
+        }
+        else {
+            nextActions.push("frontmatter に tags を1件以上追加する");
+        }
+        let grade = "D";
+        if (score >= 85) {
+            grade = "A";
+        }
+        else if (score >= 70) {
+            grade = "B";
+        }
+        else if (score >= 50) {
+            grade = "C";
+        }
+        return {
+            score,
+            grade,
+            nextActions: nextActions.slice(0, 4),
+        };
+    }
+    documentClarityForNote(note) {
+        const titlePresence = note.title.trim().length > 0;
+        const summaryPresence = summaryHeadingPresent(note.body);
+        const contentLines = clarityContentLines(note.body);
+        const listRatio = listRatioForMarkdown(note.body);
+        const longSentenceCount = longSentenceCountForMarkdown(note.body);
+        const attentionReasons = [];
+        if (!summaryPresence) {
+            attentionReasons.push("summary_missing");
+        }
+        if (contentLines.length >= CLARITY_MIN_CONTENT_LINES_FOR_LIST_CHECK && listRatio < CLARITY_LOW_LIST_RATIO_THRESHOLD) {
+            attentionReasons.push("low_list_ratio");
+        }
+        if (longSentenceCount >= CLARITY_LONG_SENTENCE_ATTENTION_COUNT) {
+            attentionReasons.push("long_sentences_present");
+        }
+        if (!titlePresence) {
+            attentionReasons.push("title_missing");
+        }
+        return {
+            status: attentionReasons.length >= 2 ? "attention" : "clear",
+            titlePresence,
+            summaryPresence,
+            listRatio,
+            longSentenceCount,
+            attentionReasons,
+        };
+    }
+    qualitySignalsForNote(note, notes) {
+        const lookup = this.buildLookup(notes);
+        const resolutions = this.resolveWikiLinksForText(note.body, lookup);
+        const linkHealth = this.linkHealthFromResolutions(resolutions);
+        const unresolvedWikiLinks = this.unresolvedTargetsFromResolutions(resolutions);
+        const unresolvedLinkHints = this.unresolvedHintsFromResolutions(resolutions, notes);
+        const duplicateWarnings = this.duplicateWarningsForNote(note, notes);
+        const backlinkCount = this.backlinkCountForTarget(note, notes, lookup);
+        const orphanWarning = backlinkCount === 0 && linkHealth.resolved === 0;
+        const structureScore = this.structureScoreForNote({
+            note,
+            linkHealth,
+            unresolvedWikiLinks,
+            duplicateWarnings,
+            backlinkCount,
+        });
+        const memoryContract = this.memoryContractForNote({
+            note,
+            linkHealth,
+            backlinkCount,
+            lookup,
+        });
+        const boundaryWarnings = this.boundaryWarningsForNote(note);
+        const documentClarity = this.documentClarityForNote(note);
+        return {
+            linkHealth,
+            unresolvedWikiLinks,
+            unresolvedLinkHints,
+            duplicateWarnings,
+            backlinkCount,
+            orphanWarning,
+            structureScore,
+            memoryContract,
+            boundaryWarnings,
+            documentClarity,
+        };
+    }
+    projectLinkHealth(notes) {
+        const lookup = this.buildLookup(notes);
+        let total = 0;
+        let resolved = 0;
+        for (const note of notes) {
+            const health = this.linkHealthFromResolutions(this.resolveWikiLinksForText(note.body, lookup));
+            total += health.total;
+            resolved += health.resolved;
+        }
+        return {
+            total,
+            resolved,
+            unresolved: total - resolved,
+        };
+    }
+    projectUnresolvedSignals(notes) {
+        const lookup = this.buildLookup(notes);
+        const resolutions = [];
+        for (const note of notes) {
+            resolutions.push(...this.resolveWikiLinksForText(note.body, lookup));
+        }
+        const unresolvedWikiLinks = this.unresolvedTargetsFromResolutions(resolutions).slice(0, MAX_SIGNAL_ITEMS);
+        const unresolvedLinkHints = this.unresolvedHintsFromResolutions(resolutions, notes)
+            .filter((item) => unresolvedWikiLinks.includes(item.target))
+            .slice(0, MAX_SIGNAL_ITEMS);
+        return {
+            unresolvedWikiLinks,
+            unresolvedLinkHints,
+        };
+    }
+    async loadProjectNotes() {
+        const files = await this.storage.listMarkdownFiles();
+        return Promise.all(files.map((relativePath) => this.loadNote(relativePath)));
+    }
+    async loadNote(relativePath) {
+        const raw = await this.storage.readFile(relativePath);
+        const fileStat = await this.storage.stat(relativePath);
+        const { frontmatter, body } = splitFrontmatter(raw);
+        const filePath = path.resolve(this.root, relativePath);
+        const title = safeString(frontmatter.title) ?? path.basename(relativePath, MARKDOWN_EXTENSION);
+        const created = safeString(frontmatter.created) ?? (fileStat.birthtime ? formatLocalDate(fileStat.birthtime) : nowDate());
+        const updated = safeString(frontmatter.updated) ?? (fileStat.mtime ? formatLocalDate(fileStat.mtime) : nowDate());
+        const defaultPermalink = relativePath.endsWith(MARKDOWN_EXTENSION)
+            ? relativePath.slice(0, -MARKDOWN_EXTENSION.length)
+            : relativePath;
+        const permalink = safeString(frontmatter.permalink) ?? defaultPermalink;
+        return {
+            title,
+            permalink,
+            filePath,
+            relativePath,
+            frontmatter,
+            body,
+            raw,
+            created,
+            updated,
+        };
+    }
+    async resolveIdentifier(identifier) {
+        const trimmed = identifier.trim();
+        if (trimmed.length === 0) {
+            return undefined;
+        }
+        const pathCandidates = [trimmed, trimmed.endsWith(MARKDOWN_EXTENSION) ? undefined : `${trimmed}${MARKDOWN_EXTENSION}`]
+            .filter((candidate) => Boolean(candidate))
+            .map((candidate) => sanitizeRelativePath(candidate));
+        for (const candidate of pathCandidates) {
+            const absolutePath = path.resolve(this.root, candidate);
+            if (!isInsideDirectory(this.root, absolutePath)) {
+                continue;
+            }
+            const candidateStat = await this.storage.stat(candidate);
+            if (candidateStat.exists && candidateStat.isFile) {
+                return await this.loadNote(candidate);
+            }
+        }
+        const notes = await this.loadProjectNotes();
+        const normalizedInput = trimmed.toLowerCase();
+        const fuzzyMatches = [];
+        for (const note of notes) {
+            const keys = this.identifierKeys(note);
+            if (keys.some((key) => key.toLowerCase() === normalizedInput)) {
+                return note;
+            }
+            let bestScore = 0;
+            for (const key of keys) {
+                bestScore = Math.max(bestScore, identifierMatchScore(key, trimmed));
+            }
+            if (bestScore > 0) {
+                fuzzyMatches.push({ note, score: bestScore });
+            }
+        }
+        if (fuzzyMatches.length === 0) {
+            return undefined;
+        }
+        fuzzyMatches.sort((left, right) => {
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            return right.note.updated.localeCompare(left.note.updated);
+        });
+        if (fuzzyMatches.length === 1) {
+            return fuzzyMatches[0].note;
+        }
+        if (fuzzyMatches[0].score >= fuzzyMatches[1].score + 20) {
+            return fuzzyMatches[0].note;
+        }
+        return undefined;
+    }
+    noteScore(note, query) {
+        const normalizedQuery = normalizeForSearch(query);
+        const terms = searchTerms(query);
+        if (normalizedQuery.length === 0 || terms.length === 0) {
+            return 0;
+        }
+        const queryCompact = compactSearchText(normalizedQuery);
+        const title = normalizeForSearch(note.title);
+        const permalink = normalizeForSearch(note.permalink);
+        const body = normalizeForSearch(note.body);
+        const titleCompact = compactSearchText(title);
+        const permalinkCompact = compactSearchText(permalink);
+        const bodyCompact = compactSearchText(body);
+        let score = 0;
+        if (this.hasExactIdentifierMatch(note, query)) {
+            score += 10_000;
+        }
+        score += countOccurrences(title, normalizedQuery) * 36;
+        score += countOccurrences(permalink, normalizedQuery) * 22;
+        score += countOccurrences(body, normalizedQuery) * 5;
+        if (queryCompact.length >= 2) {
+            score += countOccurrences(titleCompact, queryCompact) * 28;
+            score += countOccurrences(permalinkCompact, queryCompact) * 16;
+            score += countOccurrences(bodyCompact, queryCompact) * 3;
+        }
+        for (const term of terms) {
+            const length = stringLength(term);
+            const likelyNgram = isCjkToken(term) && length <= 3;
+            const titleWeight = likelyNgram
+                ? 6
+                : length >= 4
+                    ? 18
+                    : 12;
+            const permalinkWeight = likelyNgram
+                ? 3
+                : length >= 4
+                    ? 10
+                    : 6;
+            const bodyWeight = likelyNgram ? 1 : 2;
+            score += countOccurrences(title, term) * titleWeight;
+            score += countOccurrences(permalink, term) * permalinkWeight;
+            score += countOccurrences(body, term) * bodyWeight;
+        }
+        score += Math.floor(identifierMatchScore(note.title, query) / 25);
+        score += Math.floor(identifierMatchScore(note.permalink, query) / 35);
+        return score;
+    }
+    hasExactIdentifierMatch(note, query) {
+        const trimmed = query.trim();
+        if (trimmed.length === 0) {
+            return false;
+        }
+        const normalizedInput = trimmed.toLowerCase();
+        const normalizedLookupInput = normalizeLookup(trimmed);
+        return this.identifierKeys(note).some((key) => {
+            if (key.toLowerCase() === normalizedInput) {
+                return true;
+            }
+            return normalizedLookupInput.length > 0 && normalizeLookup(key) === normalizedLookupInput;
+        });
+    }
+    async searchNotes(args) {
+        const notes = await this.loadProjectNotes();
+        const results = [];
+        for (const note of notes) {
+            if (args.afterDate && note.updated < args.afterDate) {
+                continue;
+            }
+            const score = this.noteScore(note, args.query);
+            if (score <= 0) {
+                continue;
+            }
+            const exactIdentifierMatch = this.hasExactIdentifierMatch(note, args.query);
+            results.push({
+                title: note.title,
+                permalink: note.permalink,
+                filePath: note.relativePath,
+                content: note.body,
+                score,
+                updated: note.updated,
+                exactIdentifierMatch,
+                ...this.indexMetaForNote(note),
+            });
+        }
+        results.sort((left, right) => {
+            if (left.exactIdentifierMatch !== right.exactIdentifierMatch) {
+                return left.exactIdentifierMatch ? -1 : 1;
+            }
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            return right.updated.localeCompare(left.updated);
+        });
+        const rankedNotes = results
+            .map((item) => notes.find((note) => note.relativePath === item.filePath))
+            .filter((note) => Boolean(note));
+        return {
+            project: this.projectName,
+            results: results.slice(0, args.limit),
+            exactIdentifierMatchCount: results.filter((item) => item.exactIdentifierMatch).length,
+            indexNoteCandidates: this.searchIndexCandidates(notes, args.query, args.afterDate, 3),
+            explorationGuidance: this.searchExplorationGuidance(notes, rankedNotes, args.query),
+        };
+    }
+    async recentNotes(args) {
+        const notes = await this.loadProjectNotes();
+        const directoryPrefix = sanitizeRelativePath(args.directory);
+        const results = [];
+        for (const note of notes) {
+            if (directoryPrefix.length > 0) {
+                const matchPrefix = `${directoryPrefix}/`;
+                if (!note.relativePath.startsWith(matchPrefix)) {
+                    continue;
+                }
+            }
+            results.push({
+                title: note.title,
+                permalink: note.permalink,
+                filePath: note.relativePath,
+                updated: note.updated,
+                ...this.indexMetaForNote(note),
+            });
+        }
+        results.sort((left, right) => right.updated.localeCompare(left.updated));
+        return {
+            project: this.projectName,
+            results: results.slice(0, args.limit),
+            indexNoteCandidates: this.recentIndexCandidates(notes, directoryPrefix, 3),
+        };
+    }
+    async suggestNotes(args) {
+        const query = args.query.trim();
+        if (query.length === 0) {
+            return { project: this.projectName, results: [] };
+        }
+        const notes = await this.loadProjectNotes();
+        const results = [];
+        for (const note of notes) {
+            let keyScore = 0;
+            for (const key of this.identifierKeys(note)) {
+                keyScore = Math.max(keyScore, identifierMatchScore(key, query));
+            }
+            const bodyScore = this.noteScore(note, query);
+            const score = keyScore + bodyScore;
+            if (score <= 0) {
+                continue;
+            }
+            const exactIdentifierMatch = this.hasExactIdentifierMatch(note, query);
+            results.push({
+                title: note.title,
+                permalink: note.permalink,
+                filePath: note.relativePath,
+                content: note.body,
+                score,
+                updated: note.updated,
+                exactIdentifierMatch,
+                ...this.indexMetaForNote(note),
+            });
+        }
+        results.sort((left, right) => {
+            if (left.exactIdentifierMatch !== right.exactIdentifierMatch) {
+                return left.exactIdentifierMatch ? -1 : 1;
+            }
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            return right.updated.localeCompare(left.updated);
+        });
+        return {
+            project: this.projectName,
+            results: results.slice(0, args.limit),
+        };
+    }
+    async readNote(identifier) {
+        const note = await this.resolveIdentifier(identifier);
+        if (!note) {
+            throw new Error(`note not found: ${identifier}`);
+        }
+        const notes = await this.loadProjectNotes();
+        const currentNote = notes.find((item) => item.filePath === note.filePath) ?? note;
+        const signals = this.qualitySignalsForNote(currentNote, notes);
+        const indexNavigation = this.indexNavigationForNote(currentNote, notes, 3);
+        return {
+            project: this.projectName,
+            note: currentNote,
+            linkHealth: signals.linkHealth,
+            unresolvedWikiLinks: signals.unresolvedWikiLinks,
+            unresolvedLinkHints: signals.unresolvedLinkHints,
+            backlinkCount: signals.backlinkCount,
+            orphanWarning: signals.orphanWarning,
+            boundaryWarnings: signals.boundaryWarnings,
+            documentClarity: signals.documentClarity,
+            indexLike: indexNavigation.indexLike,
+            indexReasons: indexNavigation.indexReasons,
+            indexNoteCandidates: indexNavigation.indexNoteCandidates,
+        };
+    }
+    async resolveLinks(args) {
+        const note = await this.resolveIdentifier(args.identifier);
+        if (!note) {
+            throw new Error(`note not found: ${args.identifier}`);
+        }
+        const notes = await this.loadProjectNotes();
+        const lookup = this.buildLookup(notes);
+        const links = this.resolveWikiLinksForText(note.body, lookup);
+        const indexNavigation = this.indexNavigationForNote(note, notes, 3);
+        return {
+            project: this.projectName,
+            note,
+            links,
+            boundaryWarnings: this.boundaryWarningsForNote(note),
+            indexLike: indexNavigation.indexLike,
+            indexReasons: indexNavigation.indexReasons,
+            indexNoteCandidates: indexNavigation.indexNoteCandidates,
+        };
+    }
+    async listBacklinks(args) {
+        const target = await this.resolveIdentifier(args.identifier);
+        if (!target) {
+            throw new Error(`note not found: ${args.identifier}`);
+        }
+        const notes = await this.loadProjectNotes();
+        const lookup = this.buildLookup(notes);
+        const indexNavigation = this.indexNavigationForNote(target, notes, 3);
+        const backlinks = [];
+        for (const source of notes) {
+            const links = this.resolveWikiLinksForText(source.body, lookup);
+            const matches = links.filter((link) => link.resolved && link.resolvedFilePath === target.relativePath);
+            if (matches.length === 0) {
+                continue;
+            }
+            backlinks.push({
+                title: source.title,
+                permalink: source.permalink,
+                filePath: source.relativePath,
+                updated: source.updated,
+                count: matches.length,
+                examples: matches.slice(0, 3).map((item) => item.raw),
+            });
+        }
+        backlinks.sort((left, right) => {
+            if (right.count !== left.count) {
+                return right.count - left.count;
+            }
+            return right.updated.localeCompare(left.updated);
+        });
+        return {
+            project: this.projectName,
+            target,
+            backlinks: backlinks.slice(0, args.limit),
+            boundaryWarnings: this.boundaryWarningsForNote(target),
+            indexLike: indexNavigation.indexLike,
+            indexReasons: indexNavigation.indexReasons,
+            indexNoteCandidates: indexNavigation.indexNoteCandidates,
+        };
+    }
+    async lintStructure(args) {
+        const notes = await this.loadProjectNotes();
+        if (notes.length === 0) {
+            return {
+                project: this.projectName,
+                noteCount: 0,
+                averageScore: 0,
+                gradeCounts: { A: 0, B: 0, C: 0, D: 0 },
+                unresolvedWikiLinkCount: 0,
+                orphanNoteCount: 0,
+                duplicateWarningCount: 0,
+                weakStructureCount: 0,
+                memoryContractViolationCount: 0,
+                technicalDebtSignals: {
+                    unresolvedWikilinksDelta: null,
+                    unresolvedWikilinksDeltaStatus: "requires_history",
+                    staleFlowCount: 0,
+                    staleFlowDays: this.config.technicalDebt.staleFlowDays,
+                    staleFlowAgeBuckets: emptyStaleFlowAgeBuckets(),
+                    oldestStaleFlowDays: null,
+                    cleanupRatio: 1,
+                    cleanupReadyCount: 0,
+                    attentionNoteCount: 0,
+                    dependencyDirectionViolationCount: 0,
+                    singleUseTagCandidateCount: 0,
+                    titleBodyMismatchCandidateCount: 0,
+                },
+                orphanRepairQueue: [],
+                issues: [],
+            };
+        }
+        const lookup = this.buildLookup(notes);
+        const noteByRelativePath = new Map();
+        const backlinkByFilePath = new Map();
+        const titleToNotes = new Map();
+        const permalinkToNotes = new Map();
+        const resolutionsByFilePath = new Map();
+        const pushMap = (map, key, note) => {
+            const items = map.get(key) ?? [];
+            items.push(note);
+            map.set(key, items);
+        };
+        for (const note of notes) {
+            noteByRelativePath.set(note.relativePath, note);
+            backlinkByFilePath.set(note.filePath, 0);
+            pushMap(titleToNotes, note.title, note);
+            pushMap(permalinkToNotes, note.permalink, note);
+        }
+        for (const source of notes) {
+            const resolutions = this.resolveWikiLinksForText(source.body, lookup);
+            resolutionsByFilePath.set(source.filePath, resolutions);
+            for (const link of resolutions) {
+                if (!link.resolved || !link.resolvedFilePath) {
+                    continue;
+                }
+                const target = noteByRelativePath.get(link.resolvedFilePath);
+                if (!target) {
+                    continue;
+                }
+                backlinkByFilePath.set(target.filePath, (backlinkByFilePath.get(target.filePath) ?? 0) + 1);
+            }
+        }
+        const issues = [];
+        const orphanRepairQueue = [];
+        const gradeCounts = {
+            A: 0,
+            B: 0,
+            C: 0,
+            D: 0,
+        };
+        let unresolvedWikiLinkCount = 0;
+        let orphanNoteCount = 0;
+        let duplicateWarningCount = 0;
+        let weakStructureCount = 0;
+        let memoryContractViolationCount = 0;
+        let staleFlowCount = 0;
+        let oldestStaleFlowDays = null;
+        const staleFlowAgeBuckets = emptyStaleFlowAgeBuckets();
+        let cleanupReadyCount = 0;
+        let totalScore = 0;
+        let dependencyDirectionViolationCount = 0;
+        const singleUseTagCandidates = this.singleUseTagCandidates(notes);
+        const titleBodyMismatchCandidates = this.titleBodyMismatchCandidates(notes);
+        const dependencyDirectionViolations = this.dependencyDirectionViolations(notes, lookup);
+        const singleUseTagCandidateByFilePath = new Map();
+        for (const candidate of singleUseTagCandidates) {
+            const items = singleUseTagCandidateByFilePath.get(candidate.note.filePath) ?? [];
+            items.push(candidate);
+            singleUseTagCandidateByFilePath.set(candidate.note.filePath, items);
+        }
+        const titleBodyMismatchCandidateByFilePath = new Map();
+        for (const candidate of titleBodyMismatchCandidates) {
+            const items = titleBodyMismatchCandidateByFilePath.get(candidate.note.filePath) ?? [];
+            items.push(candidate);
+            titleBodyMismatchCandidateByFilePath.set(candidate.note.filePath, items);
+        }
+        const dependencyDirectionViolationByFilePath = new Map();
+        for (const candidate of dependencyDirectionViolations) {
+            const items = dependencyDirectionViolationByFilePath.get(candidate.note.filePath) ?? [];
+            items.push(candidate);
+            dependencyDirectionViolationByFilePath.set(candidate.note.filePath, items);
+        }
+        for (const note of notes) {
+            const resolutions = resolutionsByFilePath.get(note.filePath) ?? [];
+            const linkHealth = this.linkHealthFromResolutions(resolutions);
+            const unresolvedWikiLinks = this.unresolvedTargetsFromResolutions(resolutions);
+            unresolvedWikiLinkCount += unresolvedWikiLinks.length;
+            const sameTitle = (titleToNotes.get(note.title) ?? []).filter((item) => item.filePath !== note.filePath);
+            const samePermalink = (permalinkToNotes.get(note.permalink) ?? []).filter((item) => item.filePath !== note.filePath);
+            const duplicateWarnings = [];
+            if (sameTitle.length > 0) {
+                duplicateWarnings.push({
+                    kind: "title",
+                    value: note.title,
+                    count: sameTitle.length,
+                    examples: sameTitle.slice(0, 3).map((item) => `${item.title} (${item.relativePath})`),
+                });
+            }
+            if (samePermalink.length > 0) {
+                duplicateWarnings.push({
+                    kind: "permalink",
+                    value: note.permalink,
+                    count: samePermalink.length,
+                    examples: samePermalink.slice(0, 3).map((item) => `${item.title} (${item.relativePath})`),
+                });
+            }
+            duplicateWarningCount += duplicateWarnings.length;
+            const backlinkCount = backlinkByFilePath.get(note.filePath) ?? 0;
+            const orphanWarning = backlinkCount === 0 && linkHealth.resolved === 0;
+            if (orphanWarning) {
+                orphanNoteCount += 1;
+                orphanRepairQueue.push(this.orphanRepairQueueItem(note, notes));
+            }
+            const structureScore = this.structureScoreForNote({
+                note,
+                linkHealth,
+                unresolvedWikiLinks,
+                duplicateWarnings,
+                backlinkCount,
+            });
+            const memoryContract = this.memoryContractForNote({
+                note,
+                linkHealth,
+                backlinkCount,
+                lookup,
+            });
+            totalScore += structureScore.score;
+            gradeCounts[structureScore.grade] += 1;
+            const weakStructure = structureScore.score < 70;
+            if (weakStructure) {
+                weakStructureCount += 1;
+            }
+            if (memoryContract.status === "fail") {
+                memoryContractViolationCount += 1;
+            }
+            const staleFlowDays = this.staleFlowAgeDays(note);
+            const staleFlow = staleFlowDays !== undefined && staleFlowDays >= this.config.technicalDebt.staleFlowDays;
+            const singleUseTagCandidatesForNote = singleUseTagCandidateByFilePath.get(note.filePath) ?? [];
+            const titleBodyMismatchCandidatesForNote = titleBodyMismatchCandidateByFilePath.get(note.filePath) ?? [];
+            const dependencyDirectionViolationsForNote = dependencyDirectionViolationByFilePath.get(note.filePath) ?? [];
+            if (staleFlow) {
+                staleFlowCount += 1;
+                staleFlowAgeBuckets[this.staleFlowAgeBucket(staleFlowDays)] += 1;
+                oldestStaleFlowDays = oldestStaleFlowDays === null
+                    ? staleFlowDays
+                    : Math.max(oldestStaleFlowDays, staleFlowDays);
+            }
+            const needsCleanup = unresolvedWikiLinks.length > 0
+                || orphanWarning
+                || duplicateWarnings.length > 0
+                || dependencyDirectionViolationsForNote.length > 0
+                || weakStructure
+                || memoryContract.status === "fail"
+                || staleFlow;
+            if (!needsCleanup) {
+                cleanupReadyCount += 1;
+            }
+            if (unresolvedWikiLinks.length > 0) {
+                issues.push({
+                    severity: "high",
+                    category: "unresolved_wikilink",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `未解決 WikiLink: ${unresolvedWikiLinks.length}件`,
+                    suggestion: `未解決リンクを修正する (${unresolvedWikiLinks.slice(0, 2).join(", ")})`,
+                    weight: 300,
+                });
+            }
+            if (orphanWarning) {
+                issues.push({
+                    severity: "medium",
+                    category: "orphan_note",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: "孤立ノート（被リンクなし・解決済み外向きリンクなし）",
+                    suggestion: "関連ノートとの相互リンクを追加する",
+                    weight: 220,
+                });
+            }
+            for (const warning of duplicateWarnings) {
+                issues.push({
+                    severity: "high",
+                    category: warning.kind === "title" ? "duplicate_title" : "duplicate_permalink",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `${warning.kind} 重複: ${warning.value}`,
+                    suggestion: `${warning.kind} を一意にする`,
+                    weight: 260,
+                });
+            }
+            for (const violation of dependencyDirectionViolationsForNote) {
+                dependencyDirectionViolationCount += 1;
+                issues.push({
+                    severity: "medium",
+                    category: "dependency_direction_violation",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `stock ノートの親リンクが flow を指している: ${violation.parentFlowTargets.map((item) => item.title).join(", ")}`,
+                    suggestion: "親リンクを stock / index へ付け替えるか、flow 参照は関連リンクへ落とす",
+                    weight: 210,
+                });
+            }
+            if (weakStructure) {
+                issues.push({
+                    severity: structureScore.grade === "D" ? "medium" : "low",
+                    category: "weak_structure",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `構造スコアが低い: ${structureScore.score} (${structureScore.grade})`,
+                    suggestion: structureScore.nextActions[0] ?? "リンクとメタデータを補完する",
+                    weight: structureScore.grade === "D" ? 180 : 120,
+                });
+            }
+            if (memoryContract.status === "fail") {
+                const sample = memoryContract.violations.slice(0, 2).map((item) => item.code).join(", ");
+                issues.push({
+                    severity: "medium",
+                    category: "memory_contract_violation",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `Memory Contract 違反: ${memoryContract.violations.length}件`,
+                    suggestion: memoryContract.violations[0]?.suggestion ?? `違反を解消する (${sample})`,
+                    weight: 200,
+                });
+            }
+            if (staleFlow) {
+                issues.push({
+                    severity: "low",
+                    category: "stale_flow",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `Flow が ${staleFlowDays} 日更新されていない`,
+                    suggestion: "flow_state を見直すか、next_action を更新する",
+                    weight: 110,
+                });
+            }
+            for (const candidate of singleUseTagCandidatesForNote) {
+                const sampleTags = candidate.tags.slice(0, 3).join(", ");
+                issues.push({
+                    severity: "low",
+                    category: "single_use_tag_candidate",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `単発使用 tag 候補が多い: ${sampleTags}`,
+                    suggestion: "tag を削除するか、既存 tag へ寄せるか、同種ノートへ再利用する",
+                    weight: 70,
+                });
+            }
+            for (const candidate of titleBodyMismatchCandidatesForNote) {
+                issues.push({
+                    severity: "low",
+                    category: "title_body_mismatch_candidate",
+                    noteTitle: note.title,
+                    notePath: note.relativePath,
+                    message: `title と本文見出しの整合が弱い: ${candidate.titleTerms.join(", ")}`,
+                    suggestion: "title を本文へ寄せるか、本文見出し/要約に中核語を反映する",
+                    weight: 80,
+                });
+            }
+        }
+        issues.sort((left, right) => {
+            if (right.weight !== left.weight) {
+                return right.weight - left.weight;
+            }
+            return left.noteTitle.localeCompare(right.noteTitle, "ja");
+        });
+        return {
+            project: this.projectName,
+            noteCount: notes.length,
+            averageScore: Math.round(totalScore / notes.length),
+            gradeCounts,
+            unresolvedWikiLinkCount,
+            orphanNoteCount,
+            duplicateWarningCount,
+            weakStructureCount,
+            memoryContractViolationCount,
+            technicalDebtSignals: {
+                unresolvedWikilinksDelta: null,
+                unresolvedWikilinksDeltaStatus: "requires_history",
+                staleFlowCount,
+                staleFlowDays: this.config.technicalDebt.staleFlowDays,
+                staleFlowAgeBuckets,
+                oldestStaleFlowDays,
+                cleanupRatio: Number((cleanupReadyCount / notes.length).toFixed(3)),
+                cleanupReadyCount,
+                attentionNoteCount: notes.length - cleanupReadyCount,
+                dependencyDirectionViolationCount,
+                singleUseTagCandidateCount: singleUseTagCandidates.length,
+                titleBodyMismatchCandidateCount: titleBodyMismatchCandidates.length,
+            },
+            orphanRepairQueue: orphanRepairQueue
+                .sort((left, right) => {
+                const leftScore = left.suggestedParent ? 1 : 0;
+                const rightScore = right.suggestedParent ? 1 : 0;
+                if (rightScore !== leftScore) {
+                    return rightScore - leftScore;
+                }
+                return left.noteTitle.localeCompare(right.noteTitle, "ja");
+            })
+                .slice(0, args.limit),
+            issues: issues.slice(0, args.limit).map(({ weight: _weight, ...issue }) => issue),
+        };
+    }
+    async contextBundle(args) {
+        const source = await this.resolveIdentifier(args.identifier);
+        if (!source) {
+            throw new Error(`note not found: ${args.identifier}`);
+        }
+        const notes = await this.loadProjectNotes();
+        const sourceNote = notes.find((item) => item.filePath === source.filePath) ?? source;
+        const lookup = this.buildLookup(notes);
+        const resolvedByFilePath = new Map();
+        const parentByFilePath = new Map();
+        for (const note of notes) {
+            resolvedByFilePath.set(note.filePath, this.resolvedLinkTargets(note, lookup));
+            parentByFilePath.set(note.filePath, this.parentLinkTargets(note, lookup));
+        }
+        const sourceOutgoing = resolvedByFilePath.get(sourceNote.filePath) ?? new Set();
+        const sourceParents = parentByFilePath.get(sourceNote.filePath) ?? new Set();
+        const sourceDir = path.posix.dirname(sourceNote.relativePath);
+        const sourceTags = new Set(safeStringArray(sourceNote.frontmatter.tags).map((tag) => normalizeLookup(tag)));
+        const sourceKind = this.memoryKindForNote(sourceNote);
+        const indexNavigation = this.indexNavigationForNote(sourceNote, notes, 3);
+        const items = [];
+        for (const candidate of notes) {
+            if (candidate.filePath === sourceNote.filePath) {
+                continue;
+            }
+            const reasons = [];
+            let score = 0;
+            const candidateOutgoing = resolvedByFilePath.get(candidate.filePath) ?? new Set();
+            if (sourceParents.has(candidate.relativePath)) {
+                score += 280;
+                reasons.push("parent_link_from_source");
+            }
+            if (sourceOutgoing.has(candidate.relativePath)) {
+                score += 220;
+                reasons.push("source_links_to_candidate");
+            }
+            if (candidateOutgoing.has(sourceNote.relativePath)) {
+                score += 220;
+                reasons.push("candidate_backlinks_source");
+            }
+            const sharedLinks = intersectCount(sourceOutgoing, candidateOutgoing);
+            if (sharedLinks > 0) {
+                score += Math.min(150, sharedLinks * 30);
+                reasons.push(`shared_outgoing_links:${sharedLinks}`);
+            }
+            const candidateTags = new Set(safeStringArray(candidate.frontmatter.tags).map((tag) => normalizeLookup(tag)));
+            const sharedTags = intersectCount(sourceTags, candidateTags);
+            if (sharedTags > 0) {
+                score += Math.min(90, sharedTags * 18);
+                reasons.push(`shared_tags:${sharedTags}`);
+            }
+            const candidateDir = path.posix.dirname(candidate.relativePath);
+            if (candidateDir === sourceDir) {
+                score += 40;
+                reasons.push("same_directory");
+            }
+            else if (sourceDir !== "."
+                && candidateDir !== "."
+                && (candidateDir.startsWith(`${sourceDir}/`) || sourceDir.startsWith(`${candidateDir}/`))) {
+                score += 20;
+                reasons.push("near_directory");
+            }
+            if (this.memoryKindForNote(candidate) === sourceKind) {
+                score += 10;
+                reasons.push("same_memory_kind");
+            }
+            if (score <= 0) {
+                continue;
+            }
+            items.push({
+                note: candidate,
+                score,
+                reasons: uniqueStrings(reasons),
+            });
+        }
+        items.sort((left, right) => {
+            if (right.score !== left.score) {
+                return right.score - left.score;
+            }
+            if (right.note.updated !== left.note.updated) {
+                return right.note.updated.localeCompare(left.note.updated);
+            }
+            return left.note.title.localeCompare(right.note.title, "ja");
+        });
+        const rankedNotes = items.map((item) => item.note);
+        return {
+            project: this.projectName,
+            source: {
+                title: sourceNote.title,
+                permalink: sourceNote.permalink,
+                filePath: sourceNote.relativePath,
+                memoryKind: sourceKind,
+                boundaryWarnings: this.boundaryWarningsForNote(sourceNote),
+                indexLike: indexNavigation.indexLike,
+                indexReasons: indexNavigation.indexReasons,
+            },
+            items: items.slice(0, args.limit).map((item) => ({
+                title: item.note.title,
+                permalink: item.note.permalink,
+                filePath: item.note.relativePath,
+                memoryKind: this.memoryKindForNote(item.note),
+                score: item.score,
+                reasons: item.reasons,
+            })),
+            indexNoteCandidates: indexNavigation.indexNoteCandidates,
+            explorationGuidance: this.contextExplorationGuidance(notes, sourceNote, rankedNotes),
+        };
+    }
+    async writeFlowNote(args) {
+        await this.storage.ensureRoot();
+        const flowState = (safeString(args.flowState)?.toLowerCase() ?? "capture");
+        if (!FLOW_STATES.has(flowState)) {
+            throw new Error(`invalid flow_state: ${flowState}`);
+        }
+        const question = args.question.trim();
+        const nextAction = args.nextAction.trim();
+        if (question.length === 0) {
+            throw new Error("question is required");
+        }
+        if (nextAction.length === 0) {
+            throw new Error("next_action is required");
+        }
+        const parentStock = normalizeWikiTargetInput(args.parentStock);
+        if (parentStock.length === 0) {
+            throw new Error("parent_stock is required");
+        }
+        const relatedTargets = uniqueStrings((args.related ?? [])
+            .map((item) => normalizeWikiTargetInput(item))
+            .filter((item) => item.length > 0)).filter((item) => item !== parentStock);
+        if (relatedTargets.length === 0) {
+            relatedTargets.push(parentStock);
+        }
+        const lines = [];
+        lines.push(`- 親: [[${parentStock}]]`);
+        for (const target of relatedTargets) {
+            lines.push(`- 関連: [[${target}]]`);
+        }
+        lines.push("");
+        lines.push("## Question");
+        lines.push(question);
+        lines.push("");
+        lines.push("## Next Action");
+        lines.push(nextAction);
+        const details = normalizeContent(args.details ?? "").trim();
+        if (details.length > 0) {
+            lines.push("");
+            lines.push("## Notes");
+            lines.push(details);
+        }
+        const normalizedTags = args.tags
+            ? args.tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0)
+            : ["flow"];
+        const result = await this.writeNote({
+            directory: args.directory ?? FLOW_DEFAULT_DIRECTORY,
+            title: args.title,
+            content: lines.join("\n"),
+            tags: normalizedTags,
+            noteType: "flow",
+            frontmatterPatch: {
+                memory_kind: "flow",
+                flow_state: flowState,
+                question,
+                next_action: nextAction,
+                parent_stock: parentStock,
+            },
+        });
+        const notes = await this.loadProjectNotes();
+        const lookup = this.buildLookup(notes);
+        const parentResolved = this.resolveWikiTarget(parentStock, lookup);
+        const parentStockResolved = parentResolved.status === "resolved" && parentResolved.note
+            ? this.memoryKindForNote(parentResolved.note) === "stock"
+            : false;
+        return {
+            ...result,
+            flowState,
+            parentStock,
+            parentStockResolved,
+        };
+    }
+    async promoteToStock(args) {
+        const sourceFlow = await this.resolveIdentifier(args.flowIdentifier);
+        if (!sourceFlow) {
+            throw new Error(`note not found: ${args.flowIdentifier}`);
+        }
+        const notes = await this.loadProjectNotes();
+        const currentFlow = notes.find((item) => item.filePath === sourceFlow.filePath) ?? sourceFlow;
+        if (this.memoryKindForNote(currentFlow) !== "flow") {
+            throw new Error(`source note is not flow: ${currentFlow.relativePath}`);
+        }
+        const lookup = this.buildLookup(notes);
+        const parentStockRaw = safeString(currentFlow.frontmatter.parent_stock);
+        const parentStock = normalizeWikiTargetInput(parentStockRaw ?? "");
+        if (parentStock.length === 0) {
+            throw new Error("flow note has no parent_stock");
+        }
+        const parentResolved = this.resolveWikiTarget(parentStock, lookup);
+        if (parentResolved.status !== "resolved" || !parentResolved.note) {
+            throw new Error(`parent_stock is unresolved: ${parentStock}`);
+        }
+        if (this.memoryKindForNote(parentResolved.note) !== "stock") {
+            throw new Error(`parent_stock is not stock: ${parentResolved.note.title}`);
+        }
+        const stockTitle = safeString(args.stockTitle) ?? currentFlow.title;
+        const summary = (extractSectionBody(currentFlow.body, "Conclusion")
+            || extractSectionBody(currentFlow.body, "結論")
+            || extractSectionBody(currentFlow.body, "Summary")
+            || extractSectionBody(currentFlow.body, "要約")
+            || safeString(currentFlow.frontmatter.question)
+            || excerptBody(currentFlow.body, 5, 360)).trim();
+        const stockLines = [];
+        stockLines.push(`- 親: [[${parentResolved.note.permalink}]]`);
+        stockLines.push(`- 関連: [[${currentFlow.permalink}]]`);
+        stockLines.push("");
+        stockLines.push("## Claim");
+        stockLines.push(summary.length > 0 ? summary : "(to be filled)");
+        stockLines.push("");
+        stockLines.push("## Evidence");
+        stockLines.push(`- Source Flow: [[${currentFlow.permalink}]]`);
+        const flowNotes = extractSectionBody(currentFlow.body, "Notes") || excerptBody(currentFlow.body, 8, 640);
+        if (flowNotes.length > 0) {
+            stockLines.push("");
+            stockLines.push("## Notes");
+            stockLines.push(flowNotes);
+        }
+        const inheritedTags = safeStringArray(currentFlow.frontmatter.tags);
+        const stockTags = args.tags
+            ? args.tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0)
+            : uniqueStrings([...inheritedTags, "stock"]);
+        const stockPrepared = await this.prepareNoteContent({
+            directory: args.directory ?? STOCK_DEFAULT_DIRECTORY,
+            title: stockTitle,
+            content: stockLines.join("\n"),
+            tags: stockTags,
+            noteType: args.noteType ?? "stock",
+            frontmatterPatch: {
+                memory_kind: "stock",
+                source_flow: currentFlow.permalink,
+            },
+        });
+        let nextFlowBody = currentFlow.body.trimEnd();
+        if (!nextFlowBody.includes(`[[${stockPrepared.permalink}]]`)) {
+            const promotionSection = `## Promotion\n- 昇格先: [[${stockPrepared.permalink}]]`;
+            nextFlowBody = nextFlowBody.length > 0
+                ? `${nextFlowBody}\n\n${promotionSection}`
+                : promotionSection;
+        }
+        const updatedFlowFrontmatter = {
+            ...currentFlow.frontmatter,
+            title: currentFlow.title,
+            type: safeString(currentFlow.frontmatter.type) ?? "flow",
+            memory_kind: "flow",
+            flow_state: "promoted",
+            parent_stock: parentResolved.note.permalink,
+            promoted_to: stockPrepared.permalink,
+            permalink: currentFlow.permalink,
+            tags: safeStringArray(currentFlow.frontmatter.tags).length > 0
+                ? safeStringArray(currentFlow.frontmatter.tags)
+                : ["flow"],
+            created: currentFlow.created,
+            updated: nowDate(),
+        };
+        const renderedFlow = `${buildFrontmatter(updatedFlowFrontmatter)}\n\n${ensureTrailingNewline(nextFlowBody)}`;
+        await this.storage.applyBatch([
+            { kind: "write", relativePath: stockPrepared.relativePath, content: stockPrepared.content },
+            { kind: "write", relativePath: currentFlow.relativePath, content: renderedFlow },
+        ]);
+        return {
+            project: this.projectName,
+            sourceFlow: {
+                title: currentFlow.title,
+                relativePath: currentFlow.relativePath,
+                permalink: currentFlow.permalink,
+            },
+            stock: {
+                title: stockTitle,
+                relativePath: stockPrepared.relativePath,
+                permalink: stockPrepared.permalink,
+            },
+            flowState: "promoted",
+        };
+    }
+    async prepareNoteContent(input) {
+        const directory = sanitizeRelativePath(input.directory ?? this.config.defaultDirectory);
+        const fileBase = sanitizeFileBase(input.title);
+        const fileName = `${fileBase}${MARKDOWN_EXTENSION}`;
+        const relativePath = directory.length > 0 ? `${directory}/${fileName}` : fileName;
+        const targetPath = path.resolve(this.root, relativePath);
+        if (!isInsideDirectory(this.root, targetPath)) {
+            throw new Error("invalid target path");
+        }
+        let operation = "created";
+        let existingFrontmatter = {};
+        try {
+            const current = await this.loadNote(relativePath);
+            existingFrontmatter = current.frontmatter;
+            operation = "updated";
+        }
+        catch {
+            // create new file
+        }
+        const date = nowDate();
+        const permalink = safeString(existingFrontmatter.permalink)
+            ?? (relativePath.endsWith(MARKDOWN_EXTENSION)
+                ? relativePath.slice(0, -MARKDOWN_EXTENSION.length)
+                : relativePath);
+        const patch = normalizeFrontmatterPatch(input.frontmatterPatch);
+        const patchTags = Array.isArray(patch.tags) ? safeStringArray(patch.tags) : undefined;
+        const nextTags = input.tags
+            ? input.tags.map((tag) => tag.trim()).filter((tag) => tag.length > 0)
+            : patchTags ?? safeStringArray(existingFrontmatter.tags);
+        const nextType = input.noteType
+            ?? safeString(patch.type)
+            ?? safeString(existingFrontmatter.type)
+            ?? "note";
+        const frontmatter = {
+            ...existingFrontmatter,
+            title: input.title,
+            type: nextType,
+            permalink,
+            tags: nextTags,
+            created: safeString(existingFrontmatter.created) ?? date,
+            updated: date,
+        };
+        for (const [key, value] of Object.entries(patch)) {
+            if (RESERVED_FRONTMATTER_KEYS.has(key)) {
+                continue;
+            }
+            frontmatter[key] = value;
+        }
+        const body = normalizeContent(input.content).trimEnd();
+        const content = `${buildFrontmatter(frontmatter)}\n\n${ensureTrailingNewline(body)}`;
+        return { relativePath, targetPath, content, permalink, operation, title: input.title };
+    }
+    async writeNote(input) {
+        await this.storage.ensureRoot();
+        const prepared = await this.prepareNoteContent(input);
+        await this.storage.writeFile(prepared.relativePath, prepared.content);
+        const saved = await this.loadNote(prepared.relativePath);
+        const notes = await this.loadProjectNotes();
+        const signals = this.qualitySignalsForNote(saved, notes);
+        return {
+            project: this.projectName,
+            operation: prepared.operation,
+            filePath: prepared.targetPath,
+            relativePath: prepared.relativePath,
+            title: prepared.title,
+            permalink: prepared.permalink,
+            serverUpdated: nowTimestamp(),
+            linkHealth: signals.linkHealth,
+            unresolvedWikiLinks: signals.unresolvedWikiLinks,
+            unresolvedLinkHints: signals.unresolvedLinkHints,
+            backlinkCount: signals.backlinkCount,
+            orphanWarning: signals.orphanWarning,
+            duplicateWarnings: signals.duplicateWarnings,
+            structureScore: signals.structureScore,
+            memoryContract: signals.memoryContract,
+            boundaryWarnings: signals.boundaryWarnings,
+        };
+    }
+    async appendNote(args) {
+        if (args.createIfMissing) {
+            await this.storage.ensureRoot();
+        }
+        const note = await this.resolveIdentifier(args.identifier);
+        if (!note) {
+            if (!args.createIfMissing) {
+                throw new Error(`note not found: ${args.identifier}`);
+            }
+            const created = await this.writeNote({
+                directory: args.directory,
+                title: inferTitleFromIdentifier(args.identifier),
+                content: normalizeContent(args.content).trimEnd(),
+                tags: args.tags,
+                noteType: args.noteType,
+            });
+            return {
+                project: created.project,
+                filePath: created.filePath,
+                relativePath: created.relativePath,
+                title: created.title,
+                permalink: created.permalink,
+                operation: "created",
+                serverUpdated: created.serverUpdated,
+                linkHealth: created.linkHealth,
+                unresolvedWikiLinks: created.unresolvedWikiLinks,
+                unresolvedLinkHints: created.unresolvedLinkHints,
+                backlinkCount: created.backlinkCount,
+                orphanWarning: created.orphanWarning,
+                duplicateWarnings: created.duplicateWarnings,
+                structureScore: created.structureScore,
+                memoryContract: created.memoryContract,
+                boundaryWarnings: created.boundaryWarnings,
+            };
+        }
+        const date = nowDate();
+        const nextBody = `${note.body.trimEnd()}\n\n${normalizeContent(args.content).trimEnd()}\n`;
+        const frontmatter = {
+            ...note.frontmatter,
+            title: note.title,
+            permalink: note.permalink,
+            created: note.created,
+            updated: date,
+        };
+        const rendered = `${buildFrontmatter(frontmatter)}\n\n${nextBody}`;
+        await this.storage.writeFile(note.relativePath, rendered);
+        const updated = await this.loadNote(note.relativePath);
+        const notes = await this.loadProjectNotes();
+        const signals = this.qualitySignalsForNote(updated, notes);
+        return {
+            project: this.projectName,
+            filePath: note.filePath,
+            relativePath: note.relativePath,
+            title: note.title,
+            permalink: note.permalink,
+            operation: "appended",
+            serverUpdated: nowTimestamp(),
+            linkHealth: signals.linkHealth,
+            unresolvedWikiLinks: signals.unresolvedWikiLinks,
+            unresolvedLinkHints: signals.unresolvedLinkHints,
+            backlinkCount: signals.backlinkCount,
+            orphanWarning: signals.orphanWarning,
+            duplicateWarnings: signals.duplicateWarnings,
+            structureScore: signals.structureScore,
+            memoryContract: signals.memoryContract,
+            boundaryWarnings: signals.boundaryWarnings,
+        };
+    }
+    async renameNote(args) {
+        const beforeNotes = await this.loadProjectNotes();
+        const projectLinkHealthBefore = this.projectLinkHealth(beforeNotes);
+        const note = await this.resolveIdentifier(args.identifier);
+        if (!note) {
+            throw new Error(`note not found: ${args.identifier}`);
+        }
+        const oldTitle = note.title;
+        const oldRelativePath = note.relativePath;
+        const oldPermalink = note.permalink;
+        const oldKeys = this.identifierKeys(note);
+        let nextDirectory = args.directory ? sanitizeRelativePath(args.directory) : path.posix.dirname(note.relativePath);
+        if (nextDirectory === ".") {
+            nextDirectory = "";
+        }
+        const newFileBase = sanitizeFileBase(args.newTitle);
+        const newRelativePath = nextDirectory.length > 0
+            ? `${nextDirectory}/${newFileBase}${MARKDOWN_EXTENSION}`
+            : `${newFileBase}${MARKDOWN_EXTENSION}`;
+        const newAbsolutePath = path.resolve(this.root, newRelativePath);
+        if (!isInsideDirectory(this.root, newAbsolutePath)) {
+            throw new Error("invalid rename path");
+        }
+        const samePath = oldRelativePath === newRelativePath;
+        if (!samePath) {
+            const targetStat = await this.storage.stat(newRelativePath);
+            if (targetStat.exists && targetStat.isFile) {
+                throw new Error(`target file already exists: ${newRelativePath}`);
+            }
+        }
+        const date = nowDate();
+        const newPermalink = newRelativePath.endsWith(MARKDOWN_EXTENSION)
+            ? newRelativePath.slice(0, -MARKDOWN_EXTENSION.length)
+            : newRelativePath;
+        const frontmatter = {
+            ...note.frontmatter,
+            title: args.newTitle,
+            permalink: newPermalink,
+            created: note.created,
+            updated: date,
+        };
+        const rewrittenTarget = `${buildFrontmatter(frontmatter)}\n\n${ensureTrailingNewline(note.body.trimEnd())}`;
+        const ops = [];
+        let finalTargetContent = rewrittenTarget;
+        let updatedFiles = 0;
+        let updatedLinks = 0;
+        if (!samePath) {
+            ops.push({ kind: "delete", relativePath: oldRelativePath });
+        }
+        if (args.updateLinks !== false) {
+            const oldKeyLowerSet = new Set(oldKeys.map((key) => key.toLowerCase()));
+            const oldKeyNormalizedSet = new Set(oldKeys.map((key) => normalizeLookup(key)));
+            const linkRewriter = (token) => {
+                const targetLower = token.targetBase.toLowerCase();
+                const targetNormalized = normalizeLookup(token.targetBase);
+                const matches = oldKeyLowerSet.has(targetLower)
+                    || (targetNormalized.length > 0 && oldKeyNormalizedSet.has(targetNormalized));
+                if (!matches) {
+                    return undefined;
+                }
+                return renderWikiLink(newPermalink, token.suffix, token.alias);
+            };
+            const targetLinkResult = rewriteWikiLinks(rewrittenTarget, linkRewriter);
+            finalTargetContent = targetLinkResult.text;
+            updatedLinks += targetLinkResult.replaced;
+            for (const source of beforeNotes) {
+                if (source.relativePath === oldRelativePath) {
+                    continue;
+                }
+                const rewritten = rewriteWikiLinks(source.raw, linkRewriter);
+                if (rewritten.replaced > 0) {
+                    ops.push({ kind: "write", relativePath: source.relativePath, content: rewritten.text });
+                    updatedFiles += 1;
+                    updatedLinks += rewritten.replaced;
+                }
+            }
+        }
+        ops.push({ kind: "write", relativePath: newRelativePath, content: finalTargetContent });
+        await this.storage.applyBatch(ops);
+        const afterNotes = await this.loadProjectNotes();
+        const projectLinkHealthAfter = this.projectLinkHealth(afterNotes);
+        const renamed = await this.loadNote(newRelativePath);
+        const signals = this.qualitySignalsForNote(renamed, afterNotes);
+        return {
+            project: this.projectName,
+            oldTitle,
+            newTitle: renamed.title,
+            oldRelativePath,
+            newRelativePath: renamed.relativePath,
+            oldPermalink,
+            newPermalink: renamed.permalink,
+            serverUpdated: nowTimestamp(),
+            updatedLinks,
+            updatedFiles,
+            renamedNoteLinkHealth: signals.linkHealth,
+            backlinkCount: signals.backlinkCount,
+            orphanWarning: signals.orphanWarning,
+            projectLinkHealthBefore,
+            projectLinkHealthAfter,
+            unresolvedWikiLinks: signals.unresolvedWikiLinks,
+            unresolvedLinkHints: signals.unresolvedLinkHints,
+            structureScore: signals.structureScore,
+            memoryContract: signals.memoryContract,
+        };
+    }
+    async deleteNote(args) {
+        const beforeNotes = await this.loadProjectNotes();
+        const projectLinkHealthBefore = this.projectLinkHealth(beforeNotes);
+        const note = await this.resolveIdentifier(args.identifier);
+        if (!note) {
+            throw new Error(`note not found: ${args.identifier}`);
+        }
+        const current = beforeNotes.find((item) => item.filePath === note.filePath) ?? note;
+        const signalsBeforeDelete = this.qualitySignalsForNote(current, beforeNotes);
+        await this.storage.deleteFile(current.relativePath);
+        const afterNotes = await this.loadProjectNotes();
+        const projectLinkHealthAfter = this.projectLinkHealth(afterNotes);
+        const projectSignalsAfter = this.projectUnresolvedSignals(afterNotes);
+        return {
+            project: this.projectName,
+            title: current.title,
+            relativePath: current.relativePath,
+            permalink: current.permalink,
+            serverUpdated: nowTimestamp(),
+            backlinksToDeleted: signalsBeforeDelete.backlinkCount,
+            deletedNoteLinkHealth: signalsBeforeDelete.linkHealth,
+            projectLinkHealthBefore,
+            projectLinkHealthAfter,
+            unresolvedWikiLinks: projectSignalsAfter.unresolvedWikiLinks,
+            unresolvedLinkHints: projectSignalsAfter.unresolvedLinkHints,
+            structureScoreBeforeDelete: signalsBeforeDelete.structureScore,
+            memoryContractBeforeDelete: signalsBeforeDelete.memoryContract,
+        };
+    }
+}