@carljia/omd-dsh 0.1.5 → 0.1.7

package/lib/shared.js

@@ -0,0 +1,28 @@
+/**
+ * @module @carljia/omd-dsh/shared
+ *
+ * Per-agent transient state shared between the omd-mode and omd-task rows.
+ *
+ * Why this module exists: cordis scoped contexts are proxies — assigning an
+ * undeclared property throws ("cannot set property ... without provide"), and
+ * two rows in one preset are sibling contexts that cannot see each other's
+ * declared properties either. Both rows therefore import this module, and the
+ * sync ships it next to them (`.omd-vendor/shared.js`), so the two vendored
+ * rows resolve the SAME module instance and share one WeakMap. The override is
+ * keyed by the top-level agent object (stable across a session's turns; a
+ * resumed session mints a new agent and starts clean; subagents are distinct
+ * objects and simply miss the map, which is exactly the documented passthrough
+ * semantics).
+ */
+const modeOverrides = new WeakMap();
+/** Record (or clear, with `undefined`) the user's model pick for one agent. */
+export function setModeOverride(agent, override) {
+    if (override === undefined)
+        modeOverrides.delete(agent);
+    else
+        modeOverrides.set(agent, override);
+}
+/** The user's recorded model pick for one agent, or undefined. */
+export function modeOverrideFor(agent) {
+    return modeOverrides.get(agent);
+}

package/lib/sync.d.ts

@@ -0,0 +1,62 @@
+/**
+ * omd-dsh sync core — materialize the OMD presets into <DSH_HOME>/.agent-presets.
+ *
+ * Shared by the CLI (\`omd-dsh sync\`) and the bundle boot row (\`dsh plugin add\`
+ * + restart): locate the DSH harness node_modules, render each preset's
+ * omd-mode / omd-task rows from the user's model matrix, copy the presets and
+ * vendored row modules into .agent-presets, and rewrite the vendored modules'
+ * bare @deepseek-ai/* imports to absolute file:// URLs into the harness tree so
+ * the rows share ONE module instance with the harness (scope symbols etc.).
+ */
+export type SyncFlags = {
+    harness?: string;
+    dryRun: boolean;
+    verbose: boolean;
+};
+export interface TierConfig {
+    provider: string;
+    model: string;
+    hint?: string;
+    persona?: string;
+    maxTokens?: number;
+    toolFilter?: {
+        allow?: string[];
+        deny?: string[];
+        denyShell?: boolean;
+    };
+}
+export interface ModeConfig {
+    provider?: string;
+    model?: string;
+    reasoningEffort?: string;
+    tiers?: Record<string, TierConfig>;
+}
+export interface Matrix {
+    version: number;
+    defaults?: {
+        provider?: string;
+    };
+    modes: Record<string, ModeConfig>;
+}
+export declare const PACKAGE_ROOT: string;
+export declare const VENDOR_SOURCES: string[];
+/** User-owned model matrix: lives under DSH_HOME, never inside the package or the repo. */
+export declare const MATRIX_PATH: string;
+export declare function dshHome(): string;
+/**
+ * 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 declare function resolveHarness(flags: SyncFlags): string | undefined;
+/**
+ * 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 declare function resolveHarnessFromSelf(): string | undefined;
+export declare function loadMatrix(flags: SyncFlags, log?: (msg: string) => void): Matrix;
+export declare function saveMatrix(m: Matrix): void;
+export declare function runSync(flags: SyncFlags, harnessNodeModules: string, log?: (msg: string) => void): Promise<void>;

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 };