@noimosai/platform-mcp 0.1.3 → 0.1.4

package/dist/cli/skills.js

@@ -0,0 +1,142 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, open, readdir, rename, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { z } from "zod";
+import { platformSkillsBundleSchema } from "../client/index.js";
+import { safeDirectory, readPrivateJson, readPrivateText, writePrivateJson } from "../client/local-profile.js";
+const digest = (text) => createHash("sha256").update(text, "utf8").digest("hex");
+const manifestSchema = z.object({ managedBy: z.literal("relvo-cli"), version: z.literal(1), bundleVersion: z.string().regex(/^[a-f0-9]{64}$/),
+    skills: z.array(z.object({ name: z.string().regex(/^relvo(?:-[a-z0-9]+)*$/), sha256: z.string().regex(/^[a-f0-9]{64}$/) }).strict()).max(32) }).strict();
+export function verifiedSkillBundle(input) {
+    const bundle = platformSkillsBundleSchema.parse(input);
+    const skills = [...bundle.skills].sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    if (new TextEncoder().encode(JSON.stringify(bundle)).byteLength > 1048576 || skills.some((skill) => new TextEncoder().encode(skill.content).byteLength > 65536 || digest(skill.content) !== skill.sha256) ||
+        digest(JSON.stringify(skills.map(({ name, description, sha256 }) => ({ name, description, sha256 })))) !== bundle.version)
+        throw new Error("Relvo guide integrity verification failed. No local guides were changed.");
+    return { ...bundle, skills };
+}
+const journalSchema = z.object({ managedBy: z.literal("relvo-cli"), version: z.literal(1), transactionId: z.uuid(), previous: manifestSchema.nullable(), bundle: platformSkillsBundleSchema,
+    preserved: z.array(z.string()).optional() }).strict();
+const journalMaximum = 1114112;
+function nextManifest(previous, bundle, preserved = []) {
+    const installed = bundle.skills.filter((skill) => !preserved.includes(skill.name));
+    return manifestSchema.parse({ managedBy: "relvo-cli", version: 1, bundleVersion: bundle.version,
+        skills: [...(previous?.skills.filter((old) => !installed.some((skill) => skill.name === old.name)) ?? []), ...installed.map(({ name, sha256 }) => ({ name, sha256 }))] });
+}
+const guideFiles = async (folder) => (await readdir(folder)).filter((file) => file !== ".DS_Store");
+const missing = (error) => error instanceof Error && "code" in error && error.code === "ENOENT";
+async function readManifest(root) {
+    try {
+        return manifestSchema.parse(await readPrivateJson(join(root, ".relvo-managed.json")));
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return null;
+        throw new Error("Relvo guide manifest is unsafe or invalid. No guides were overwritten.");
+    }
+}
+async function finishJournal(root, journal) {
+    const bundle = verifiedSkillBundle(journal.bundle), preserved = new Set(journal.preserved), current = await readManifest(root);
+    if (![JSON.stringify(journal.previous), JSON.stringify(nextManifest(journal.previous, bundle, journal.preserved))].includes(JSON.stringify(current)))
+        throw new Error("Relvo guide manifest changed during an interrupted update. It was preserved.");
+    const stageName = `.relvo-stage-${journal.transactionId}`;
+    for (const skill of bundle.skills) {
+        if (preserved.has(skill.name))
+            continue;
+        const folder = join(root, skill.name), previous = journal.previous?.skills.find((entry) => entry.name === skill.name);
+        try {
+            await safeDirectory(folder, true, true);
+            const files = await guideFiles(folder);
+            if (files.some((file) => !["SKILL.md", stageName].includes(file)))
+                throw new Error("Unknown files");
+            if (files.includes(stageName)) {
+                await readPrivateText(join(folder, stageName));
+                await unlink(join(folder, stageName));
+            }
+            if (files.includes("SKILL.md")) {
+                const hash = digest(await readPrivateText(join(folder, "SKILL.md")));
+                if (hash !== skill.sha256 && hash !== previous?.sha256)
+                    throw new Error("Edited guide");
+            }
+        }
+        catch {
+            preserved.add(skill.name);
+        }
+    }
+    const installed = bundle.skills.filter((skill) => !preserved.has(skill.name));
+    try {
+        for (const skill of installed) {
+            const stage = join(root, skill.name, stageName), handle = await open(stage, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+            try {
+                await handle.writeFile(skill.content);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+        }
+        for (const skill of installed) {
+            const folder = join(root, skill.name);
+            await rename(join(folder, stageName), join(folder, "SKILL.md"));
+            const directory = await open(folder, constants.O_RDONLY);
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+        }
+        await writePrivateJson(join(root, ".relvo-managed.json"), nextManifest(journal.previous, bundle, [...preserved]), false);
+        await unlink(join(root, ".relvo-update.json"));
+    }
+    catch (error) {
+        for (const skill of installed)
+            await unlink(join(root, skill.name, stageName)).catch(() => { });
+        throw error;
+    }
+    return [...preserved];
+}
+export async function installSkills(home, clients, input) {
+    const bundle = verifiedSkillBundle(input);
+    const targets = [];
+    for (const client of [...new Set(clients)]) {
+        const parent = join(home, client === "claude" ? ".claude" : ".agents"), root = join(parent, "skills");
+        await safeDirectory(home);
+        await safeDirectory(parent, true);
+        await safeDirectory(root, true);
+        try {
+            await finishJournal(root, journalSchema.parse(await readPrivateJson(join(root, ".relvo-update.json"), journalMaximum)));
+        }
+        catch (error) {
+            if (!missing(error))
+                throw error;
+        }
+        const manifest = await readManifest(root), preserved = [];
+        for (const skill of bundle.skills) {
+            const folder = join(root, skill.name), existing = manifest?.skills.find((entry) => entry.name === skill.name);
+            try {
+                const info = await lstat(folder);
+                if (!existing || !info.isDirectory() || info.isSymbolicLink())
+                    throw new Error("Foreign guide");
+                await safeDirectory(folder, false, true);
+                if (JSON.stringify(await guideFiles(folder)) !== '["SKILL.md"]' || digest(await readPrivateText(join(folder, "SKILL.md"))) !== existing.sha256)
+                    throw new Error("Edited guide");
+            }
+            catch (error) {
+                if (!missing(error))
+                    preserved.push(skill.name);
+            }
+        }
+        nextManifest(manifest, bundle, preserved);
+        targets.push({ client, root, manifest, preserved });
+    }
+    const results = [];
+    for (const target of targets) {
+        const journal = { managedBy: "relvo-cli", version: 1, transactionId: randomUUID(), previous: target.manifest, bundle, preserved: target.preserved };
+        await writePrivateJson(join(target.root, ".relvo-update.json"), journal, false, journalMaximum);
+        const preserved = await finishJournal(target.root, { ...journal, preserved: [...target.preserved] });
+        results.push({ client: target.client, version: bundle.version, count: bundle.skills.length - preserved.length, preserved });
+    }
+    return results;
+}

package/dist/cli/team-harness-targets.js

@@ -0,0 +1,337 @@
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { z } from "zod";
+import { TEAM_HARNESSES, TEAM_HARNESS_NAMES } from "../schema/platformTeamSkills.js";
+import { localProfilePath } from "../client/local-profile.js";
+export { TEAM_HARNESSES };
+export const harnessNames = TEAM_HARNESS_NAMES;
+const under = (value, fallback) => value && isAbsolute(value) ? resolve(value) : fallback;
+export function harnessRoots(home, env = {}, custom = []) {
+    const agents = join(home, ".agents"), geminiHome = under(env.GEMINI_CLI_HOME, home);
+    const dirs = { claude: join(home, ".claude"), codex: under(env.CODEX_HOME, join(home, ".codex")),
+        pi: under(env.PI_CODING_AGENT_DIR, join(home, ".pi", "agent")), dsh: under(env.DSH_HOME, join(home, ".dsh")),
+        opencode: under(env.OPENCODE_CONFIG_DIR, join(under(env.XDG_CONFIG_HOME, join(home, ".config")), "opencode")), gemini: join(geminiHome, ".gemini"),
+        kimi: under(env.KIMI_CODE_HOME, join(home, ".kimi-code")), qwen: under(env.QWEN_HOME, join(home, ".qwen")), cursor: join(home, ".cursor"),
+        copilot: under(env.COPILOT_HOME, join(home, ".copilot")), amp: join(home, ".config", "amp"), droid: join(home, ".factory") };
+    return { home, dirs, custom, agents: { claude: agents, codex: agents, pi: agents, dsh: under(env.DSH_AGENTS_HOME, agents), opencode: agents, gemini: join(geminiHome, ".agents"),
+            kimi: agents, qwen: agents, cursor: agents, copilot: agents, amp: agents, droid: agents } };
+}
+const customFile = z.object({ harnesses: z.array(z.object({ name: z.string().regex(/^[a-z][a-z0-9-]{1,30}$/), like: z.enum(TEAM_HARNESSES), dir: z.string().min(1).max(500) }).strict())
+        .max(20) }).strict();
+export const customHarnessesPath = (home) => join(resolve(localProfilePath(home), ".."), "harnesses.json");
+export async function readCustomHarnesses(home) {
+    const path = customHarnessesPath(home);
+    let handle;
+    try {
+        handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW);
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT")
+            return [];
+        throw new Error(`${path} is a link or cannot be read.`);
+    }
+    let text;
+    try {
+        const info = await handle.stat();
+        if (!info.isFile() || info.size > 65536 || typeof process.getuid === "function" && info.uid !== process.getuid())
+            throw new Error(`${path} is not a plain file of yours.`);
+        text = await handle.readFile("utf8");
+    }
+    finally {
+        await handle.close();
+    }
+    let parsed;
+    try {
+        parsed = customFile.parse(JSON.parse(text));
+    }
+    catch {
+        throw new Error(`${path} must be {"harnesses": [{"name", "like", "dir"}]} with lowercase names and a listed agent as like.`);
+    }
+    const builtIn = harnessRoots(home), relvo = resolve(localProfilePath(home), "..");
+    const custom = parsed.harnesses.map(entry => ({ ...entry, dir: entry.dir === "~" || entry.dir.startsWith("~/") ? join(home, entry.dir.slice(1)) : resolve(entry.dir) }));
+    for (const [index, entry] of custom.entries()) {
+        const inside = relative(home, entry.dir);
+        if (!inside || inside.startsWith("..") || inside.startsWith(sep) || isAbsolute(inside))
+            throw new Error(`${path}: ${entry.name}'s dir must be a folder inside your home folder.`);
+        if (entry.dir === relvo || entry.dir.startsWith(`${relvo}${sep}`))
+            throw new Error(`${path}: ${entry.name}'s dir must not be inside Relvo's own folder.`);
+        if (TEAM_HARNESSES.includes(entry.name) || custom.some((other, at) => at < index && other.name === entry.name))
+            throw new Error(`${path}: the name ${entry.name} is taken.`);
+        if (Object.values(builtIn.dirs).includes(entry.dir) || custom.some((other, at) => at < index && other.dir === entry.dir))
+            throw new Error(`${path}: ${entry.name}'s dir is another agent's folder.`);
+    }
+    return custom;
+}
+export function harnessView(roots, name) {
+    if (TEAM_HARNESSES.includes(name))
+        return { name, like: z.enum(TEAM_HARNESSES).parse(name), custom: false, roots };
+    const entry = roots.custom.find(item => item.name === name);
+    if (!entry)
+        throw new Error(`Unknown agent ${name}. Use one of ${[...TEAM_HARNESSES, ...roots.custom.map(item => item.name)].join(", ")}.`);
+    return { name, like: entry.like, custom: true, roots: { ...roots, dirs: { ...roots.dirs, [entry.like]: entry.dir } } };
+}
+export const harnessLabel = (view) => view.custom ? view.name : harnessNames[view.like];
+export async function harnessesPresent(roots) {
+    const present = [];
+    for (const harness of TEAM_HARNESSES) {
+        if (harness === "claude" || harness === "codex") {
+            present.push(harness);
+            continue;
+        }
+        try {
+            if ((await lstat(roots.dirs[harness])).isDirectory())
+                present.push(harness);
+        }
+        catch { }
+    }
+    return [...present, ...roots.custom.map(entry => entry.name)];
+}
+export const skillRoot = (roots, harness) => harness === "claude" ? join(roots.dirs.claude, "skills") : join(roots.agents[harness], "skills");
+export function ownSkillRoot(roots, harness) {
+    if (harness === "claude")
+        return join(roots.dirs.claude, "skills");
+    return harness === "codex" ? null : join(roots.dirs[harness], "skills");
+}
+const none = (reason) => ({ reason });
+export const HARNESS_AGENT_SETTINGS = {
+    codex: { model: "text", model_reasoning_effort: "text", model_reasoning_summary: "text", model_verbosity: "text", personality: "text", service_tier: "text" },
+    opencode: { model: "text", variant: "text", steps: "count", hidden: "boolean", color: "text" },
+    gemini: { model: "text", display_name: "text", temperature: "number", max_turns: "count", timeout_mins: "count" },
+    kimi: { whenToUse: "text" },
+    qwen: { model: "text", maxTurns: "count", background: "boolean" },
+    copilot: { model: "text", "disable-model-invocation": "boolean", "user-invocable": "boolean" },
+    cursor: { model: "text", readonly: "boolean", is_background: "boolean" },
+    droid: { model: "text", reasoningEffort: "text" }
+};
+export function agentTarget(roots, harness) {
+    const { dirs } = roots, md = (dir, suffix = ".md") => (name) => join(dir, `${name}${suffix}`);
+    switch (harness) {
+        case "claude": return { format: "claude", path: md(join(dirs.claude, "agents")) };
+        case "codex": return { format: "codex", path: md(join(dirs.codex, "agents"), ".toml") };
+        case "opencode": return { format: "markdown", path: md(join(dirs.opencode, "agents")), named: false, fields: { mode: "subagent" } };
+        case "gemini": return { format: "markdown", path: md(join(dirs.gemini, "agents")), named: true };
+        case "kimi": return { format: "markdown", path: md(join(dirs.kimi, "agents")), named: true };
+        case "qwen": return { format: "markdown", path: md(join(dirs.qwen, "agents")), named: true };
+        case "copilot": return { format: "markdown", path: md(join(dirs.copilot, "agents"), ".agent.md"), named: true };
+        case "cursor": return { format: "markdown", path: md(join(dirs.cursor, "agents")), named: true };
+        case "droid": return { format: "markdown", path: md(join(dirs.droid, "droids")), named: true };
+        case "pi": return none("Pi has no subagents of its own");
+        case "dsh": return none("deepseek-harness defines agents as YAML presets of plugins, not as instructions");
+        case "amp": return none("Amp adds agents only through plugins");
+    }
+}
+export function ruleTarget(roots, harness) {
+    const { dirs, agents } = roots, block = (path, imports, options = {}) => ({ format: "block", path, before: options.before ?? [], after: options.after ?? [], emptyShadows: options.emptyShadows ?? true, imports,
+        ...options.own ? { own: { path: options.own, imports: options.ownImports ?? imports } } : {} });
+    switch (harness) {
+        case "claude": return { format: "file", path: name => join(dirs.claude, "rules", `${name}.md`), imports: "outside-code" };
+        case "qwen": return { format: "file", path: name => join(dirs.qwen, "rules", `${name}.md`), imports: false };
+        case "codex": return block(join(dirs.codex, "AGENTS.md"), false, { before: [join(dirs.codex, "AGENTS.override.md")], emptyShadows: false });
+        case "pi": return block(join(dirs.pi, "AGENTS.md"), false, { before: [join(dirs.pi, "AGENTS.override.md")], after: ["AGENTS.MD", "CLAUDE.md", "CLAUDE.MD"].map(name => join(dirs.pi, name)) });
+        case "opencode": return block(join(dirs.opencode, "AGENTS.md"), false);
+        case "gemini": return block(join(dirs.gemini, "GEMINI.md"), "anywhere");
+        case "copilot": return block(join(dirs.copilot, "copilot-instructions.md"), "anywhere");
+        case "amp": return block(join(dirs.amp, "AGENTS.md"), "anywhere", { after: [join(roots.home, ".config", "AGENTS.md")] });
+        case "dsh": return block(join(agents.dsh, "AGENTS.md"), "anywhere", { own: join(dirs.dsh, "AGENTS.md"), ownImports: false });
+        case "kimi": return block(join(agents.kimi, "AGENTS.md"), "anywhere", { after: [join(agents.kimi, "agents.md")], own: join(dirs.kimi, "AGENTS.md"), ownImports: false });
+        case "droid": return block(join(agents.droid, "AGENTS.md"), "anywhere", { own: join(dirs.droid, "AGENTS.md"), ownImports: "anywhere" });
+        case "cursor": return none("Cursor keeps user rules in its settings, not in a file");
+    }
+}
+export function instructionsTarget(roots, harness) {
+    if (harness === "claude" || harness === "qwen")
+        return { format: "block", path: join(roots.dirs[harness], harness === "claude" ? "CLAUDE.md" : "QWEN.md"),
+            imports: harness === "claude" ? "outside-code" : "anywhere", before: [], after: [], emptyShadows: true };
+    return ruleTarget(roots, harness);
+}
+const EMAIL_BEFORE = /[A-Za-z0-9._+-]+[@＠][A-Za-z0-9_-]+(?:\.[A-Za-z0-9_-]*[A-Za-z0-9])+$/;
+function referenceAt(text, at) {
+    if (at + 1 >= text.length || /\s/.test(text[at + 1]))
+        return false;
+    return at === 0 || !/[A-Za-z0-9]/.test(text[at - 1]) || EMAIL_BEFORE.test(text.slice(Math.max(0, at - 320), at));
+}
+const lineStarts = (text) => [0, ...[...text.matchAll(/\n/g)].map(match => match.index + 1)];
+function claudeCode(text) {
+    const starts = lineStarts(text), lines = starts.map((start, index) => text.slice(start, index + 1 < starts.length ? starts[index + 1] - 1 : text.length));
+    const blank = (line) => /^[ \t]*$/.test(line), fenceLike = /^[ \t>*+\-0-9.)]*(`{3,}|~{3,})/, htmlStart = /^[ \t>*+\-0-9.)]*</;
+    const ranges = [], prose = [[]];
+    for (let index = 0; index < lines.length; index++) {
+        const line = lines[index];
+        if (htmlStart.test(line))
+            return [];
+        if (fenceLike.test(line)) {
+            const open = /^(`{3,})[^`]*$|^(~{3,})/.exec(line);
+            if (!open || index > 0 && !blank(lines[index - 1]))
+                return [];
+            const fence = open[1] ?? open[2], close = lines.findIndex((next, at) => at > index && /^ {0,3}(`{3,}|~{3,})/.test(next));
+            if (close < 0 || !new RegExp(`^ {0,3}${fence[0]}{${fence.length},} *$`).test(lines[close]))
+                return [];
+            ranges.push([starts[index], starts[close] + lines[close].length]);
+            prose.push([]);
+            index = close;
+            continue;
+        }
+        if (blank(line))
+            prose.push([]);
+        else
+            prose[prose.length - 1].push(index);
+    }
+    for (const paragraph of prose) {
+        const body = paragraph.map(index => lines[index]);
+        if (body.some(line => /[<\\[~]|:\/\/|www\./.test(line) || /``/.test(line) || (line.match(/`/g)?.length ?? 0) % 2))
+            continue;
+        for (const index of paragraph)
+            for (const span of lines[index].matchAll(/`[^`]+`/g))
+                ranges.push([starts[index] + span.index, starts[index] + span.index + span[0].length]);
+    }
+    return ranges;
+}
+export function escapeImports(text, reading) {
+    if (!reading)
+        return { text, escaped: false };
+    const code = reading === "outside-code" ? claudeCode(text) : [];
+    let escaped = false;
+    const result = text.replace(/@/g, (match, at) => {
+        if (!referenceAt(text, at) || code.some(([start, end]) => at >= start && at < end))
+            return match;
+        escaped = true;
+        return "＠";
+    });
+    return { text: result, escaped };
+}
+export const unescapeImports = (text, original = "") => text.replace(/＠/g, (match, at) => referenceAt(text, at) && !original.includes(text.slice(at).split(/\s/u, 1)[0]) ? "@" : match);
+const GEMINI_EVENTS = { PreToolUse: "BeforeTool", PostToolUse: "AfterTool", UserPromptSubmit: "BeforeAgent", Stop: "AfterAgent",
+    SessionStart: "SessionStart", SessionEnd: "SessionEnd", PreCompact: "PreCompress", Notification: "Notification" };
+const GEMINI_TOOLS = { Edit: "replace", Bash: "run_shell_command", Read: "read_file", Write: "write_file", Glob: "glob", Grep: "grep", LS: "ls" };
+const DROID_TOOLS = { Bash: "Execute", Write: "Create", WebFetch: "FetchUrl" };
+const renamed = (tools) => (matcher) => Object.entries(tools).reduce((text, [claude, own]) => text.replace(new RegExp(`\\b${claude}\\b`, "g"), own), matcher);
+const set = (...values) => new Set(values);
+const among = (events) => (event) => events.has(event) ? event : null;
+export function hookTarget(roots, harness) {
+    const { dirs } = roots, scripts = join(dirs[harness], "relvo-team-hooks");
+    switch (harness) {
+        case "claude": return { format: "settings", path: join(dirs.claude, "settings.json"), scripts };
+        case "codex": return { format: "settings", path: join(dirs.codex, "hooks.json"), scripts, trust: true,
+            events: among(set("SessionStart", "SessionEnd", "PreToolUse", "PermissionRequest", "PostToolUse", "PreCompact", "PostCompact", "UserPromptSubmit", "SubagentStart", "SubagentStop", "Stop", "Interrupt")),
+            handlerTypes: set("command", "mcp_tool"),
+            handlerFields: set("type", "command", "commandWindows", "command_windows", "timeout", "statusMessage", "async", "additionalContextLimit", "server", "tool", "input") };
+        case "qwen": return { format: "settings", path: join(dirs.qwen, "settings.json"), scripts,
+            events: among(set("PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "SessionStart", "SessionEnd", "Stop", "StopFailure", "SubagentStart", "SubagentStop", "PreCompact", "PostCompact", "Notification", "PermissionRequest", "PermissionDenied")),
+            handlerTypes: set("command"), handlerFields: set("type", "command", "name", "description", "timeout", "async", "env", "shell", "statusMessage") };
+        case "gemini": return { format: "settings", path: join(dirs.gemini, "settings.json"), scripts, events: event => GEMINI_EVENTS[event] ?? null, matcher: renamed(GEMINI_TOOLS),
+            handlerTypes: set("command"), handlerFields: set("type", "command", "timeout"), command: command => command.replace(/\$CLAUDE_PROJECT_DIR/g, "$GEMINI_PROJECT_DIR") };
+        case "droid": return { format: "settings", path: join(dirs.droid, "settings.json"), topLevel: join(dirs.droid, "hooks.json"), scripts,
+            events: among(set("PreToolUse", "PostToolUse", "UserPromptSubmit", "Notification", "Stop", "SubagentStop", "PreCompact", "SessionStart", "SessionEnd")),
+            matcher: renamed(DROID_TOOLS), handlerTypes: set("command"), handlerFields: set("type", "command", "timeout"),
+            command: command => command.replace(/\$CLAUDE_PROJECT_DIR/g, "$FACTORY_PROJECT_DIR") };
+        case "copilot": return { format: "file", path: join(dirs.copilot, "hooks", "relvo-team.json"), scripts,
+            events: among(set("PreToolUse", "PostToolUse", "PostToolUseFailure", "UserPromptSubmit", "SessionStart", "SessionEnd", "Stop", "SubagentStop", "PreCompact")),
+            handlerTypes: set("command"), handlerFields: set("type", "command", "timeout"), fieldNames: { timeout: "timeoutSec" } };
+        case "pi": return { format: "plugin", folder: join(dirs.pi, "extensions"), entries: ["index.ts", "index.js", "package.json"],
+            shadows: [{ path: join(dirs.pi, "extensions", "index.ts") }, { path: join(dirs.pi, "extensions", "index.js") },
+                { path: join(dirs.pi, "extensions", "package.json"), when: json => z.object({ pi: z.object({ extensions: z.array(z.unknown()).min(1) }) }).safeParse(json).success }] };
+        case "opencode": return { format: "plugin", folder: join(dirs.opencode, "plugins"), shadows: [],
+            entries: ["package.json", ...["server", "index"].flatMap(name => [".ts", ".tsx", ".js"].map(extension => `${name}${extension}`))] };
+        case "amp": return { format: "plugin", folder: join(dirs.amp, "plugins"), entries: ["index.ts", "index.js"], shadows: [] };
+        case "cursor": return none("Cursor already runs the hooks sync writes for Claude Code in ~/.claude/settings.json, so a second copy would run each twice");
+        case "dsh": return none("deepseek-harness runs Claude Code hooks only through an experimental plugin");
+        case "kimi": return none(KIMI_CONFIG);
+    }
+}
+const KIMI_CONFIG = "one invalid entry makes Kimi Code drop every hook and permission rule of config.toml, the user's too, and its rewrites can drop the comments sync finds its own entries by";
+const stdio = (server) => ({ command: server.command, args: server.args ?? [], ...(server.env ? { env: server.env } : {}) });
+const headers = (server, variable) => {
+    const all = { ...server.headers, ...(server.bearerTokenEnvVar ? { Authorization: `Bearer ${variable(server.bearerTokenEnvVar)}` } : {}) };
+    return Object.keys(all).length ? { headers: all } : {};
+};
+const braced = (name) => `\${${name}}`;
+export function mcpTarget(roots, harness) {
+    const { dirs } = roots, json = (paths, at, entry) => ({ format: "json", paths, at, entry });
+    switch (harness) {
+        case "claude":
+        case "codex": return { format: "cli" };
+        case "pi": return json([join(dirs.pi, "mcp.json")], "mcpServers", (_, server) => "url" in server ? { url: server.url, ...headers(server, braced) } : stdio(server));
+        case "opencode": return json([join(dirs.opencode, "opencode.jsonc"), join(dirs.opencode, "opencode.json")], "mcp", (_, server) => "url" in server
+            ? { type: "remote", url: server.url, ...headers(server, name => `{env:${name}}`) }
+            : { type: "local", command: [server.command, ...server.args ?? []], ...(server.env ? { environment: server.env } : {}) });
+        case "gemini":
+        case "qwen": return json([join(dirs[harness], "settings.json")], "mcpServers", (_, server) => "url" in server
+            ? { httpUrl: server.url, ...headers(server, braced) } : stdio(server));
+        case "kimi": return json([join(dirs.kimi, "mcp.json")], "mcpServers", (_, server) => "url" in server
+            ? { url: server.url, ...(server.headers ? { headers: server.headers } : {}), ...(server.bearerTokenEnvVar ? { bearerTokenEnvVar: server.bearerTokenEnvVar } : {}) } : stdio(server));
+        case "cursor": return json([join(dirs.cursor, "mcp.json")], "mcpServers", (_, server) => "url" in server
+            ? { url: server.url, ...headers(server, name => `\${env:${name}}`) } : stdio(server));
+        case "copilot": return json([join(dirs.copilot, "mcp-config.json")], "mcpServers", (_, server) => {
+            if (!("url" in server))
+                return { type: "local", ...stdio(server), tools: ["*"] };
+            if (server.bearerTokenEnvVar)
+                return "GitHub Copilot CLI does not document reading a token from the environment; add this server yourself";
+            return { type: "http", url: server.url, ...(server.headers ? { headers: server.headers } : {}), tools: ["*"] };
+        });
+        case "amp": return json([join(dirs.amp, "settings.json")], "amp.mcpServers", (_, server) => "url" in server ? { url: server.url, ...headers(server, braced) } : stdio(server));
+        case "droid": return json([join(dirs.droid, "mcp.json")], "mcpServers", (_, server) => "url" in server
+            ? { type: "http", url: server.url, ...headers(server, braced) } : { type: "stdio", ...stdio(server) });
+        case "dsh": return { format: "dsh", path: join(dirs.dsh, "cordis.patch.yml") };
+    }
+}
+export function dshMcpRow(name, server) {
+    if (name.length > 32)
+        return "deepseek-harness takes MCP server names of at most 32 characters";
+    if ("url" in server) {
+        if (server.bearerTokenEnvVar)
+            return "deepseek-harness reads a token from the environment only through code in its configuration; add this server yourself";
+        return { id: name, name: "@deepseek-ai/dsh-mcp-client", config: { serverName: name, transport: "streamable-http", url: server.url, headers: server.headers ?? {} } };
+    }
+    return { id: name, name: "@deepseek-ai/dsh-mcp-client", config: { serverName: name, transport: "stdio", command: server.command, args: server.args ?? [], env: server.env ?? {} } };
+}
+const bashCommand = (rule) => {
+    const match = /^Bash\((.*)\)$/s.exec(rule.trim());
+    if (!match)
+        return null;
+    const command = match[1].trim();
+    return command.endsWith(":*") || command.endsWith(" *") ? { command: command.slice(0, -2).trim(), prefix: true } : { command, prefix: false };
+};
+function opencodeShell(rule, list) {
+    const bash = bashCommand(rule);
+    if (!bash || !bash.command || bash.command.includes("?") || list === "allow" && bash.command.includes("*"))
+        return null;
+    return bash.prefix ? `${bash.command} *` : bash.command;
+}
+function cursorShell(rule, list) {
+    const bash = bashCommand(rule);
+    if (list === "ask" || !bash || !/^[A-Za-z0-9._/-]+$/.test(bash.command) || list === "allow" && !bash.prefix)
+        return null;
+    return `Shell(${bash.command})`;
+}
+const QWEN_TOOLS = set("Bash", "Read", "Edit", "Write", "Glob", "Grep", "NotebookEdit", "WebFetch");
+function qwenRule(rule) {
+    const match = /^([A-Za-z]+)(?:\((.*)\))?$/s.exec(rule.trim());
+    if (!match)
+        return /^mcp__[A-Za-z0-9_-]+(?:__[A-Za-z0-9_-]+)?$/.test(rule.trim()) ? rule.trim() : null;
+    const [, tool, specifier] = match;
+    if (!QWEN_TOOLS.has(tool))
+        return null;
+    if (specifier === undefined)
+        return tool;
+    if (tool === "WebFetch")
+        return null;
+    return tool === "Bash" && specifier.endsWith(":*") ? `Bash(${specifier.slice(0, -2).trimEnd()} *)` : `${tool}(${specifier})`;
+}
+export function permissionTarget(roots, harness) {
+    const { dirs } = roots;
+    switch (harness) {
+        case "claude": return { format: "settings", path: join(dirs.claude, "settings.json"), translate: rule => rule };
+        case "qwen": return { format: "settings", path: join(dirs.qwen, "settings.json"), translate: qwenRule };
+        case "codex": return { format: "codex-rules", path: join(dirs.codex, "rules", "relvo-team.rules") };
+        case "gemini": return { format: "gemini-policy", path: join(dirs.gemini, "policies", "relvo-team.toml") };
+        case "pi": return none("Pi has no permission rules; its extensions decide");
+        case "dsh": return none("deepseek-harness has sandbox and approval modes, not rules per command");
+        case "opencode": return { format: "opencode", paths: [join(dirs.opencode, "opencode.jsonc"), join(dirs.opencode, "opencode.json")], translate: opencodeShell };
+        case "cursor": return { format: "settings", path: join(dirs.cursor, "cli-config.json"), translate: cursorShell, existing: true };
+        case "droid": return { format: "droid", path: join(dirs.droid, "settings.json") };
+        case "kimi": return none(KIMI_CONFIG);
+        case "copilot": return none("GitHub Copilot CLI takes permissions only as command-line flags");
+        case "amp": return none("Amp has no rules per command, only for MCP servers");
+    }
+}