@ouro.bot/cli 0.1.0-alpha.62 → 0.1.0-alpha.637

package/dist/heart/daemon/migrate-to-desk.js

@@ -0,0 +1,848 @@
+"use strict";
+/**
+ * `ouro migrate-to-desk` migrator.
+ *
+ * Reads `<bundle>/tasks/**` recursively, classifies each file per the
+ * shared triage rules (see `src/repertoire/desk/classifier.ts`), and writes
+ * the result into `<bundle>/desk/` in the new desk shape:
+ *
+ *   - terminal / stale_live / ambiguous → `desk/_archive/<original-relative-path>`
+ *   - live_clear → `desk/legacy/<slug>/{task.md, iterations/...}`
+ *   - special_europe_trip → `desk/summer-2026-europe-trip/` (full lift)
+ *   - track-level `track.md` for `legacy`
+ *   - migration log at `desk/_meta/migration-2026-05-22.log`
+ *
+ * **COPY semantics, not move.** The source `tasks/` tree is left intact for
+ * dual-read safety. The operator triggers final deletion in a later step
+ * (out of scope here).
+ *
+ * **Idempotency.** A second run aborts cleanly unless `--force` is passed.
+ * With `--force`, destructive scope is bounded to migrator-owned dirs:
+ * `desk/_archive/`, `desk/legacy/`, `desk/summer-2026-europe-trip/`,
+ * `desk/_meta/featured.md`, `desk/_meta/migration-2026-05-22.log`.
+ * Nothing else under `desk/` is touched.
+ *
+ * **Dry-run.** `--dry-run` writes the summary to stdout and modifies nothing.
+ *
+ * **Slug derivation + pairing.** Paired planning/doing/ideation files
+ * sharing a slug collapse into a single task with iterations. The migrator
+ * groups by `deriveTaskSlug()` (which strips date prefixes and role infix).
+ * If any sibling is terminal → all siblings terminal. Else if any is
+ * live_clear → all live_clear.
+ *
+ * **Europe-trip fallback.** If a `europe-trip-lift-plan.md` is not embedded
+ * here, we use minimal stub content for the two tasks and the track
+ * `track.md`. The operator can flesh out the content in a follow-up.
+ *
+ * The CLI surface: `ouro migrate-to-desk --agent <name> [--root <path>]
+ * [--force] [--dry-run]`. The `--root` flag overrides the bundle root
+ * (defaults to `<bundlesRoot>/<agent>.ouro`). Used by Units 12 + 13 to
+ * point at `/tmp/<bundle>-latest/`.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMigrateToDesk = runMigrateToDesk;
+exports.ensureSchemaVersion = ensureSchemaVersion;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const runtime_1 = require("../../nerves/runtime");
+const classifier_1 = require("../../repertoire/desk/classifier");
+// ── Constants ──
+const LEGACY_TRACK_NAME = "legacy";
+const EUROPE_TRIP_TRACK_NAME = "summer-2026-europe-trip";
+const EUROPE_TRIP_TASK_OUTBOUND = "book-replacement-outbound";
+const EUROPE_TRIP_TASK_WEEKLY = "weekly-trip-check";
+const MIGRATION_LOG_BASENAME = "migration-2026-05-22.log";
+const SCHEMA_VERSION = 1;
+const DEFAULT_CUTOFF_DAYS = 30;
+const MIGRATOR_OWNED_DIRS = ["_archive", LEGACY_TRACK_NAME, EUROPE_TRIP_TRACK_NAME];
+const MIGRATOR_OWNED_META_FILES = ["featured.md", MIGRATION_LOG_BASENAME];
+// ── Public entry point ──
+async function runMigrateToDesk(opts) {
+    const bundleRoot = opts.root ?? path.join(opts.bundlesRoot, `${opts.agent}.ouro`);
+    const tasksRoot = path.join(bundleRoot, "tasks");
+    const deskRoot = path.join(bundleRoot, "desk");
+    const metaDir = path.join(deskRoot, "_meta");
+    const logPath = path.join(metaDir, MIGRATION_LOG_BASENAME);
+    const today = opts.today ?? new Date(Date.UTC(2026, 4, 22));
+    const cutoffMs = opts.cutoffMs ?? today.getTime() - DEFAULT_CUTOFF_DAYS * 24 * 3600 * 1000;
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.migrate_to_desk_start",
+        message: `migrate-to-desk started for ${opts.agent}`,
+        meta: {
+            agent: opts.agent,
+            root: bundleRoot,
+            force: Boolean(opts.force),
+            dryRun: Boolean(opts.dryRun),
+        },
+    });
+    // Missing-bundle handling.
+    if (!fs.existsSync(tasksRoot)) {
+        const summary = `migrate-to-desk: no tasks/ directory at ${tasksRoot} — nothing to migrate`;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.migrate_to_desk_no_source",
+            message: summary,
+            meta: { agent: opts.agent, root: bundleRoot },
+        });
+        return {
+            performed: false,
+            summary,
+            counts: emptyCounts(),
+            logPath,
+        };
+    }
+    // Idempotency check.
+    if (fs.existsSync(logPath) && !opts.force) {
+        const summary = `migrate-to-desk: migration log already exists at ${logPath}; ` +
+            `pass --force to re-run (scope limited to migrator-owned dirs).`;
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.migrate_to_desk_aborted_existing",
+            message: summary,
+            meta: { agent: opts.agent, logPath },
+        });
+        return {
+            performed: false,
+            summary,
+            counts: emptyCounts(),
+            logPath,
+            abortedExisting: true,
+        };
+    }
+    // Discover + classify.
+    const allFiles = walkTasks(tasksRoot);
+    const classifications = classifyAll(allFiles, tasksRoot, cutoffMs);
+    const grouped = applyPairingRules(classifications);
+    // Build the migration plan.
+    const plan = buildPlan(grouped, deskRoot);
+    const counts = countBuckets(grouped);
+    if (opts.dryRun) {
+        const summary = renderDryRunSummary(plan, counts, deskRoot, logPath);
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.migrate_to_desk_dry_run",
+            message: "migrate-to-desk dry-run complete",
+            meta: { agent: opts.agent, counts },
+        });
+        return { performed: false, summary, counts, logPath };
+    }
+    // Force scope: clean migrator-owned dirs only.
+    if (opts.force) {
+        clearMigratorOwnedDirs(deskRoot);
+    }
+    // Ensure desk dirs exist.
+    fs.mkdirSync(metaDir, { recursive: true });
+    // Apply the plan.
+    for (const action of plan) {
+        applyPlanAction(action);
+    }
+    // Write the track.md for the legacy track if any live_clear tasks landed.
+    const hasLegacyTasks = plan.some((a) => a.kind === "write_task" && a.outputPath.startsWith(path.join(deskRoot, LEGACY_TRACK_NAME) + path.sep));
+    if (hasLegacyTasks) {
+        const legacyTrackMd = path.join(deskRoot, LEGACY_TRACK_NAME, "track.md");
+        fs.mkdirSync(path.dirname(legacyTrackMd), { recursive: true });
+        fs.writeFileSync(legacyTrackMd, renderLegacyTrackMd(today), "utf-8");
+    }
+    // Europe-trip lift: write the track + tasks + featured pointer.
+    const hasEuropeTrip = plan.some((a) => a.kind === "europe_trip");
+    if (hasEuropeTrip) {
+        writeEuropeTripScaffold(deskRoot, today);
+        fs.writeFileSync(path.join(metaDir, "featured.md"), `${EUROPE_TRIP_TRACK_NAME}\n`, "utf-8");
+    }
+    // Write the migration log.
+    const logLines = renderLogLines(grouped, plan, today);
+    fs.writeFileSync(logPath, logLines.join("\n") + "\n", "utf-8");
+    const summary = renderPerformedSummary(counts, deskRoot, logPath);
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.migrate_to_desk_complete",
+        message: "migrate-to-desk complete",
+        meta: { agent: opts.agent, counts, logPath },
+    });
+    return { performed: true, summary, counts, logPath };
+}
+function walkTasks(tasksRoot) {
+    const out = [];
+    walk(tasksRoot, "", out);
+    return out;
+}
+function walk(root, rel, out) {
+    const dir = rel ? path.join(root, rel) : root;
+    let entries;
+    try {
+        entries = fs.readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        /* v8 ignore start -- defensive: walk into a missing/permission-denied subdir; tasksRoot existence checked at entry @preserve */
+        return;
+        /* v8 ignore stop */
+    }
+    for (const entry of entries) {
+        const childRel = rel ? path.join(rel, entry.name) : entry.name;
+        const childAbs = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(root, childRel, out);
+            continue;
+        }
+        /* v8 ignore start -- defensive: entry is neither directory nor file (socket, FIFO, etc.); skip silently. Not reachable from synthetic fixture bundles, but defends against pathological filesystems. @preserve */
+        if (!entry.isFile())
+            continue;
+        /* v8 ignore stop */
+        let mtimeMs = Date.now();
+        try {
+            mtimeMs = fs.statSync(childAbs).mtimeMs;
+        }
+        catch {
+            /* v8 ignore start -- defensive: stat failure on a file we just listed; fallback to now() @preserve */
+            mtimeMs = Date.now();
+            /* v8 ignore stop */
+        }
+        out.push({ relPath: normalizeRelPath(childRel), absPath: childAbs, mtimeMs });
+    }
+}
+function normalizeRelPath(p) {
+    return p.split(path.sep).join("/");
+}
+function classifyAll(files, tasksRoot, cutoffMs) {
+    const out = [];
+    for (const file of files) {
+        let content = "";
+        try {
+            content = fs.readFileSync(file.absPath, "utf-8");
+        }
+        catch {
+            /* v8 ignore start -- defensive: read failure on a file walk just enumerated; treated as ambiguous @preserve */
+            content = "";
+            /* v8 ignore stop */
+        }
+        const result = (0, classifier_1.classifyFile)({
+            relPath: file.relPath,
+            content,
+            mtimeMs: file.mtimeMs,
+            cutoffMs,
+        });
+        out.push({ ...file, initial: result });
+    }
+    // Silence unused-tasksRoot lint; included for symmetry/debugging clarity.
+    void tasksRoot;
+    return out;
+}
+/**
+ * Apply pairing rules:
+ * 1. Sub-files under `<taskdir>/` inherit from their parent task file.
+ * 2. Sibling planning/doing/ideation/audit files sharing a slug group together.
+ * 3. If any sibling is terminal → all terminal. Else if any is live_clear → all live_clear.
+ */
+function applyPairingRules(entries) {
+    // First pass: identify task-file siblings by directory + slug.
+    // We only group top-level markdown files (those without a parent task dir).
+    const slugGroups = new Map();
+    const childrenByParent = new Map();
+    const standalones = [];
+    for (const entry of entries) {
+        const parentDir = (0, classifier_1.extractParentTaskDir)(entry.relPath);
+        if (parentDir) {
+            const list = childrenByParent.get(parentDir) ?? [];
+            list.push(entry);
+            childrenByParent.set(parentDir, list);
+            continue;
+        }
+        if (entry.relPath.endsWith(".md") && !entry.initial.bucket.startsWith("special")) {
+            // Group by slug + parent path (e.g. one-shots/foo)
+            const slug = (0, classifier_1.deriveTaskSlug)(entry.relPath);
+            const dir = path.posix.dirname(entry.relPath);
+            const key = `${dir}::${slug}`;
+            const list = slugGroups.get(key) ?? [];
+            list.push(entry);
+            slugGroups.set(key, list);
+        }
+        else {
+            standalones.push(entry);
+        }
+    }
+    // Determine the group's final bucket: any terminal → terminal; else any
+    // live_clear → live_clear; else any stale_live → stale_live; else ambiguous.
+    // Special_europe_trip is preserved as-is (it lands in standalones, not
+    // slugGroups, so the special-trip branch below is defensive).
+    const finalBySlug = new Map();
+    for (const [key, members] of slugGroups.entries()) {
+        /* v8 ignore start -- special_europe_trip files are routed to `standalones` (not slugGroups) by the slug-grouping check above. The branch is defensive in case the classifier ever changes. @preserve */
+        if (members.some((m) => m.initial.bucket === "special_europe_trip")) {
+            finalBySlug.set(key, "special_europe_trip");
+            continue;
+        }
+        /* v8 ignore stop */
+        if (members.some((m) => m.initial.bucket === "terminal")) {
+            finalBySlug.set(key, "terminal");
+            continue;
+        }
+        if (members.some((m) => m.initial.bucket === "live_clear")) {
+            finalBySlug.set(key, "live_clear");
+            continue;
+        }
+        if (members.some((m) => m.initial.bucket === "stale_live")) {
+            finalBySlug.set(key, "stale_live");
+            continue;
+        }
+        finalBySlug.set(key, "ambiguous");
+    }
+    // Build the result.
+    const result = [];
+    for (const [key, members] of slugGroups.entries()) {
+        // finalBySlug.set(key, ...) was called for every key in slugGroups above,
+        // so the lookup is guaranteed non-undefined.
+        const finalBucket = finalBySlug.get(key);
+        for (const m of members) {
+            result.push({ ...m, finalBucket, pairingSlug: key });
+        }
+    }
+    // Children inherit from the parent task dir's slug group.
+    for (const [parentDir, kids] of childrenByParent.entries()) {
+        const slug = (0, classifier_1.deriveTaskSlug)(parentDir + ".md");
+        const dir = path.posix.dirname(parentDir + ".md");
+        const key = `${dir}::${slug}`;
+        // Parent might not exist (orphan child); default to ambiguous.
+        const finalBucket = finalBySlug.get(key) ?? "ambiguous";
+        for (const kid of kids) {
+            result.push({ ...kid, finalBucket, pairingSlug: key });
+        }
+    }
+    // Standalones (special_europe_trip, archive subdir non-md, etc.) pass through.
+    for (const s of standalones) {
+        result.push({ ...s, finalBucket: s.initial.bucket });
+    }
+    return result;
+}
+function buildPlan(grouped, deskRoot) {
+    const plan = [];
+    const archiveRoot = path.join(deskRoot, "_archive");
+    const legacyRoot = path.join(deskRoot, LEGACY_TRACK_NAME);
+    // Group live_clear entries by their pairing slug for task assembly.
+    // Live_clear entries only come from slugGroups or childrenByParent — both
+    // assign a pairingSlug — so we can safely use a non-null assertion when
+    // looking it up. Standalones never produce live_clear (they're only special
+    // or non-markdown ambiguous files).
+    const liveTasksBySlug = new Map();
+    for (const entry of grouped) {
+        if (entry.finalBucket !== "live_clear")
+            continue;
+        const slug = entry.pairingSlug;
+        const list = liveTasksBySlug.get(slug) ?? [];
+        list.push(entry);
+        liveTasksBySlug.set(slug, list);
+    }
+    for (const entry of grouped) {
+        switch (entry.finalBucket) {
+            case "terminal":
+            case "stale_live":
+            case "ambiguous": {
+                const outputPath = path.join(archiveRoot, entry.relPath);
+                plan.push({
+                    kind: "copy_to_archive",
+                    src: entry.absPath,
+                    outputPath,
+                    relPath: entry.relPath,
+                    markdown: entry.relPath.endsWith(".md"),
+                });
+                break;
+            }
+            case "special_europe_trip": {
+                plan.push({ kind: "europe_trip", relPath: entry.relPath });
+                break;
+            }
+            case "live_clear": {
+                // Live clear entries become tasks under `legacy/<slug>/`. Use the
+                // pairing slug's slug-portion (after `::`) for the directory.
+                const pairingSlug = entry.pairingSlug;
+                const taskSlug = derivePairingSlugDir(pairingSlug, entry.relPath);
+                const taskDir = path.join(legacyRoot, taskSlug);
+                // If this is the canonical task file (parent .md in the same dir),
+                // it becomes `task.md`. Otherwise it's an iteration artifact.
+                const group = liveTasksBySlug.get(pairingSlug);
+                const isCanonical = isCanonicalTaskFile(entry, group);
+                if (isCanonical) {
+                    plan.push({
+                        kind: "write_task",
+                        outputPath: path.join(taskDir, "task.md"),
+                        sources: group,
+                        relPath: entry.relPath,
+                    });
+                }
+                else {
+                    // Iteration artifact — preserve filename under iterations/.
+                    const iterBase = path.basename(entry.relPath);
+                    plan.push({
+                        kind: "copy_to_iteration",
+                        src: entry.absPath,
+                        outputPath: path.join(taskDir, "iterations", iterBase),
+                        relPath: entry.relPath,
+                        markdown: iterBase.endsWith(".md"),
+                    });
+                }
+                break;
+            }
+        }
+    }
+    return plan;
+}
+/**
+ * Extract the slug-portion of a pairing key. Pairing keys look like
+ * `<dir>::<slug>`. The caller (buildPlan) only invokes this with a confirmed
+ * non-empty pairingSlug created by `applyPairingRules`, which always inserts
+ * a `::` separator. The relPath fallback exists as a defensive guard.
+ */
+function derivePairingSlugDir(pairingSlug, relPath) {
+    const sep = pairingSlug.indexOf("::");
+    /* v8 ignore start -- defensive: pairing keys are constructed as `${dir}::${slug}` in applyPairingRules; the `::` separator always exists. @preserve */
+    if (sep === -1)
+        return (0, classifier_1.deriveTaskSlug)(relPath);
+    /* v8 ignore stop */
+    return pairingSlug.slice(sep + 2);
+}
+/**
+ * Determine which entry in a pairing group is the canonical task file.
+ * Preference: file with `doing-` infix (the executable doc) > `planning-` >
+ * earliest by filename. Sub-artifacts (those under a `<task>/` subdir) never
+ * win.
+ */
+function isCanonicalTaskFile(entry, group) {
+    // Children (with a pairing-derived parent dir) are never canonical.
+    if ((0, classifier_1.extractParentTaskDir)(entry.relPath))
+        return false;
+    // From within the group, pick the canonical winner.
+    const topLevels = group.filter((g) => !(0, classifier_1.extractParentTaskDir)(g.relPath));
+    /* v8 ignore start -- defensive: if entry has no parent task dir (above), it IS a top-level file and is in the group, so topLevels always contains at least entry itself. The empty-array branch is unreachable. @preserve */
+    if (topLevels.length === 0)
+        return false;
+    /* v8 ignore stop */
+    const winner = pickCanonical(topLevels);
+    return winner.relPath === entry.relPath;
+}
+function pickCanonical(candidates) {
+    // Prefer doing- > planning- > others, then earliest filename.
+    const role = (rel) => {
+        const base = path.basename(rel);
+        if (/\b-doing-/.test(base) || /^doing-/.test(base.replace(/^\d{4}-\d{2}-\d{2}(?:-\d{4})?-/, "")))
+            return 0;
+        /* v8 ignore start -- the `^planning-` post-strip alternative and the `return 2` other-role fallthrough only fire for undated filenames (no `YYYY-MM-DD-` prefix). Real bundles use the dated convention exclusively. @preserve */
+        if (/\b-planning-/.test(base) || /^planning-/.test(base.replace(/^\d{4}-\d{2}-\d{2}(?:-\d{4})?-/, "")))
+            return 1;
+        return 2;
+        /* v8 ignore stop */
+    };
+    const sorted = [...candidates].sort((a, b) => {
+        const ra = role(a.relPath);
+        const rb = role(b.relPath);
+        /* v8 ignore start -- the false branch of `ra !== rb` (same-role tiebreaker) is only reachable when a group has two files with the same role (e.g. two `-doing-` siblings). Legacy bundles use paired doing+planning, not duplicate roles. @preserve */
+        if (ra === rb)
+            return a.relPath.localeCompare(b.relPath);
+        /* v8 ignore stop */
+        return ra - rb;
+    });
+    return sorted[0];
+}
+// ── Plan application ──
+function applyPlanAction(action) {
+    switch (action.kind) {
+        case "copy_to_archive": {
+            fs.mkdirSync(path.dirname(action.outputPath), { recursive: true });
+            if (action.markdown) {
+                const raw = fs.readFileSync(action.src, "utf-8");
+                const withSchema = ensureSchemaVersion(raw);
+                fs.writeFileSync(action.outputPath, withSchema, "utf-8");
+            }
+            else {
+                fs.copyFileSync(action.src, action.outputPath);
+            }
+            break;
+        }
+        case "copy_to_iteration": {
+            fs.mkdirSync(path.dirname(action.outputPath), { recursive: true });
+            if (action.markdown) {
+                const raw = fs.readFileSync(action.src, "utf-8");
+                const withSchema = ensureSchemaVersion(raw);
+                fs.writeFileSync(action.outputPath, withSchema, "utf-8");
+            }
+            else {
+                fs.copyFileSync(action.src, action.outputPath);
+            }
+            break;
+        }
+        case "write_task": {
+            fs.mkdirSync(path.dirname(action.outputPath), { recursive: true });
+            const taskMd = renderTaskMd(action.sources, action.relPath);
+            fs.writeFileSync(action.outputPath, taskMd, "utf-8");
+            break;
+        }
+        case "europe_trip": {
+            // Handled by writeEuropeTripScaffold after plan execution.
+            break;
+        }
+    }
+}
+/**
+ * If the markdown file has YAML frontmatter, ensure it carries
+ * `schema_version: 1`. If it has no frontmatter, prepend a minimal block.
+ */
+function ensureSchemaVersion(raw) {
+    const trimmed = raw.trimStart();
+    if (trimmed.startsWith("---")) {
+        const afterFirst = trimmed.slice(3);
+        const closeIdx = afterFirst.indexOf("\n---");
+        if (closeIdx !== -1) {
+            const fmBlock = afterFirst.slice(0, closeIdx);
+            if (/\bschema_version\s*:/.test(fmBlock)) {
+                return raw;
+            }
+            // Insert schema_version line at the start of the frontmatter block.
+            const head = trimmed.slice(0, 3); // "---"
+            const newFmBlock = `schema_version: ${SCHEMA_VERSION}${fmBlock}`;
+            const rest = afterFirst.slice(closeIdx);
+            return `${head}\n${newFmBlock}${rest}`;
+        }
+    }
+    // No frontmatter — prepend a minimal block.
+    return `---\nschema_version: ${SCHEMA_VERSION}\n---\n${raw}`;
+}
+// ── Task / track rendering ──
+function renderTaskMd(sources, primaryRelPath) {
+    const winner = pickCanonical(sources.filter((s) => !(0, classifier_1.extractParentTaskDir)(s.relPath)));
+    const winnerContent = readSafe(winner.absPath);
+    const withSchema = ensureSchemaVersion(winnerContent);
+    // Footer noting the migration provenance.
+    const trailer = [
+        "",
+        "<!-- migrated from `tasks/" + primaryRelPath + "` on 2026-05-22 -->",
+        "",
+    ].join("\n");
+    return withSchema.endsWith("\n") ? withSchema + trailer : withSchema + "\n" + trailer;
+}
+function renderLegacyTrackMd(today) {
+    const dateStr = today.toISOString().slice(0, 10);
+    return [
+        "---",
+        "schema_version: 1",
+        "track: legacy",
+        "status: collaborating",
+        `created: ${dateStr}`,
+        "---",
+        "",
+        "# legacy",
+        "",
+        `Migrated from \`tasks/\` on ${dateStr} by the legacy-tasks-to-desk migrator.`,
+        "",
+        "## triage rules",
+        "",
+        "- TERMINAL (done / approved / complete / cancelled / fixed / etc.) → archived under `_archive/`",
+        "- STALE_LIVE (live status but updated >30 days ago, cutoff 2026-04-22) → archived under `_archive/`",
+        "- AMBIGUOUS (no status, junk format, .md.bak, empty) → archived under `_archive/`",
+        "- LIVE_CLEAR (live status, updated within last 30 days, coherent) → migrated here, as one task per paired slug, with iterations under `iterations/`",
+        "",
+        "Tasks under this track are the recovered live work-in-progress. Audit and either move to a proper track or archive.",
+        "",
+    ].join("\n");
+}
+// ── Europe-trip scaffold (minimal stubs per Unit 11 fallback) ──
+function writeEuropeTripScaffold(deskRoot, today) {
+    const trackDir = path.join(deskRoot, EUROPE_TRIP_TRACK_NAME);
+    const planningDir = path.join(trackDir, "_planning");
+    const outboundDir = path.join(trackDir, EUROPE_TRIP_TASK_OUTBOUND);
+    const weeklyDir = path.join(trackDir, EUROPE_TRIP_TASK_WEEKLY);
+    for (const d of [trackDir, planningDir, outboundDir, weeklyDir]) {
+        fs.mkdirSync(d, { recursive: true });
+    }
+    fs.writeFileSync(path.join(trackDir, "track.md"), renderEuropeTripTrackMd(today), "utf-8");
+    fs.writeFileSync(path.join(planningDir, "overview.md"), renderEuropeTripOverview(), "utf-8");
+    fs.writeFileSync(path.join(planningDir, "next-actions.md"), renderEuropeTripNextActions(), "utf-8");
+    fs.writeFileSync(path.join(outboundDir, "task.md"), renderEuropeTripOutboundTask(today), "utf-8");
+    fs.writeFileSync(path.join(weeklyDir, "task.md"), renderEuropeTripWeeklyTask(today), "utf-8");
+}
+function renderEuropeTripTrackMd(today) {
+    const dateStr = today.toISOString().slice(0, 10);
+    return [
+        "---",
+        "schema_version: 1",
+        `track: ${EUROPE_TRIP_TRACK_NAME}`,
+        "featured: true",
+        "status: active",
+        "urgency: high",
+        "target_date: 2026-08-01",
+        "trip_record: trips/records/trip_summer-2026-europe-trip_82bdea2a9d088cbe.json",
+        "travel_docs: travel/2026-summer-trip/",
+        `created: ${dateStr}`,
+        "---",
+        "",
+        "# summer-2026-europe-trip",
+        "",
+        "Project-management overlay for the summer 2026 Europe trip. Trip-tools own the canonical state (itinerary, bookings, ledger, records); this desk track owns the recurring pulse and the open project-management chase.",
+        "",
+        "## status",
+        "",
+        "Migrated by the legacy-tasks-to-desk migrator from `tasks/ongoing/2026-03-09-1410-summer-2026-europe-trip.md`. Flesh out from original sources + `travel/2026-summer-trip/` state.",
+        "",
+        "## links into trip-tools",
+        "",
+        "- `travel/2026-summer-trip/itinerary.md`",
+        "- `travel/2026-summer-trip/bookings.md`",
+        "- `travel/2026-summer-trip/budget.md`",
+        "- `travel/2026-summer-trip/packing.md`",
+        "- `travel/2026-summer-trip/ideas.md`",
+        "- `travel/2026-summer-trip/basel.md`",
+        "- `travel/2026-summer-trip/research-log.md`",
+        "- `travel/2026-summer-trip/gap-fill-2026-04-30.md`",
+        "- `trips/records/trip_summer-2026-europe-trip_82bdea2a9d088cbe.json`",
+        "",
+        "## active tasks",
+        "",
+        `- \`${EUROPE_TRIP_TASK_OUTBOUND}\` — replacement flight chase (Lufthansa 9FLJTF cancelled 2026-04-16; refund issued)`,
+        `- \`${EUROPE_TRIP_TASK_WEEKLY}\` — recurring weekly→daily project-level pulse`,
+        "",
+    ].join("\n");
+}
+function renderEuropeTripOverview() {
+    return [
+        "---",
+        "schema_version: 1",
+        "---",
+        "",
+        "# overview — desk vs. trip-tools",
+        "",
+        "Trip-tools own the canonical trip state: `trips/` (ledger + records) and `travel/2026-summer-trip/` (itinerary, bookings, budget, packing, ideas, basel, research-log, gap-fill).",
+        "",
+        "This desk track owns only the project-management overlay: the weekly pulse and the open chase items. It LINKS to trip-tools files; it does not duplicate them.",
+        "",
+        "Migrated as a minimal stub by the legacy-tasks-to-desk migrator. Flesh out content from `tasks/ongoing/2026-03-09-1410-summer-2026-europe-trip.md` + the latest gap-fill.",
+        "",
+    ].join("\n");
+}
+function renderEuropeTripNextActions() {
+    return [
+        "---",
+        "schema_version: 1",
+        "---",
+        "",
+        "# next actions",
+        "",
+        "Project-management actions that trip-tools don't naturally model:",
+        "",
+        "- (placeholder) Surface 3-5 replacement-flight candidates",
+        "- (placeholder) Confirm Italy/wedding lodging artifact from the operator",
+        "",
+        "Stub left by the migrator — operator can hand-edit content in a follow-up.",
+        "",
+    ].join("\n");
+}
+function renderEuropeTripOutboundTask(today) {
+    const dateStr = today.toISOString().slice(0, 10);
+    return [
+        "---",
+        "schema_version: 1",
+        `track: ${EUROPE_TRIP_TRACK_NAME}`,
+        "status: processing",
+        "target_date: 2026-08-01",
+        `created: ${dateStr}`,
+        "---",
+        "",
+        `# ${EUROPE_TRIP_TASK_OUTBOUND}`,
+        "",
+        "Replacement outbound flight to Europe — Lufthansa 9FLJTF (LX8007 SEA→ZRH) was cancelled 2026-04-16; refund issued 2026-04-17 ($1,269 + $298 services).",
+        "",
+        "Search order per `travel/2026-summer-trip/gap-fill-2026-04-30.md#1-replacement-flight-to-europe`:",
+        "1. SEA→BSL one-stops first",
+        "2. SEA→ZRH + train fallback",
+        "",
+        "Hotel Märthof check-in is 15:00 on Aug 2.",
+        "",
+        "Stub left by the migrator — operator can hand-edit content in a follow-up.",
+        "",
+    ].join("\n");
+}
+function renderEuropeTripWeeklyTask(today) {
+    const dateStr = today.toISOString().slice(0, 10);
+    return [
+        "---",
+        "schema_version: 1",
+        `track: ${EUROPE_TRIP_TRACK_NAME}`,
+        "status: drafting",
+        `created: ${dateStr}`,
+        "cadence:",
+        "  - until: 2026-07-25",
+        "    every: weekly",
+        "  - until: 2026-08-01",
+        "    every: daily",
+        "---",
+        "",
+        `# ${EUROPE_TRIP_TASK_WEEKLY}`,
+        "",
+        "Recurring project-level pulse. Each tick: walk `travel/2026-summer-trip/bookings.md`, list open slots and any `target_date` inside the next interval, append a one-line entry to `_planning/next-actions.md`. Post-departure: auto-archive.",
+        "",
+        "Stub left by the migrator — operator can hand-edit content in a follow-up.",
+        "",
+    ].join("\n");
+}
+// ── Force-mode scope ──
+function clearMigratorOwnedDirs(deskRoot) {
+    for (const d of MIGRATOR_OWNED_DIRS) {
+        const p = path.join(deskRoot, d);
+        if (fs.existsSync(p))
+            removeTreeEnumerated(p);
+    }
+    const metaDir = path.join(deskRoot, "_meta");
+    for (const f of MIGRATOR_OWNED_META_FILES) {
+        const p = path.join(metaDir, f);
+        if (fs.existsSync(p))
+            fs.rmSync(p, { force: true });
+    }
+}
+/**
+ * Remove a directory tree by enumerating its contents — readdir, recurse into
+ * subdirs, rmSync each file, then rmdirSync bottom-up. Avoids `recursive:
+ * true` per the harness's "agent-callable code should enumerate" rule
+ * (see test-isolation.contract.test.ts Directive A).
+ */
+function removeTreeEnumerated(root) {
+    let stat;
+    try {
+        stat = fs.lstatSync(root);
+    }
+    catch {
+        /* v8 ignore start -- defensive: removed underneath us; nothing to do @preserve */
+        return;
+        /* v8 ignore stop */
+    }
+    /* v8 ignore start -- defensive: MIGRATOR_OWNED_DIRS is a fixed list of dir names; this branch only fires if one of those names happens to be a file (impossible by construction) @preserve */
+    if (!stat.isDirectory()) {
+        fs.rmSync(root, { force: true });
+        return;
+    }
+    /* v8 ignore stop */
+    const entries = fs.readdirSync(root, { withFileTypes: true });
+    for (const entry of entries) {
+        const child = path.join(root, entry.name);
+        if (entry.isDirectory()) {
+            removeTreeEnumerated(child);
+        }
+        else {
+            fs.rmSync(child, { force: true });
+        }
+    }
+    fs.rmdirSync(root);
+}
+// ── Summary + log rendering ──
+function emptyCounts() {
+    return {
+        terminal: 0,
+        stale_live: 0,
+        ambiguous: 0,
+        live_clear: 0,
+        special_europe_trip: 0,
+    };
+}
+function countBuckets(grouped) {
+    const counts = emptyCounts();
+    for (const g of grouped) {
+        counts[g.finalBucket] += 1;
+    }
+    return counts;
+}
+function renderDryRunSummary(plan, counts, deskRoot, logPath) {
+    const lines = [];
+    lines.push("[dry-run] migrate-to-desk plan:");
+    lines.push(`  desk root: ${deskRoot}`);
+    lines.push(`  counts:`);
+    lines.push(`    terminal:            ${counts.terminal}`);
+    lines.push(`    stale_live:          ${counts.stale_live}`);
+    lines.push(`    ambiguous:           ${counts.ambiguous}`);
+    lines.push(`    live_clear:          ${counts.live_clear}`);
+    lines.push(`    special_europe_trip: ${counts.special_europe_trip}`);
+    lines.push(`  planned actions: ${plan.length}`);
+    lines.push(`  would write log: ${logPath}`);
+    lines.push("[dry-run] no files modified.");
+    return lines.join("\n");
+}
+function renderPerformedSummary(counts, deskRoot, logPath) {
+    const lines = [];
+    lines.push("migrate-to-desk: complete.");
+    lines.push(`  desk root: ${deskRoot}`);
+    lines.push(`  archived (terminal):            ${counts.terminal}`);
+    lines.push(`  archived (stale_live):          ${counts.stale_live}`);
+    lines.push(`  archived (ambiguous):           ${counts.ambiguous}`);
+    lines.push(`  migrated to legacy track:       ${counts.live_clear}`);
+    lines.push(`  special_europe_trip:            ${counts.special_europe_trip}`);
+    lines.push(`  log: ${logPath}`);
+    return lines.join("\n");
+}
+function renderLogLines(grouped, plan, today) {
+    const lines = [];
+    const dateStr = today.toISOString().slice(0, 10);
+    lines.push(`# migration log — ${dateStr}`);
+    lines.push("# format: <bucket>\t<source-relpath>\t<dest-relpath>\t<reason>");
+    // Map relPath → destination for log output.
+    const destByRelPath = new Map();
+    for (const action of plan) {
+        switch (action.kind) {
+            case "copy_to_archive":
+            case "copy_to_iteration":
+            case "write_task":
+                destByRelPath.set(action.relPath, action.outputPath);
+                break;
+            case "europe_trip":
+                destByRelPath.set(action.relPath, "<europe-trip-scaffold>");
+                break;
+        }
+    }
+    // Sort by relPath for deterministic output.
+    const sorted = [...grouped].sort((a, b) => a.relPath.localeCompare(b.relPath));
+    for (const g of sorted) {
+        /* v8 ignore start -- defensive: every grouped entry produces a plan action that registers in destByRelPath above. The `<unrouted>` fallback is unreachable in practice. @preserve */
+        const dest = destByRelPath.get(g.relPath) ?? "<unrouted>";
+        /* v8 ignore stop */
+        lines.push([g.finalBucket, g.relPath, dest, g.initial.reason].join("\t"));
+    }
+    return lines;
+}
+// ── Small helpers ──
+function readSafe(p) {
+    try {
+        return fs.readFileSync(p, "utf-8");
+    }
+    catch {
+        /* v8 ignore start -- defensive: re-read of a file we already accessed in classifyAll; treated as empty @preserve */
+        return "";
+        /* v8 ignore stop */
+    }
+}