@carljia/omd-dsh 0.1.4 → 0.1.7

package/lib/sync.js

@@ -0,0 +1,549 @@
+import { promises as fs, existsSync, mkdirSync, realpathSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import { homedir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+export const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+export const VENDOR_SOURCES = ["omd-mode.mjs", "omd-task.mjs", "omd-ulw.mjs", "omd-plan.mjs", "omd-start-work.mjs", "omd-mode-switch.mjs", "shared.js"];
+/** User-owned model matrix: lives under DSH_HOME, never inside the package or the repo. */
+export const MATRIX_PATH = join(dshHome(), "omd-matrix.json");
+/** Pre-migration location (package root) — migrated to MATRIX_PATH once when present. */
+const LEGACY_MATRIX_PATH = join(PACKAGE_ROOT, "omd-matrix.json");
+const MODE_FENCE = { start: "# [omd-dsh:mode:start]", end: "# [omd-dsh:mode:end]" };
+const TASK_FENCE = { start: "# [omd-dsh:task:start]", end: "# [omd-dsh:task:end]" };
+/** Presets that were renamed: old directory name -> new preset name. */
+const RENAMED_FROM = { "omd-architect": "omd-ultraworker" };
+function sha256(text) { return createHash("sha256").update(text).digest("hex"); }
+export function dshHome() { return process.env.DSH_HOME !== undefined && process.env.DSH_HOME !== "" ? resolve(process.env.DSH_HOME) : join(homedir(), ".dsh"); }
+function findNodeModules(start) {
+    let current = resolve(start);
+    for (;;) {
+        if (basename(current) === "node_modules")
+            return current;
+        const parent = dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function harnessCachePath() { return join(dshHome(), "omd-dsh-harness.json"); }
+/** Read the cached harness node_modules, ignoring a stale/missing entry. */
+function readCachedHarness() {
+    try {
+        const p = harnessCachePath();
+        if (!existsSync(p))
+            return undefined;
+        const parsed = JSON.parse(readFileSync(p, "utf8"));
+        const nm = parsed && typeof parsed === "object" ? parsed.harnessNodeModules : undefined;
+        if (typeof nm !== "string" || nm === "")
+            return undefined;
+        if (!existsSync(join(nm, "@deepseek-ai", "dsh-scope", "package.json")))
+            return undefined;
+        return nm;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Persist the resolved harness node_modules for later runs (best-effort). */
+function writeCachedHarness(harnessNodeModules) {
+    try {
+        writeFileSync(harnessCachePath(), JSON.stringify({ harnessNodeModules }, null, 2) + "\n", "utf8");
+    }
+    catch { /* best-effort */ }
+}
+/**
+ * Resolve the DSH harness node_modules:
+ *   1. --harness flag (and cache it for later);
+ *   2. auto-detect via the dsh executable on PATH;
+ *   3. fall back to the locally cached value.
+ */
+export function resolveHarness(flags) {
+    let nm;
+    if (flags.harness !== undefined) {
+        nm = findNodeModules(flags.harness);
+        if (nm !== undefined) {
+            try {
+                nm = realpathSync(nm);
+                writeCachedHarness(nm);
+            }
+            catch { /* keep nm as-is */ }
+        }
+        return nm;
+    }
+    nm = locateHarnessViaDsh() ?? locateHarnessViaNpxCache() ?? readCachedHarness();
+    if (nm !== undefined) {
+        try {
+            nm = realpathSync(nm);
+        }
+        catch { /* keep */ }
+    }
+    return nm;
+}
+/**
+ * Resolve the harness node_modules from THIS module's own location, walking up
+ * the Node resolution path for @deepseek-ai/dsh-scope. This is the reliable
+ * anchor when the package runs as a bundle inside a DSH profile: the profile's
+ * flat module fallback (or its hoisted node_modules) exposes the harness tree.
+ */
+export function resolveHarnessFromSelf() {
+    let dir = dirname(fileURLToPath(import.meta.url));
+    for (;;) {
+        const nm = join(dir, "node_modules");
+        const scopeDir = join(nm, "@deepseek-ai", "dsh-scope");
+        if (existsSync(join(scopeDir, "package.json"))) {
+            try {
+                const real = realpathSync(scopeDir);
+                return findNodeModules(real);
+            }
+            catch {
+                return nm;
+            }
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            return undefined;
+        dir = parent;
+    }
+}
+function locateHarnessViaDsh() {
+    const candidates = [];
+    try {
+        const probe = process.platform === "win32" ? "where.exe" : "which";
+        const out = execFileSync(probe, ["dsh"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+        for (const line of out.split(/\r?\n/)) {
+            const t = line.trim();
+            if (t !== "")
+                candidates.push(t);
+        }
+    }
+    catch { /* dsh not on PATH */ }
+    for (const candidate of candidates) {
+        let real = candidate;
+        try {
+            real = realpathSync(candidate);
+        }
+        catch { /* keep */ }
+        const nm = findNodeModules(real);
+        if (nm !== undefined && existsSync(join(nm, "@deepseek-ai", "dsh-scope", "package.json")))
+            return nm;
+    }
+    return undefined;
+}
+/** Candidate npx cache roots where a non-global DSH install may live. */
+function npxCacheRoots() {
+    const roots = [];
+    if (process.platform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA;
+        if (localAppData)
+            roots.push(join(localAppData, "npm-cache", "_npx"));
+        const appData = process.env.APPDATA;
+        if (appData)
+            roots.push(join(appData, "npm-cache", "_npx"));
+    }
+    else {
+        roots.push(join(homedir(), ".npm", "_npx"));
+    }
+    return roots;
+}
+/**
+ * Best-effort scan of the npx cache for a DSH install whose node_modules
+ * carries @deepseek-ai/dsh-scope. Picks the most recently touched one.
+ */
+function locateHarnessViaNpxCache() {
+    const matches = [];
+    for (const root of npxCacheRoots()) {
+        let entries;
+        try {
+            entries = readdirSync(root);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            const nm = join(root, entry, "node_modules");
+            if (!existsSync(join(nm, "@deepseek-ai", "dsh-scope", "package.json")))
+                continue;
+            let mtime = 0;
+            try {
+                mtime = statSync(join(root, entry)).mtimeMs;
+            }
+            catch { /* keep 0 */ }
+            matches.push({ nm, mtime });
+        }
+    }
+    matches.sort((a, b) => b.mtime - a.mtime);
+    return matches.length > 0 ? matches[0].nm : undefined;
+}
+function resolveHarnessModule(harnessNodeModules, specifier) {
+    const segments = specifier.split("/");
+    const scope = segments[0].startsWith("@") ? segments[0] + "/" + segments[1] : segments[0];
+    const subpath = scope === specifier ? "" : specifier.slice(scope.length + 1);
+    const pkgDir = join(harnessNodeModules, ...scope.split("/"));
+    const manifestPath = join(pkgDir, "package.json");
+    if (!existsSync(manifestPath))
+        throw new Error("omd-dsh: cannot resolve \"" + specifier + "\" -- no package.json at " + manifestPath);
+    const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+    let entry;
+    const exportsMap = manifest.exports;
+    if (subpath === "" && exportsMap !== undefined && exportsMap["."] !== undefined) {
+        const dot = exportsMap["."];
+        if (typeof dot === "string")
+            entry = dot;
+        else if (typeof dot === "object" && dot !== null) {
+            entry = dot.node ?? dot.import ?? dot.default;
+            if (typeof entry === "object" && entry !== null)
+                entry = entry.node ?? entry.import ?? entry.default;
+        }
+    }
+    if (entry === undefined && subpath === "")
+        entry = manifest.module ?? manifest.main;
+    if (entry === undefined)
+        entry = subpath === "" ? "index.js" : subpath;
+    else if (subpath !== "")
+        entry = join(entry, subpath);
+    let resolvedPath = resolve(pkgDir, entry);
+    try {
+        resolvedPath = realpathSync(resolvedPath);
+    }
+    catch { /* keep */ }
+    if (!existsSync(resolvedPath))
+        throw new Error("omd-dsh: resolved entry \"" + entry + "\" for \"" + specifier + "\" does not exist at " + resolvedPath);
+    return pathToFileURL(resolvedPath).href;
+}
+function rewriteImports(sourceText, harnessNodeModules) {
+    const specifierPattern = /@deepseek-ai\/[A-Za-z0-9@._/-]+/g;
+    return sourceText.split(/\r?\n/).map((line) => {
+        if (!line.trimStart().startsWith("import"))
+            return line;
+        return line.replace(specifierPattern, (s) => resolveHarnessModule(harnessNodeModules, s));
+    }).join("\n");
+}
+function readMeta(dir) {
+    const metaPath = join(dir, ".omd-meta.json");
+    if (!existsSync(metaPath))
+        return undefined;
+    try {
+        const p = JSON.parse(readFileSync(metaPath, "utf8"));
+        if (p !== null && typeof p === "object" && p.files !== null && typeof p.files === "object")
+            return p;
+        return undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+async function collectSourceFiles(rootDir) {
+    const out = [];
+    const walk = async (dir) => {
+        for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+            const full = join(dir, entry.name);
+            if (entry.isDirectory())
+                await walk(full);
+            else
+                out.push(full);
+        }
+    };
+    await walk(rootDir);
+    return out;
+}
+// ── matrix ──
+const DEFAULT_MATRIX_PATH = join(PACKAGE_ROOT, "omd-matrix.default.json");
+function parseMatrix(text) {
+    try {
+        const parsed = JSON.parse(text);
+        if (parsed !== null && typeof parsed === "object" && parsed.modes !== null && typeof parsed.modes === "object")
+            return parsed;
+    }
+    catch { /* fall through */ }
+    return undefined;
+}
+function readDefaultMatrix() {
+    if (!existsSync(DEFAULT_MATRIX_PATH))
+        throw new Error("omd-dsh: missing default matrix file " + DEFAULT_MATRIX_PATH + " (broken package — reinstall @carljia/omd-dsh)");
+    const parsed = parseMatrix(readFileSync(DEFAULT_MATRIX_PATH, "utf8"));
+    if (parsed === undefined)
+        throw new Error("omd-dsh: malformed default matrix file " + DEFAULT_MATRIX_PATH + " (broken package — reinstall @carljia/omd-dsh)");
+    return parsed;
+}
+function writeMatrixFile(path, text) {
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, text, "utf8");
+}
+export function loadMatrix(flags, log = console.log) {
+    if (!existsSync(MATRIX_PATH)) {
+        if (flags.dryRun)
+            return JSON.parse(JSON.stringify(readDefaultMatrix()));
+        const legacyText = existsSync(LEGACY_MATRIX_PATH) ? readFileSync(LEGACY_MATRIX_PATH, "utf8") : undefined;
+        if (legacyText !== undefined && parseMatrix(legacyText) !== undefined) {
+            writeMatrixFile(MATRIX_PATH, legacyText);
+            log("omd-dsh: migrated omd-matrix.json: " + LEGACY_MATRIX_PATH + " -> " + MATRIX_PATH);
+            log("omd-dsh: customize the model matrix any time with \`omd-dsh setup\`.");
+        }
+        else {
+            const defaults = readDefaultMatrix();
+            writeMatrixFile(MATRIX_PATH, JSON.stringify(defaults, null, 2) + "\n");
+            log("omd-dsh: generated " + MATRIX_PATH + " from the shipped deepseek default matrix; customize it any time with \`omd-dsh setup\`.");
+        }
+    }
+    const text = readFileSync(MATRIX_PATH, "utf8");
+    const parsed = parseMatrix(text);
+    if (parsed === undefined)
+        throw new Error("omd-dsh: malformed " + MATRIX_PATH + " (restore it, or delete it and run omd-dsh setup)");
+    return parsed;
+}
+export function saveMatrix(m) { writeMatrixFile(MATRIX_PATH, JSON.stringify(m, null, 2) + "\n"); }
+// ── row rendering ──
+function q(s) { return JSON.stringify(s); }
+function renderModeRow(modeId, cfg) {
+    const out = ["- id: omd-mode", "  name: '../.omd-vendor/omd-mode.mjs'", "  config:", "    mode: " + modeId];
+    if (cfg.provider !== undefined)
+        out.push("    provider: " + cfg.provider);
+    if (cfg.model !== undefined)
+        out.push("    model: " + cfg.model);
+    if (cfg.reasoningEffort !== undefined)
+        out.push("    reasoningEffort: " + cfg.reasoningEffort);
+    return out;
+}
+function renderToolFilter(tf) {
+    const deny = tf.deny ?? [];
+    const allow = tf.allow ?? [];
+    const out = [];
+    if (tf.denyShell === true) {
+        const arr = (names) => "[" + names.map((n) => "'" + n + "'").join(", ") + "]";
+        const expr = "(process.platform === 'win32') ? " + arr([...deny, "pwsh"]) + " : " + arr([...deny, "bash"]);
+        out.push("toolFilter:", "  deny: !!js " + q(expr));
+    }
+    else {
+        if (allow.length > 0)
+            out.push("toolFilter:", "  allow: [" + allow.join(", ") + "]");
+        if (deny.length > 0) {
+            if (out.length === 0)
+                out.push("toolFilter:");
+            out.push("  deny: [" + deny.join(", ") + "]");
+        }
+    }
+    return out;
+}
+function renderTaskRow(cfg) {
+    const tiers = cfg.tiers ?? {};
+    if (Object.keys(tiers).length === 0)
+        return [];
+    const out = ["- id: omd-task", "  name: '../.omd-vendor/omd-task.mjs'", "  config:", "    provider: spawn", "    toolName: omd_task", "    backgroundMode: continuable", "    tiers:"];
+    for (const [name, t] of Object.entries(tiers)) {
+        out.push("      " + name + ":");
+        out.push("        provider: " + t.provider);
+        out.push("        model: " + t.model);
+        if (t.hint !== undefined)
+            out.push("        hint: " + q(t.hint));
+        if (t.persona !== undefined)
+            out.push("        persona: " + q(t.persona));
+        if (t.maxTokens !== undefined)
+            out.push("        maxTokens: " + t.maxTokens);
+        if (t.toolFilter !== undefined)
+            for (const l of renderToolFilter(t.toolFilter))
+                out.push("        " + l);
+    }
+    return out;
+}
+function spliceFence(lines, fence, rendered) {
+    const start = lines.findIndex((l) => l.trim() === fence.start);
+    const end = lines.findIndex((l) => l.trim() === fence.end);
+    if (start === -1 || end === -1 || end < start)
+        throw new Error("omd-dsh: preset is missing the " + fence.start + " / " + fence.end + " markers; regenerate the preset from source");
+    const indent = (lines[start].match(/^ */) || [""])[0];
+    const renderedIndented = rendered.map((l) => indent + l);
+    lines.splice(start, end - start + 1, indent + fence.start, ...renderedIndented, indent + fence.end);
+}
+function applyMatrix(text, modeId, cfg) {
+    const lines = text.split("\n");
+    spliceFence(lines, MODE_FENCE, renderModeRow(modeId, cfg));
+    const taskRendered = renderTaskRow(cfg);
+    const hasTaskFence = lines.some((l) => l.trim() === TASK_FENCE.start);
+    if (taskRendered.length > 0 && !hasTaskFence) {
+        throw new Error("omd-dsh: mode \"" + modeId + "\" has tiers in omd-matrix.json but its preset is missing the task fence");
+    }
+    if (hasTaskFence)
+        spliceFence(lines, TASK_FENCE, taskRendered);
+    return lines.join("\n");
+}
+/**
+ * Whether one omd-dsh-managed preset directory differs from the hashes its
+ * .omd-meta.json recorded. Returns a description of the first discrepancy,
+ * or undefined when every recorded file is present and unmodified.
+ */
+async function locallyModified(dir, meta) {
+    const recorded = meta.files ?? {};
+    const current = {};
+    const walk = async (d) => {
+        for (const entry of await fs.readdir(d, { withFileTypes: true })) {
+            const full = join(d, entry.name);
+            if (entry.isDirectory())
+                await walk(full);
+            else if (entry.name !== ".omd-meta.json") {
+                const rel = relative(dir, full).split("\\").join("/");
+                current[rel] = sha256(await fs.readFile(full, "utf8"));
+            }
+        }
+    };
+    await walk(dir);
+    for (const rel of new Set([...Object.keys(recorded), ...Object.keys(current)])) {
+        if (current[rel] === undefined)
+            return "missing file " + rel;
+        const recordedHash = recorded[rel] !== undefined && typeof recorded[rel] === "object" && recorded[rel] !== null ? recorded[rel].sha256 : undefined;
+        if (typeof recordedHash !== "string" || recordedHash !== current[rel])
+            return "modified file " + rel;
+    }
+    return undefined;
+}
+export async function runSync(flags, harnessNodeModules, log = console.log) {
+    const matrix = loadMatrix(flags, log);
+    const manifest = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf8"));
+    const sourceVersion = manifest.version;
+    const presetsSourceDir = join(PACKAGE_ROOT, "presets");
+    const vendorSourceDir = join(PACKAGE_ROOT, "lib", "vendor");
+    const agentPresetsRoot = join(dshHome(), ".agent-presets");
+    const presetNames = (await fs.readdir(presetsSourceDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+    const report = { synced: [], updated: [], conflicts: [], skipped: [], orphan: [], removed: [] };
+    const record = (kind, text) => report[kind].push(text);
+    for (const presetName of presetNames) {
+        const modeId = presetName.replace(/^omd-/, "");
+        const cfg = matrix.modes[modeId];
+        if (cfg === undefined)
+            throw new Error("omd-dsh sync: omd-matrix.json has no entry for mode \"" + modeId + "\" (preset " + presetName + ")");
+        const sourceDir = join(presetsSourceDir, presetName);
+        const targetDir = join(agentPresetsRoot, presetName);
+        const sourceFiles = await collectSourceFiles(sourceDir);
+        const existingMeta = existsSync(targetDir) ? readMeta(targetDir) : undefined;
+        if (existsSync(targetDir) && existingMeta === undefined) {
+            record("skipped", presetName + "/ (directory exists but is not managed by omd-dsh -- left untouched)");
+            continue;
+        }
+        const nextFiles = {};
+        for (const sourceFile of sourceFiles) {
+            const rel = relative(sourceDir, sourceFile).split("\\").join("/");
+            let sourceText = await fs.readFile(sourceFile, "utf8");
+            if (rel === "agent.cordis.yml")
+                sourceText = applyMatrix(sourceText, modeId, cfg);
+            const sourceHash = sha256(sourceText);
+            const destFile = join(targetDir, rel);
+            let action = "synced";
+            if (existsSync(destFile)) {
+                const destHash = sha256(await fs.readFile(destFile, "utf8"));
+                const prevHash = existingMeta?.files?.[rel]?.sha256;
+                if (destHash === sourceHash)
+                    action = "up-to-date";
+                else if (prevHash !== undefined && destHash === prevHash)
+                    action = "updated";
+                else
+                    action = "conflict";
+            }
+            if (action === "conflict") {
+                record("conflicts", presetName + "/" + rel + " (locally modified -- keeping your version)");
+                if (existingMeta?.files?.[rel]?.sha256 !== undefined)
+                    nextFiles[rel] = { sha256: existingMeta.files[rel].sha256 };
+                continue;
+            }
+            if (action === "up-to-date")
+                record("skipped", presetName + "/" + rel + " (up to date)");
+            else {
+                if (!flags.dryRun) {
+                    await fs.mkdir(dirname(destFile), { recursive: true });
+                    await fs.writeFile(destFile, sourceText, "utf8");
+                }
+                record(action === "synced" ? "synced" : "updated", presetName + "/" + rel + (flags.dryRun ? " (dry-run)" : ""));
+            }
+            nextFiles[rel] = { sha256: sourceHash };
+        }
+        if (!flags.dryRun) {
+            await fs.mkdir(targetDir, { recursive: true });
+            await fs.writeFile(join(targetDir, ".omd-meta.json"), JSON.stringify({ source: "omd-dsh", sourceVersion, files: nextFiles }, null, 2) + "\n", "utf8");
+        }
+    }
+    const vendorTargetDir = join(agentPresetsRoot, ".omd-vendor");
+    const vendorMeta = existsSync(vendorTargetDir) ? readMeta(vendorTargetDir) : undefined;
+    if (existsSync(vendorTargetDir) && vendorMeta === undefined) {
+        record("skipped", ".omd-vendor/ (directory exists but is not managed by omd-dsh -- left untouched)");
+    }
+    else {
+        const nextVendorFiles = {};
+        for (const vendorName of VENDOR_SOURCES) {
+            const sourceFile = join(vendorSourceDir, vendorName);
+            if (!existsSync(sourceFile)) {
+                throw new Error("omd-dsh sync: missing vendored source " + sourceFile + " -- run \`npm run build\` first");
+            }
+            let sourceText = await fs.readFile(sourceFile, "utf8");
+            sourceText = rewriteImports(sourceText, harnessNodeModules);
+            const sourceHash = sha256(sourceText);
+            const destFile = join(vendorTargetDir, vendorName);
+            let action = "synced";
+            if (existsSync(destFile)) {
+                const destHash = sha256(await fs.readFile(destFile, "utf8"));
+                const prevHash = vendorMeta?.files?.[vendorName]?.sha256;
+                if (destHash === sourceHash)
+                    action = "up-to-date";
+                else if (prevHash !== undefined && destHash === prevHash)
+                    action = "updated";
+                else
+                    action = "conflict";
+            }
+            if (action === "conflict") {
+                record("conflicts", ".omd-vendor/" + vendorName + " (locally modified -- keeping your version)");
+                if (vendorMeta?.files?.[vendorName]?.sha256 !== undefined)
+                    nextVendorFiles[vendorName] = { sha256: vendorMeta.files[vendorName].sha256 };
+                continue;
+            }
+            if (action === "up-to-date")
+                record("skipped", ".omd-vendor/" + vendorName + " (up to date)");
+            else {
+                if (!flags.dryRun) {
+                    await fs.mkdir(vendorTargetDir, { recursive: true });
+                    await fs.writeFile(destFile, sourceText, "utf8");
+                }
+                record(action === "synced" ? "synced" : "updated", ".omd-vendor/" + vendorName + (flags.dryRun ? " (dry-run)" : ""));
+            }
+            nextVendorFiles[vendorName] = { sha256: sourceHash };
+        }
+        if (!flags.dryRun && VENDOR_SOURCES.length > 0) {
+            await fs.mkdir(vendorTargetDir, { recursive: true });
+            await fs.writeFile(join(vendorTargetDir, ".omd-meta.json"), JSON.stringify({ source: "omd-dsh", sourceVersion, harnessNodeModules, files: nextVendorFiles }, null, 2) + "\n", "utf8");
+        }
+    }
+    if (existsSync(agentPresetsRoot)) {
+        for (const entry of await fs.readdir(agentPresetsRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory() || !entry.name.startsWith("omd-"))
+                continue;
+            if (presetNames.includes(entry.name))
+                continue;
+            const orphanDir = join(agentPresetsRoot, entry.name);
+            const meta = readMeta(orphanDir);
+            if (meta === undefined)
+                continue;
+            const renamedTo = RENAMED_FROM[entry.name];
+            if (renamedTo !== undefined && presetNames.includes(renamedTo)) {
+                const dirty = await locallyModified(orphanDir, meta);
+                if (dirty === undefined) {
+                    if (!flags.dryRun)
+                        await fs.rm(orphanDir, { recursive: true, force: true });
+                    record("removed", entry.name + "/ (renamed to " + renamedTo + " and unmodified -- removed" + (flags.dryRun ? ", dry-run" : "") + ")");
+                }
+                else {
+                    record("conflicts", entry.name + "/ (renamed to " + renamedTo + " but locally modified -- keeping your version: " + dirty + ")");
+                }
+            }
+            else {
+                record("orphan", entry.name + "/ (was installed by omd-dsh but no longer ships with v" + sourceVersion + " -- left untouched)");
+            }
+        }
+    }
+    log("omd-dsh sync: DSH_HOME=" + dshHome());
+    log("omd-dsh sync: matrix=" + MATRIX_PATH + " (customize the model matrix any time with \`omd-dsh setup\`)");
+    log("omd-dsh sync: harness node_modules=" + harnessNodeModules);
+    log("omd-dsh sync: source version=" + sourceVersion + (flags.dryRun ? " (dry-run)" : ""));
+    for (const key of ["synced", "updated", "skipped", "conflicts", "orphan", "removed"])
+        for (const line of report[key])
+            log("  [" + key + "] " + line);
+    const summary = ["synced", "updated", "conflicts", "orphan", "removed"].map((key) => report[key].length + " " + key).join(", ");
+    log("omd-dsh sync: " + summary + (flags.dryRun ? " (dry-run)" : ""));
+}

package/lib/task.js

@@ -2,6 +2,7 @@ import z from "@deepseek-ai/schemastery";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 import { assertSubagentMaxDepth } from "@deepseek-ai/dsh-subagent";
 import { scopeOf } from "@deepseek-ai/dsh-scope";
+import { modeOverrideFor } from "./shared.js";
 /**
  * @module @carljia/omd-dsh/task
  *
@@ -212,9 +213,9 @@ function apply(ctx, config) {
                     throw new Error("omd_task requires a calling agent (exec.agent was undefined)");
                 const tierName = resolveTier(config, args.tier);
                 let tier = config.tiers[tierName];
-                // 用户显式切换模型后（omd-mode 在 agent/request 让路并在作用域 ctx 上记录
-                // omdModeOverride），deep tier 改用用户选择的模型；其余 tier 保持矩阵配置。
-                const override = ctx.omdModeOverride;
+                // 用户显式切换模型后（omd-mode 在 agent/request 让路并把用户选择记入 shared.ts，
+                // 键为顶层 agent 对象），deep tier 改用用户选择的模型；其余 tier 保持矩阵配置。
+                const override = modeOverrideFor(parent);
                 if (tierName === "deep" && override !== undefined
                     && typeof override.provider === "string" && typeof override.model === "string") {
                     tier = { ...tier, provider: override.provider, model: override.model };

package/lib/vendor/omd-mode.mjs

@@ -1,5 +1,6 @@
 import z from "@deepseek-ai/schemastery";
 import { scopeOf } from "@deepseek-ai/dsh-scope";
+import { setModeOverride } from "./shared.js";
 /**
  * @module @carljia/omd-dsh
  *
@@ -31,8 +32,8 @@ import { scopeOf } from "@deepseek-ai/dsh-scope";
  *   - otherwise the user explicitly picked a
  *     different model                            -> yield: the request and
  *       the persona variables keep the user's selection, and the row
- *       records it on the scoped context as `omdModeOverride` so the
- *       omd-task row can route the "deep" tier to the user's model.
+ *       records it (shared.ts, keyed by the agent) so the omd-task row can
+ *       route the "deep" tier to the user's model.
  *
  * When provider/model are not configured the row passes everything
  * through and only serves the persona banner variables (inheriting the
@@ -106,7 +107,8 @@ function apply(ctx, config) {
     }
     catch { /* 读不到默认时退化为仅 entry == pinned 判定 */ }
     // 供同 preset 内的 omd-task 行读取：用户显式切换模型后（本行让路），deep tier 沿用用户选择。
-    ctx.omdModeOverride = undefined;
+    // 注意：不能直接往 cordis 作用域 ctx 上写属性（Proxy 会抛 "without provide"，且行间
+    // ctx 互不可见），因此共享状态放在 shared.ts 的 WeakMap 里，按顶层 agent 对象为键。
     /**
      * 判定一次入口选择是否应钉到模式模型（true），还是让路给用户选择（false）。
      * @param agent - 顶层 agent（子代理已由调用方过滤）。
@@ -162,7 +164,7 @@ function apply(ctx, config) {
         if (pinned === undefined || isSubagent(agent))
             return resolved;
         if (shouldPin(agent, { provider: resolved.provider, model: resolved.model })) {
-            ctx.omdModeOverride = undefined;
+            setModeOverride(agent, undefined);
             const stripped = { ...resolved };
             delete stripped.reasoningEffort;
             const out = {
@@ -176,7 +178,7 @@ function apply(ctx, config) {
             return out;
         }
         // 用户显式选择了别的模型：本次任务顶层路由用用户选择；deep tier 同步（omd-task 读取）。
-        ctx.omdModeOverride = { provider: resolved.provider, model: resolved.model };
+        setModeOverride(agent, { provider: resolved.provider, model: resolved.model });
         return resolved;
     }, { prepend: true });
 }