@aitne/daemon 0.1.0

package/dist/core/management-md.js

@@ -0,0 +1,652 @@
+import { existsSync, renameSync } from "node:fs";
+import { mkdir, readFile, writeFile, stat } from "node:fs/promises";
+import { dirname, resolve } from "node:path";
+import * as chokidar from "chokidar";
+import { INTEGRATION_DESCRIPTORS, INTEGRATION_KEYS, integrationPatchSchema, isIntegrationKey, } from "@aitne/shared";
+import { readIntegrations, writeIntegrations, } from "../db/integrations-store.js";
+import { missingDelegatedVariants } from "./skills-compiler.js";
+import { createLogger } from "../logging.js";
+const logger = createLogger("management-md");
+const FILE_NAME = "integrations.md";
+const LEGACY_FILE_NAME = "management.md";
+/**
+ * Integration Delegation Framework — `integrations.md` render + parse + watch
+ * (Phase 1).
+ *
+ * `integrations.md` lives at `<dataDir>/integrations.md` (top-level, alongside
+ * `.env` and `data.db`). It is the human-editable view of the integrations
+ * map; the DB (`settings` table, key `"integrations"`) is the authoritative
+ * source for the daemon.
+ *
+ * Write paths:
+ *   - `PATCH /api/integrations/:key` → DB update → `renderManagementMd()`
+ *     rewrites the file.
+ *   - User hand-edits → chokidar fires → `parseManagementMd()` → DB update.
+ *
+ * Self-write suppression: every file write through `writeManagementMd()`
+ * stamps the absolute path in a module-scoped Set cleared on the next tick.
+ * The watcher checks this before re-parsing, so the PATCH-then-rewrite
+ * flow doesn't loop back into itself.
+ *
+ * The file is fully idempotent: booting re-renders it from the DB state
+ * unconditionally, so hand-edits that round-trip cleanly through the
+ * parser produce identical bytes on the next render (no churn).
+ */
+export function getManagementMdPath(dataDir) {
+    return resolve(dataDir, FILE_NAME);
+}
+export function getLegacyManagementMdPath(dataDir) {
+    return resolve(dataDir, LEGACY_FILE_NAME);
+}
+/**
+ * One-shot compatibility migration for installs that predate the
+ * `integrations.md` rename. If both files exist, keep `integrations.md` as
+ * authoritative and leave the legacy file untouched for manual inspection.
+ */
+export function migrateLegacyManagementMd(dataDir) {
+    const from = getLegacyManagementMdPath(dataDir);
+    const to = getManagementMdPath(dataDir);
+    if (existsSync(to)) {
+        if (existsSync(from)) {
+            // `integrations.md` wins by design; the user probably migrated the
+            // file manually. Surface a one-time warning so the orphaned legacy
+            // file is visible (otherwise it sits in dataDir silently forever).
+            logger.warn({ legacyPath: from, currentPath: to }, "legacy management.md remains alongside integrations.md — delete the legacy file manually if no longer needed");
+        }
+        return { migrated: false, from, to, reason: "target_exists" };
+    }
+    if (!existsSync(from)) {
+        return { migrated: false, from, to, reason: "legacy_missing" };
+    }
+    renameSync(from, to);
+    logger.info({ from, to }, "legacy management.md migrated to integrations.md");
+    return { migrated: true, from, to };
+}
+const pendingSelfWrites = new Set();
+function markSelfWrite(absPath) {
+    pendingSelfWrites.add(absPath);
+    // Clear on next tick so a round-trip through chokidar (which debounces)
+    // doesn't hang onto the mark indefinitely. Chokidar's default
+    // `awaitWriteFinish` settles within a few hundred ms; a 5s window is
+    // generous without being open-ended.
+    setTimeout(() => pendingSelfWrites.delete(absPath), 5000).unref();
+}
+function consumeSelfWrite(absPath) {
+    return pendingSelfWrites.delete(absPath);
+}
+// ── Render ─────────────────────────────────────────────────────────────────
+// Ownership note: this frontmatter emits `owner: daemon`. The file is a
+// daemon-rendered snapshot of `settings.integrations_json`; the Dashboard
+// (Settings → Connections) is the canonical edit surface. Hand-edits are
+// still parsed by chokidar as a break-glass path for resilience, but the
+// file is not advertised as user-editable. See §14.3 of
+// docs/design/14-integration-delegation.md.
+const FRONTMATTER = `---
+file: integrations.md
+purpose: per-integration access-mode configuration
+owner: daemon
+schema_version: 1
+---
+`;
+const MODES_SECTION = `## Modes
+
+- **direct** — daemon holds credentials and polls; full feature set; setup required.
+- **delegated** — no daemon credentials; backend connector is the access path; reduced features; zero setup.
+- **disabled** — integration off.
+`;
+function renderCurrentStateTable(integrations) {
+    const rows = [
+        "| Integration | Mode | Backend | Sub-tier | Last changed |",
+        "|---|---|---|---|---|",
+    ];
+    for (const key of INTEGRATION_KEYS) {
+        const state = integrations[key];
+        const backend = state.delegatedBackend ?? "—";
+        const subTier = renderSubTier(key, state);
+        rows.push(`| ${key} | ${state.mode} | ${backend} | ${subTier} | ${state.lastChangedAt} |`);
+    }
+    return `## Current state\n\n${rows.join("\n")}\n`;
+}
+function renderSubTier(key, state) {
+    if (state.mode !== "delegated" || !state.delegatedBackend)
+        return "—";
+    // Per §4.6.1: Claude Code Gmail = Draft-Only, Codex Gmail = Full-Auto.
+    // Calendar is close to parity on both backends.
+    if (key === "gmail") {
+        if (state.delegatedBackend === "claude")
+            return "draft-only";
+        if (state.delegatedBackend === "codex")
+            return "full-auto";
+    }
+    return "full";
+}
+function renderActiveTodaySection(integrations) {
+    const active = INTEGRATION_KEYS.filter((k) => integrations[k].mode !== "disabled");
+    if (active.length === 0) {
+        return `## Active today\n\n_No integrations active._\n`;
+    }
+    return `## Active today\n\n${active.map((k) => `- \`${k}\``).join("\n")}\n`;
+}
+export function renderNoteSourcesSection(integrations, notes) {
+    const obsidianLine = notes.externalObsidianVaultPath
+        ? `${notes.externalObsidianVaultPath}${notes.externalObsidianWatch ? "" : " (watching disabled)"}`
+        : "—";
+    const notion = integrations.notion;
+    let notionLine;
+    if (notion.mode === "disabled") {
+        notionLine = "disabled";
+    }
+    else if (notion.mode === "delegated" && notion.delegatedBackend) {
+        notionLine = `enabled (delegated via ${notion.delegatedBackend})`;
+    }
+    else {
+        notionLine = "enabled (direct)";
+    }
+    return [
+        "## Note Sources",
+        "",
+        "<!-- Auto-generated. Edit settings via Dashboard → Settings → Note. Hand-edits are overwritten on next render. -->",
+        `- Obsidian vault (personal): ${obsidianLine}`,
+        `- Notion: ${notionLine}`,
+        "",
+    ].join("\n");
+}
+const PLANNED_SECTION = `## Planned / not yet shipped
+
+- \`google_drive\`
+- \`slack\`
+`;
+function renderConnectorSupportTable() {
+    const rows = [
+        "| Integration | Direct | Claude Code | Codex | Gemini CLI |",
+        "|---|:---:|:---:|:---:|:---:|",
+    ];
+    for (const key of INTEGRATION_KEYS) {
+        const desc = INTEGRATION_DESCRIPTORS[key];
+        const directCell = desc.directSetup ? "✅" : "—";
+        const claudeCell = renderConnectorCell(desc.backendConnectors.claude, key, "claude");
+        const codexCell = renderConnectorCell(desc.backendConnectors.codex, key, "codex");
+        const geminiCell = renderConnectorCell(desc.backendConnectors.gemini, key, "gemini");
+        rows.push(`| ${key} | ${directCell} | ${claudeCell} | ${codexCell} | ${geminiCell} |`);
+    }
+    return `## Per-backend connector support (read-only snapshot, rendered by daemon)\n\n${rows.join("\n")}\n`;
+}
+function renderConnectorCell(connector, integrationKey, backend) {
+    if (!connector)
+        return backend === "gemini" ? "🕓 unverified" : "—";
+    if (integrationKey === "gmail" && backend === "claude") {
+        return "⚠️ draft-only";
+    }
+    return "✅";
+}
+function renderToolDenySection(integrations) {
+    // §7.7 — render the per-integration deny list. Skip integrations with
+    // an empty list so the section stays compact. The header always renders
+    // (even when every integration is empty) so users / round-trip parsers
+    // know the section exists.
+    const blocks = [];
+    for (const key of INTEGRATION_KEYS) {
+        const denied = integrations[key].deniedTools ?? [];
+        if (denied.length === 0)
+            continue;
+        const lines = [`### ${key}`, ""];
+        for (const tool of denied) {
+            lines.push(`- \`${tool}\``);
+        }
+        lines.push("");
+        blocks.push(lines.join("\n"));
+    }
+    const header = "## Tool deny policy (§7.7)\n\n" +
+        "Per-tool deny list, materialized into the delegated skill body. Hard\n" +
+        "enforcement on Claude (`allowed-tools` frontmatter is filtered); soft\n" +
+        "enforcement on Codex / Gemini (a \"Denied tools (do not invoke)\" prose\n" +
+        "block is appended to the skill body). Edit via the dashboard's Tool\n" +
+        "Permissions card under each integration.\n\n";
+    if (blocks.length === 0) {
+        return header + "_No tools denied._\n";
+    }
+    return header + blocks.join("\n");
+}
+export function renderManagementMd(integrations, notes = {
+    externalObsidianVaultPath: null,
+    externalObsidianWatch: true,
+}) {
+    return [
+        FRONTMATTER,
+        "# Integration Management\n",
+        MODES_SECTION,
+        renderCurrentStateTable(integrations),
+        renderActiveTodaySection(integrations),
+        renderNoteSourcesSection(integrations, notes),
+        PLANNED_SECTION,
+        renderConnectorSupportTable(),
+        renderToolDenySection(integrations),
+    ].join("\n");
+}
+/**
+ * Parse the "Current state" table from an `integrations.md` body. Free prose,
+ * `Modes`, `Active today`, `Planned`, and the connector-support snapshot are
+ * all ignored — the Current-state table is authoritative. `Last changed` is
+ * written by the daemon; user edits to that column are tolerated and
+ * preserved only when valid ISO-8601.
+ */
+export function parseManagementMd(body) {
+    const warnings = [];
+    const errors = [];
+    const integrations = {};
+    const currentStateRows = extractCurrentStateRows(body);
+    if (currentStateRows === null) {
+        errors.push("missing or malformed 'Current state' table");
+        return { ok: false, integrations, warnings, errors };
+    }
+    // §7.7 — extract the per-integration deny list once; merge into rows below.
+    // Unknown integrations are warned, not fatal (schema-admin lock-down is a
+    // soft policy — a malformed deny block must not block the whole file).
+    const denyByKey = extractToolDenyBlocks(body, warnings);
+    for (const row of currentStateRows) {
+        if (!isIntegrationKey(row.key)) {
+            warnings.push(`unknown integration key: ${row.key}`);
+            continue;
+        }
+        const mode = row.mode;
+        const backendCell = row.backend === "—" || row.backend === "" ? undefined : row.backend;
+        const patch = integrationPatchSchema.safeParse({
+            mode,
+            delegatedBackend: backendCell,
+        });
+        if (!patch.success) {
+            errors.push(`integration ${row.key}: ${patch.error.issues
+                .map((i) => i.message)
+                .join("; ")}`);
+            continue;
+        }
+        const lastChanged = isIsoDate(row.lastChanged)
+            ? row.lastChanged
+            : new Date().toISOString();
+        integrations[row.key] = {
+            mode: patch.data.mode,
+            ...(patch.data.delegatedBackend
+                ? { delegatedBackend: patch.data.delegatedBackend }
+                : {}),
+            deniedTools: denyByKey[row.key] ?? [],
+            lastChangedAt: lastChanged,
+        };
+    }
+    return { ok: errors.length === 0, integrations, warnings, errors };
+}
+/**
+ * Walk the rendered body for `### <integration-key>` blocks under the
+ * `## Tool deny policy` section. Each block lists denied tool names as
+ * backtick-wrapped bullets; we strip backticks and return a per-integration
+ * map. The watcher uses this to round-trip hand-edits without losing the
+ * deny list.
+ */
+function extractToolDenyBlocks(body, warnings) {
+    const out = {};
+    const lines = body.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length && !/^##\s+Tool deny policy/i.test(lines[i])) {
+        i++;
+    }
+    if (i >= lines.length)
+        return out;
+    i++;
+    let currentKey = null;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (/^##\s+/.test(line))
+            break; // next h2 → leave the deny section
+        const subHeader = /^###\s+(\S+)/.exec(line);
+        if (subHeader) {
+            const key = subHeader[1];
+            if (isIntegrationKey(key)) {
+                currentKey = key;
+                out[currentKey] = [];
+            }
+            else {
+                warnings.push(`unknown integration key in tool deny section: ${key}`);
+                currentKey = null;
+            }
+            i++;
+            continue;
+        }
+        if (currentKey) {
+            const bullet = /^\s*-\s+`?([^`\s]+)`?/.exec(line);
+            if (bullet) {
+                out[currentKey].push(bullet[1]);
+            }
+        }
+        i++;
+    }
+    return out;
+}
+function extractCurrentStateRows(body) {
+    // Find the "## Current state" section and walk forward to the first
+    // pipe-delimited table. Markdown tables have a separator line (`|---|...`)
+    // that we skip.
+    const lines = body.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length && !/^##\s+Current state\s*$/i.test(lines[i])) {
+        i++;
+    }
+    if (i >= lines.length)
+        return null;
+    // Skip blank lines, then expect a table header.
+    i++;
+    while (i < lines.length && lines[i].trim() === "")
+        i++;
+    if (i >= lines.length || !lines[i].trim().startsWith("|"))
+        return null;
+    // Consume header + separator.
+    i += 2;
+    const rows = [];
+    while (i < lines.length) {
+        const line = lines[i].trim();
+        if (line === "" || !line.startsWith("|"))
+            break;
+        const cells = line
+            .split("|")
+            .slice(1, -1)
+            .map((c) => c.trim());
+        if (cells.length < 5) {
+            i++;
+            continue;
+        }
+        rows.push({
+            key: cells[0],
+            mode: cells[1],
+            backend: cells[2],
+            // cells[3] is sub-tier — rendered-only, ignored by parser
+            lastChanged: cells[4],
+        });
+        i++;
+    }
+    return rows;
+}
+function isIsoDate(value) {
+    if (!value)
+        return false;
+    const d = new Date(value);
+    return !Number.isNaN(d.getTime()) && value.includes("T");
+}
+// ── File I/O ───────────────────────────────────────────────────────────────
+/**
+ * Write the rendered body to disk, creating parent directories if needed.
+ * Stamps the path as a self-write so the watcher skips the resulting event.
+ *
+ * `notes` is optional for backward compatibility — callers that have not
+ * yet been wired to surface external-vault state pass nothing and the
+ * section renders the "—" placeholder. The dashboard config PATCH
+ * handler is wired (SETUP-FLOW-REDESIGN-PLAN §6.2) so any user edit
+ * round-trips through the proper inputs.
+ */
+export async function writeManagementMd(dataDir, integrations, notes) {
+    const path = getManagementMdPath(dataDir);
+    await mkdir(dirname(path), { recursive: true });
+    const body = renderManagementMd(integrations, notes);
+    markSelfWrite(path);
+    await writeFile(path, body, "utf-8");
+    return path;
+}
+/**
+ * Read + parse the file from disk. Returns `null` when the file does not
+ * exist — callers treat that as "first run, write defaults and move on".
+ */
+export async function readAndParseManagementMd(dataDir) {
+    const path = getManagementMdPath(dataDir);
+    try {
+        const body = await readFile(path, "utf-8");
+        return parseManagementMd(body);
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return null;
+        throw err;
+    }
+}
+/**
+ * First-start reconciliation:
+ *   1. If the file is missing → render it from the DB and return.
+ *   2. If the file is present and parses clean → merge user-visible fields
+ *      (mode + delegatedBackend) back into the DB. Any delegated flip
+ *      whose required variant files are missing is reverted per
+ *      `enforceVariantAvailability` (§4.7 symmetry with the PATCH edge).
+ *      Then re-render so daemon-owned columns (lastChanged adjustments,
+ *      reverted rows) round-trip cleanly.
+ *   3. If parse fails → log, leave the DB alone, re-render from DB so the
+ *      file moves back to a known-good state. The owner-DM branch is
+ *      Phase 2+; for now we only log.
+ */
+export async function bootstrapManagementMd(dataDir, db, workspaceDir, notes) {
+    // Callers are responsible for invoking `migrateLegacyManagementMd`
+    // before `bootstrapManagementMd` so any legacy file has already been
+    // renamed to `integrations.md` before we touch it. See index.ts.
+    const path = getManagementMdPath(dataDir);
+    const dbState = readIntegrations(db);
+    let fileExists = true;
+    try {
+        await stat(path);
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            fileExists = false;
+        }
+        else {
+            throw err;
+        }
+    }
+    if (!fileExists) {
+        await writeManagementMd(dataDir, dbState, notes);
+        logger.info({ path }, "integrations.md created with default integrations map");
+        return { path, created: true, integrations: dbState, rejections: [] };
+    }
+    const parsed = await readAndParseManagementMd(dataDir);
+    if (!parsed || !parsed.ok) {
+        logger.warn({ path, errors: parsed?.errors, warnings: parsed?.warnings }, "integrations.md did not parse cleanly; re-rendering from DB");
+        await writeManagementMd(dataDir, dbState, notes);
+        return { path, created: false, integrations: dbState, rejections: [] };
+    }
+    const merged = mergeParsedIntoDb(dbState, parsed.integrations);
+    // `workspaceDir` is optional so older integration tests that only care
+    // about parse/render behavior keep passing; pre-existing startup code
+    // threads the real value through. When absent, the missing-variant
+    // guard is a no-op — equivalent to pre-follow-up behavior.
+    const { filtered, rejections } = workspaceDir
+        ? enforceVariantAvailability(merged, dbState, workspaceDir)
+        : { filtered: merged, rejections: [] };
+    if (rejections.length > 0) {
+        logger.warn({ path, rejections }, "integrations.md: delegated flip(s) reverted — required variant files missing");
+    }
+    if (changed(dbState, filtered)) {
+        writeIntegrations(db, filtered);
+        logger.info({ path, changedKeys: diffKeys(dbState, filtered) }, "applied integrations.md edits to DB on boot");
+    }
+    // Always re-render so daemon-owned columns are canonical — and so any
+    // reverted rows are visibly corrected in the file even when the user
+    // doesn't re-edit.
+    await writeManagementMd(dataDir, filtered, notes);
+    if (parsed.warnings.length > 0) {
+        logger.warn({ warnings: parsed.warnings }, "integrations.md boot warnings");
+    }
+    return { path, created: false, integrations: filtered, rejections };
+}
+function mergeParsedIntoDb(dbState, parsed) {
+    const merged = { ...dbState };
+    for (const key of INTEGRATION_KEYS) {
+        const next = parsed[key];
+        if (!next)
+            continue;
+        const prev = dbState[key];
+        const semanticChange = prev.mode !== next.mode ||
+            (prev.delegatedBackend ?? undefined) !==
+                (next.delegatedBackend ?? undefined);
+        if (semanticChange) {
+            merged[key] = {
+                ...next,
+                lastChangedAt: new Date().toISOString(),
+            };
+        }
+    }
+    return merged;
+}
+/**
+ * §4.7 "Missing-variant policy" enforcement on the integrations.md side.
+ *
+ * For every delegated flip introduced by the merge, verify the target
+ * backend's skill + task-flow variants exist on disk. Any key with a
+ * missing variant is reverted to its previous DB state; accepted keys
+ * pass through untouched. The returned `rejections` list lets the caller
+ * log / DM / re-render to surface the rollback.
+ *
+ * This mirrors the 400 `missing_variants` response on
+ * `PATCH /api/integrations/:key` — both the API edge and the file-edit
+ * edge now refuse to commit a delegated state the agent would silently
+ * fall back out of.
+ */
+export function enforceVariantAvailability(merged, dbState, workspaceDir) {
+    const filtered = { ...merged };
+    const rejections = [];
+    for (const key of INTEGRATION_KEYS) {
+        const next = merged[key];
+        const prev = dbState[key];
+        if (next.mode !== "delegated" || !next.delegatedBackend)
+            continue;
+        // DELEGATED-MODE-V2-DESIGN.md §11 (Phase 3) re-activated the variant
+        // gate for every delegated integration: gmail and google_calendar
+        // now ship `SKILL.delegated.<sessionBackend>.md` variants
+        // (cross-backend) plus the `null` resolution for same-backend.
+        // Only validate when this edit introduces a new delegated target. A
+        // key that was already delegated to the same backend pre-merge has
+        // presumably already cleared the check once (either via PATCH or a
+        // prior boot); re-running it here would surface transient file churn
+        // every time a user edited an unrelated row.
+        const semanticallyNew = prev.mode !== next.mode ||
+            (prev.delegatedBackend ?? null) !== (next.delegatedBackend ?? null);
+        if (!semanticallyNew)
+            continue;
+        const missing = missingDelegatedVariants(workspaceDir, key, next.delegatedBackend);
+        const paths = [...missing.skills, ...missing.taskFlows];
+        if (paths.length === 0)
+            continue;
+        filtered[key] = prev;
+        rejections.push({ key, backend: next.delegatedBackend, missing: paths });
+    }
+    return { filtered, rejections };
+}
+function changed(a, b) {
+    for (const key of INTEGRATION_KEYS) {
+        if (a[key].mode !== b[key].mode ||
+            (a[key].delegatedBackend ?? undefined) !==
+                (b[key].delegatedBackend ?? undefined)) {
+            return true;
+        }
+    }
+    return false;
+}
+function diffKeys(a, b) {
+    return INTEGRATION_KEYS.filter((key) => a[key].mode !== b[key].mode ||
+        (a[key].delegatedBackend ?? undefined) !==
+            (b[key].delegatedBackend ?? undefined));
+}
+/**
+ * Watch `integrations.md` for out-of-band edits and reconcile them into the
+ * DB. Self-writes stamped via `writeManagementMd()` are ignored; bad parses
+ * trigger a rewrite from the DB state.
+ *
+ * §4.7 symmetry: delegated flips whose skill or task-flow variant files
+ * are absent on disk are reverted to the previous DB state, the file is
+ * re-rendered to show the rollback, and (if `sendNotification` is wired)
+ * the owner gets a DM explaining which files need to be authored.
+ */
+export function startManagementMdWatcher(dataDir, db, options = {}) {
+    const path = getManagementMdPath(dataDir);
+    const watcher = chokidar.watch(path, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100,
+        },
+    });
+    const handle = async (reason) => {
+        if (consumeSelfWrite(path)) {
+            logger.debug({ path, reason }, "integrations.md: self-write ignored");
+            return;
+        }
+        try {
+            const parsed = await readAndParseManagementMd(dataDir);
+            if (!parsed)
+                return;
+            if (!parsed.ok) {
+                logger.warn({ path, errors: parsed.errors, warnings: parsed.warnings }, "integrations.md parse failed — rewriting from DB");
+                const dbState = readIntegrations(db);
+                await writeManagementMd(dataDir, dbState, options.getNoteSources?.());
+                return;
+            }
+            const dbState = readIntegrations(db);
+            const merged = mergeParsedIntoDb(dbState, parsed.integrations);
+            const { filtered, rejections } = options.workspaceDir
+                ? enforceVariantAvailability(merged, dbState, options.workspaceDir)
+                : { filtered: merged, rejections: [] };
+            if (rejections.length > 0) {
+                logger.warn({ path, rejections, reason }, "integrations.md: delegated flip(s) reverted — required variant files missing");
+                if (options.sendNotification) {
+                    try {
+                        await options.sendNotification({
+                            message: buildRevertDm(rejections),
+                            notificationType: "integration.variant_missing",
+                            priority: "normal",
+                        });
+                    }
+                    catch (err) {
+                        logger.warn({ err, rejections }, "integrations.md: failed to DM owner about variant-missing revert");
+                    }
+                }
+            }
+            if (changed(dbState, filtered)) {
+                writeIntegrations(db, filtered);
+                logger.info({ path, changedKeys: diffKeys(dbState, filtered), reason }, "integrations.md edit applied to DB");
+                // Re-render so timestamps the parser stamped with `now` become
+                // the canonical serialized form.
+                await writeManagementMd(dataDir, filtered, options.getNoteSources?.());
+            }
+            else if (rejections.length > 0) {
+                // The only change was a rejected delegated flip — filtered
+                // equals dbState, so no DB write, but we still want the file to
+                // visibly reflect the reverted state (otherwise the user's edit
+                // would appear to "stick" on disk).
+                await writeManagementMd(dataDir, filtered, options.getNoteSources?.());
+            }
+            else if (parsed.warnings.length > 0) {
+                logger.warn({ warnings: parsed.warnings }, "integrations.md: semantic-equivalent edit with warnings");
+            }
+        }
+        catch (err) {
+            logger.error({ err, path }, "integrations.md watcher handler error");
+        }
+    };
+    watcher.on("change", () => void handle("change"));
+    watcher.on("add", () => void handle("add"));
+    watcher.on("error", (err) => logger.error({ err }, "integrations.md watcher error"));
+    logger.info({ path }, "integrations.md watcher started");
+    return {
+        async stop() {
+            await watcher.close();
+            logger.info({ path }, "integrations.md watcher stopped");
+        },
+    };
+}
+function buildRevertDm(rejections) {
+    const lines = [
+        `integrations.md: reverted ${rejections.length} delegated flip(s) — required variant file(s) missing:`,
+    ];
+    for (const r of rejections) {
+        lines.push(`• ${r.key} → ${r.backend}: ${r.missing.length} file(s)`);
+        for (const p of r.missing) {
+            lines.push(`    ${p}`);
+        }
+    }
+    lines.push("Author these variants (or narrow the registry's skillsTouched / taskFlowsTouched) before retrying.");
+    return lines.join("\n");
+}
+//# sourceMappingURL=management-md.js.map