@intutic/sync-daemon 2.1.0 → 2.2.0

package/dist/disconnect/harnesses.js

@@ -0,0 +1,728 @@
+/**
+ * harnesses.ts — the reverse of every file `intutic connect` writes, harness
+ * by harness.
+ *
+ * Each entry names the files one harness's writers touch (its rules file,
+ * its gate script and hook registrations, its proxy routing, its MCP
+ * config) and how each is undone. The writers themselves are the source:
+ * `tools/cli/src/harness/*.ts` (the connect adapters),
+ * `services/sync-daemon/src/harness/*Hooks.ts` and `mcpAutoWrite.ts`.
+ *
+ * Workspace files are undone in every workspace in the context; user-level
+ * files once. A file two harnesses share (`AGENTS.md`, `.env.intutic`) is
+ * undone only when none of the harnesses that write it stays connected.
+ *
+ * @module
+ */
+import * as node_path from 'node:path';
+import * as node_os from 'node:os';
+import * as node_fs from 'node:fs/promises';
+import { isDeepStrictEqual } from 'node:util';
+import { isSeq, parseDocument } from 'yaml';
+import { parse as parseToml } from 'smol-toml';
+import { claudeDesktopConfigPath, continueConfigPath, cursorGlobalConfigPath, gooseConfigPath, grokUserConfigPath, museConfigPath, openCodeGlobalConfigPath, windsurfConfigPath, } from '../harness/mcpAutoWrite.js';
+import { jetbrainsConfigRoot } from '../harness/windsurfJetBrainsProxy.js';
+import { windsurfSettingsPath } from '../harness/windsurfHooks.js';
+import { resolveClaudeDesktopConfigPath } from '../harness/claudeDesktopHooks.js';
+import { parseComponentOptions, serializeComponentOptions } from '../harness/jetbrainsXmlConfig.js';
+import { resolveDshHome, listDshProfileDirs } from '../harness/dshHooks.js';
+import { stripOwnHeader as stripAiderHeader, AIDER_SOPS_FILE } from '../harness/aiderConfigMerger.js';
+import { parseJson5Like } from '../harness/openclawHooks.js';
+import { unharden } from '../harness/gooseHardener.js';
+import { pruneLedger } from './originals.js';
+import { allEdits, deleteFile, deletePath, getPath, isObject, jsonFormat, orderLike, pruneEmpty, removeFromArray, restoreKey, restoreMatchingValues, reverseOwnedFile, reverseStructuredFile, reverseTextFile, setPath, tomlFormat, yamlFormat, } from './plan.js';
+import { unwrapClaudeState, unwrapContinueServers, unwrapOpenCodeServers, unwrapServersAt, } from './mcp.js';
+import { contains, isGateCommandEntry, isGateEntry, runsGate, startsWithRulesHeader } from './recognise.js';
+import { lineValue, removeEmptyTable, removeTable, restoreKeyLine, tomlSections } from './tomlLines.js';
+const home = () => node_os.homedir();
+const join = node_path.join;
+// ─── Shared shapes ───────────────────────────────────────────────────────────
+/** Deletes a file in one of Intutic's own directories (`.intutic/`, `~/.intutic/`). */
+async function intuticFile(plan, file) {
+    if (!plan.claim(file))
+        return;
+    try {
+        await node_fs.access(file);
+    }
+    catch {
+        return;
+    }
+    plan.change(file, 'delete (Intutic file)', () => deleteFile(file));
+}
+/** Deletes gate scripts from a workspace's (or the home) `.intutic/hooks/`. */
+async function gateScripts(plan, root, names) {
+    for (const name of names)
+        await intuticFile(plan, join(root, '.intutic', 'hooks', name));
+    plan.removeIfEmpty(join(root, '.intutic', 'hooks'));
+}
+/** A rules file Intutic writes whole, with the generated header first. */
+async function rulesFile(plan, file, workspaceRoot) {
+    await reverseOwnedFile(plan, file, workspaceRoot, startsWithRulesHeader);
+}
+async function json(plan, file, workspaceRoot, edit, deleteIfEmptyWithoutRecord = false) {
+    await reverseStructuredFile(plan, file, workspaceRoot, jsonFormat, edit, { deleteIfEmptyWithoutRecord });
+}
+/** `{ hooks: { <event>: [{ matcher, hooks: [{ command }] }] } }`, the Claude-Code-style shape. */
+function removeGateEntries(doc, ctx, events, script) {
+    return allEdits(...events.map((event) => removeFromArray(doc, ['hooks', event], isGateEntry(script), ctx.original)));
+}
+/** A key Intutic adds when it is missing (a schema version, a format version): removed when the original lacked it. */
+function removeAddedKey(doc, path, ctx) {
+    if (ctx.original === null || getPath(ctx.original, path) !== undefined || getPath(doc, path) === undefined)
+        return false;
+    return deletePath(doc, path);
+}
+/** Keys Intutic stamps for provenance; never the user's. */
+function removeOwnKeys(doc, keys) {
+    return allEdits(...keys.map((k) => deletePath(doc, [k])));
+}
+const startsWith = (prefix) => (v) => typeof v === 'string' && v.startsWith(prefix);
+/** Runs `fn` only when none of `writers` stays connected. */
+async function sharedBy(ctx, writers, fn) {
+    if (writers.some((h) => ctx.remaining.has(h)))
+        return;
+    await fn();
+}
+async function forEachWorkspace(ctx, fn) {
+    for (const root of ctx.workspaceRoots)
+        await fn(root);
+}
+// ─── Claude Code ─────────────────────────────────────────────────────────────
+const CLAUDE_GATES = ['claude-code-check.js', 'pre-tool-check.js'];
+function isClaudeGateEntry(entry) {
+    return CLAUDE_GATES.some((script) => isGateEntry(script)(entry));
+}
+/**
+ * Puts `permissions.deny` back. The writer records the rules it added
+ * (`intuticDeny`); a rule the user added since stays. In the workspace file
+ * the writer replaced the list outright, so the original rules come back; in
+ * the user file it only ever added, so an original rule missing now was
+ * removed by the user and stays removed.
+ */
+function restoreDeny(doc, ctx, replaced) {
+    const deny = getPath(doc, ['permissions', 'deny']);
+    if (!Array.isArray(deny))
+        return false;
+    const recorded = ctx.record?.meta?.intuticDeny;
+    if (!Array.isArray(recorded)) {
+        if (deny.length > 0)
+            ctx.note('permissions.deny may hold rules an earlier Intutic version added without recording them; review it');
+        return false;
+    }
+    const added = new Set(recorded);
+    const originalValue = ctx.original ? getPath(ctx.original, ['permissions', 'deny']) : undefined;
+    const originalDeny = Array.isArray(originalValue) ? originalValue : [];
+    const kept = replaced ? originalDeny : originalDeny.filter((r) => deny.includes(r));
+    const next = [...kept, ...deny.filter((r) => !originalDeny.includes(r) && !added.has(r))];
+    if (isDeepStrictEqual(next, deny))
+        return false;
+    if (next.length === 0 && originalValue === undefined) {
+        deletePath(doc, ['permissions', 'deny']);
+        pruneEmpty(doc, ['permissions'], ctx.original);
+    }
+    else {
+        setPath(doc, ['permissions', 'deny'], next);
+    }
+    return true;
+}
+function claudeSettings(plan, file, workspaceRoot, replacedDeny) {
+    return json(plan, file, workspaceRoot, (doc, ctx) => {
+        const hooks = removeFromArray(doc, ['hooks', 'PreToolUse'], isClaudeGateEntry, ctx.original);
+        return allEdits(hooks, (hooks || ctx.record !== null) && restoreDeny(doc, ctx, replacedDeny));
+    });
+}
+const claudeCode = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await rulesFile(plan, join(root, 'CLAUDE.md'), root);
+        await claudeSettings(plan, join(root, '.claude', 'settings.json'), root, true);
+        await gateScripts(plan, root, ['claude-code-check.js']);
+        await sharedBy(ctx, ['claude-code', 'cursor'], () => gateScripts(plan, root, ['pre-tool-check.js']));
+    });
+    await claudeSettings(plan, join(home(), '.claude', 'settings.json'), home(), false);
+    // Claude Code's own state file: only the MCP maps are Intutic's, and it is never restored whole.
+    await json(plan, join(home(), '.claude.json'), home(), (doc) => unwrapClaudeState(doc));
+};
+// ─── Claude Desktop ──────────────────────────────────────────────────────────
+const claudeDesktop = async (plan, ctx) => {
+    await forEachWorkspace(ctx, (root) => gateScripts(plan, root, ['claude-desktop-check.js']));
+    // The MCP writer and the hook writer agree on the path except on Windows.
+    for (const file of new Set([claudeDesktopConfigPath(), resolveClaudeDesktopConfigPath()])) {
+        await json(plan, file, home(), (doc, c) => allEdits(unwrapServersAt(doc, ['mcpServers'], c.original), removeGateEntries(doc, c, ['PreToolUse'], 'claude-desktop-check.js')));
+    }
+};
+// ─── Cursor ──────────────────────────────────────────────────────────────────
+const CURSOR_EVENTS = ['beforeShellExecution', 'beforeMCPExecution', 'preToolUse'];
+function cursorHooks(plan, file, workspaceRoot) {
+    return json(plan, file, workspaceRoot, (doc, c) => {
+        const removed = allEdits(...CURSOR_EVENTS.map((e) => removeFromArray(doc, ['hooks', e], isGateCommandEntry('cursor-check.js'), c.original)));
+        if (!removed)
+            return false;
+        // The writer adds `version: 1` when the file has none.
+        if (c.original !== null)
+            removeAddedKey(doc, ['version'], c);
+        else if (Object.keys(doc).length === 1 && doc.version === 1)
+            delete doc.version;
+        return true;
+    }, true);
+}
+const cursor = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await rulesFile(plan, join(root, '.cursorrules'), root);
+        await gateScripts(plan, root, ['cursor-check.js']);
+        await cursorHooks(plan, join(root, '.cursor', 'hooks.json'), root);
+        await json(plan, join(root, '.cursor', 'mcp.json'), root, (doc, c) => unwrapServersAt(doc, ['mcpServers'], c.original), true);
+        await sharedBy(ctx, ['claude-code', 'cursor'], () => gateScripts(plan, root, ['pre-tool-check.js']));
+    });
+    await cursorHooks(plan, join(home(), '.cursor', 'hooks.json'), home());
+    await json(plan, cursorGlobalConfigPath(), home(), (doc, c) => unwrapServersAt(doc, ['mcpServers'], c.original));
+};
+// ─── Windsurf ────────────────────────────────────────────────────────────────
+const CASCADE_EVENTS = ['pre_run_command', 'pre_write_code', 'pre_mcp_tool_use'];
+function cascadeHooks(plan, file, workspaceRoot) {
+    return json(plan, file, workspaceRoot, (doc, c) => allEdits(...CASCADE_EVENTS.map((e) => removeFromArray(doc, ['hooks', e], isGateCommandEntry('windsurf-check.js'), c.original))), true);
+}
+/**
+ * Desktop's `settings.json`: the two proxy keys, and the TLS check the writer
+ * switched off with them. Both keys naming the same loopback listener with
+ * the check off is the writer's signature, recognised even when connect
+ * predates the recorded proxy URLs; the listener is then passed on, for the
+ * JetBrains settings it also pointed there. Both the settings file Windsurf
+ * reads and `~/.codeium/windsurf/settings.json`, where earlier versions wrote
+ * the keys.
+ */
+async function windsurfProxySettings(plan, ctx) {
+    let listener = null;
+    for (const file of [windsurfSettingsPath(), join(home(), '.codeium', 'windsurf', 'settings.json')]) {
+        listener = (await windsurfProxySettingsFile(plan, ctx, file)) ?? listener;
+    }
+    return listener;
+}
+async function windsurfProxySettingsFile(plan, ctx, file) {
+    let listener = null;
+    await json(plan, file, home(), (doc, c) => {
+        const proxy = doc['http.proxy'];
+        const signature = typeof proxy === 'string' && /^http:\/\/127\.0\.0\.1:\d+$/.test(proxy) && doc['codeium.proxy'] === proxy && doc['http.proxyStrictSSL'] === false;
+        if (signature)
+            listener = proxy;
+        const isOurs = (v) => ctx.isProxyUrl(v) || (signature && v === proxy);
+        const proxied = allEdits(restoreKey(doc, ['http.proxy'], c, isOurs), restoreKey(doc, ['codeium.proxy'], c, isOurs));
+        if (!proxied)
+            return false;
+        restoreKey(doc, ['http.proxyStrictSSL'], c, (v) => v === false);
+        return true;
+    });
+    return listener;
+}
+/** A JetBrains `options/*.xml` settings file, as one component's options. */
+function xmlComponentFormat(component) {
+    return {
+        parse(raw) {
+            const parsed = parseComponentOptions(raw, component);
+            if (parsed === null)
+                throw new Error('not a JetBrains settings file');
+            return parsed;
+        },
+        toJS: (file) => structuredClone(file),
+        write: (_file, next) => serializeComponentOptions(next, component),
+    };
+}
+const JETBRAINS_PROXY_OPTIONS = ['USE_HTTP_PROXY', 'USE_PROXY_PAC', 'PROXY_TYPE_IS_SOCKS', 'PROXY_HOST', 'PROXY_PORT'];
+/**
+ * The JetBrains platform proxy the writer pointed at the Intutic proxy, and
+ * the Windsurf plugin's "Detect proxy" toggle it switched on, in every IDE
+ * where it did.
+ */
+async function jetbrainsProxy(plan, ctx, listener) {
+    const root = jetbrainsConfigRoot();
+    if (!root)
+        return;
+    let products;
+    try {
+        products = await node_fs.readdir(root);
+    }
+    catch {
+        return;
+    }
+    for (const product of products) {
+        const options = join(root, product, 'options');
+        let reverted = false;
+        await reverseStructuredFile(plan, join(options, 'proxy.settings.xml'), home(), xmlComponentFormat('HttpConfigurable'), (doc, c) => {
+            const host = getPath(doc, ['options', 'PROXY_HOST']);
+            const port = getPath(doc, ['options', 'PROXY_PORT']);
+            const url = `http://${host}:${port}`;
+            if (typeof host !== 'string' || typeof port !== 'string' || !(ctx.isProxyUrl(url) || url === listener))
+                return false;
+            for (const key of JETBRAINS_PROXY_OPTIONS) {
+                const was = c.original ? getPath(c.original, ['options', key]) : undefined;
+                if (was === undefined)
+                    deletePath(doc, ['options', key]);
+                else
+                    setPath(doc, ['options', key], was);
+            }
+            if (c.original === null)
+                c.note('the IDE proxy was switched off rather than restored: an earlier Intutic version set it without keeping the previous setting');
+            reverted = true;
+            return true;
+        }, { deleteIfEmptyWithoutRecord: true });
+        if (!reverted)
+            continue;
+        await reverseStructuredFile(plan, join(options, 'CodeiumSettings.xml'), home(), xmlComponentFormat('com.codeium.intellij.settings.AppSettingsState'), (doc, c) => {
+            if (c.original === null || getPath(doc, ['options', 'detectProxy']) !== 'true')
+                return false;
+            const was = getPath(c.original, ['options', 'detectProxy']);
+            if (was === 'true')
+                return false;
+            if (was === undefined)
+                deletePath(doc, ['options', 'detectProxy']);
+            else
+                setPath(doc, ['options', 'detectProxy'], was);
+            return true;
+        });
+    }
+}
+const windsurf = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await rulesFile(plan, join(root, '.windsurfrules'), root);
+        await gateScripts(plan, root, ['windsurf-check.js']);
+        await cascadeHooks(plan, join(root, '.windsurf', 'hooks.json'), root);
+    });
+    await cascadeHooks(plan, join(home(), '.codeium', 'windsurf', 'hooks.json'), home());
+    await cascadeHooks(plan, join(home(), '.codeium', 'hooks.json'), home());
+    const listener = await windsurfProxySettings(plan, ctx);
+    await jetbrainsProxy(plan, ctx, listener);
+    await json(plan, windsurfConfigPath(), home(), (doc, c) => unwrapServersAt(doc, ['mcpServers'], c.original));
+};
+// ─── GitHub Copilot ──────────────────────────────────────────────────────────
+const OWN_HOOK_FILE = contains('Intutic governance hook');
+const githubCopilot = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await rulesFile(plan, join(root, '.github', 'copilot-instructions.md'), root);
+        await gateScripts(plan, root, ['github-copilot-check.js']);
+        await reverseOwnedFile(plan, join(root, '.github', 'hooks', 'intutic-governance.json'), root, OWN_HOOK_FILE);
+    });
+    await reverseOwnedFile(plan, join(home(), '.copilot', 'hooks', 'intutic-governance.json'), home(), OWN_HOOK_FILE);
+};
+// ─── AGENTS.md writers: Muse Code, Grok Build, OpenCode ──────────────────────
+const AGENTS_MD_WRITERS = ['muse-code', 'grok', 'opencode'];
+async function agentsMd(plan, ctx) {
+    await sharedBy(ctx, AGENTS_MD_WRITERS, () => forEachWorkspace(ctx, (root) => rulesFile(plan, join(root, 'AGENTS.md'), root)));
+}
+const MUSE_EVENTS = ['PreToolUse', 'PermissionRequest'];
+const muse = async (plan, ctx) => {
+    await agentsMd(plan, ctx);
+    await forEachWorkspace(ctx, async (root) => {
+        await gateScripts(plan, root, ['muse-check.js']);
+        await json(plan, join(root, '.muse', 'hooks.json'), root, (doc, c) => allEdits(removeGateEntries(doc, c, MUSE_EVENTS, 'muse-check.js'), restoreKey(doc, ['description'], c, startsWith('Intutic governance hooks'))), true);
+    });
+    const museDir = node_path.dirname(museConfigPath());
+    await reverseOwnedFile(plan, join(museDir, 'intutic-managed-hooks.json'), home(), contains('Intutic governance hooks'));
+    await json(plan, museConfigPath(), home(), (doc, c) => {
+        const changed = allEdits(unwrapServersAt(doc, ['mcp_servers'], c.original), restoreKey(doc, ['managed_hooks_path'], c, (v) => typeof v === 'string' && v.endsWith('intutic-managed-hooks.json')));
+        // Both writers add `schema_version` to a file that has none.
+        if (changed)
+            removeAddedKey(doc, ['schema_version'], c);
+        return changed;
+    });
+};
+function grokConfig(plan, file, workspaceRoot, ctx) {
+    return reverseStructuredFile(plan, file, workspaceRoot, tomlFormat, (doc, c) => {
+        const models = isObject(doc.model) ? Object.keys(doc.model) : [];
+        return allEdits(unwrapServersAt(doc, ['mcp_servers'], c.original), ...models.map((name) => restoreKey(doc, ['model', name, 'base_url'], c, ctx.isProxyUrl)));
+    });
+}
+const grok = async (plan, ctx) => {
+    await agentsMd(plan, ctx);
+    await forEachWorkspace(ctx, async (root) => {
+        await gateScripts(plan, root, ['grok-check.js']);
+        await reverseOwnedFile(plan, join(root, '.grok', 'hooks', 'intutic-governance.json'), root, OWN_HOOK_FILE);
+        await grokConfig(plan, join(root, '.grok', 'config.toml'), root, ctx);
+    });
+    await reverseOwnedFile(plan, join(home(), '.grok', 'hooks', 'intutic-governance.json'), home(), OWN_HOOK_FILE);
+    await grokConfig(plan, grokUserConfigPath(), home(), ctx);
+};
+const OWN_PLUGIN = contains('Intutic OpenCode governance plugin.');
+const opencode = async (plan, ctx) => {
+    await agentsMd(plan, ctx);
+    await forEachWorkspace(ctx, async (root) => {
+        const plugins = join(root, '.opencode', 'plugins');
+        await reverseOwnedFile(plan, join(plugins, 'intutic-governance.js'), root, OWN_PLUGIN);
+        await reverseOwnedFile(plan, join(plugins, 'intutic-governance', 'index.js'), root, OWN_PLUGIN);
+        plan.removeIfEmpty(join(plugins, 'intutic-governance'));
+        await json(plan, join(root, 'opencode.json'), root, (doc, c) => unwrapOpenCodeServers(doc, c.original));
+    });
+    await json(plan, openCodeGlobalConfigPath(), home(), (doc, c) => unwrapOpenCodeServers(doc, c.original));
+};
+// ─── Roo Code, Cline ─────────────────────────────────────────────────────────
+const rooCode = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        const rules = join(root, '.roorules');
+        let isDir = false;
+        try {
+            isDir = (await node_fs.stat(rules)).isDirectory();
+        }
+        catch {
+            // Absent.
+        }
+        if (isDir) {
+            await rulesFile(plan, join(rules, 'README.md'), root);
+            await reverseOwnedFile(plan, join(rules, 'hooks', 'hooks.json'), root, contains('roo-check.js'));
+        }
+        else {
+            await rulesFile(plan, rules, root);
+        }
+        await gateScripts(plan, root, ['roo-check.js']);
+    });
+};
+const cline = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await rulesFile(plan, join(root, '.clinerules', 'intutic-governance.md'), root);
+        await reverseOwnedFile(plan, join(root, '.clinerules', 'hooks', 'PreToolUse'), root, contains('Intutic Cline PreToolUse governance gate.'));
+        await json(plan, join(root, '.cline', 'mcp.json'), root, (doc, c) => unwrapServersAt(doc, ['mcpServers'], c.original), true);
+    });
+};
+// ─── Codex and the SDK adapters (.env.intutic) ───────────────────────────────
+/** Every adapter that writes `.env.intutic`. */
+export const ENV_INTUTIC_WRITERS = [
+    'codex',
+    'langgraph',
+    'langchain',
+    'crewai',
+    'autogen',
+    'ag2',
+    'google-adk',
+    'openai-agents',
+    'pydantic-ai',
+    'smolagents',
+    'strands',
+    'agent-framework',
+    'mastra',
+    'vercel-ai-sdk',
+    'eve',
+    'trueforge',
+    'ai-sdk-harness',
+    'ai-sdk-workflow',
+];
+async function envIntutic(plan, ctx) {
+    await sharedBy(ctx, ENV_INTUTIC_WRITERS, () => forEachWorkspace(ctx, (root) => rulesFile(plan, join(root, '.env.intutic'), root)));
+}
+/** The comment `codexConfigMerger.ts` writes above the key it inserts. */
+const CODEX_KEY_COMMENT = "# Set by Intutic: routes Codex's built-in OpenAI provider through the Intutic proxy.";
+function codexHome() {
+    return process.env.CODEX_HOME || join(home(), '.codex');
+}
+function codexConfig(plan, ctx) {
+    return reverseTextFile(plan, join(codexHome(), 'config.toml'), home(), parseToml, (text, c) => {
+        const lines = text.split('\n');
+        if (lines[0] === CODEX_KEY_COMMENT && ctx.isProxyUrl(lineValue(lines[1] ?? '', 'openai_base_url'))) {
+            // Inserted at the top, with a blank line before the user's content.
+            lines.splice(0, lines[2] === '' ? 3 : 2);
+            return lines.join('\n');
+        }
+        const originalLines = c.originalText === null ? null : c.originalText.split('\n');
+        if (!restoreKeyLine(lines, null, 'openai_base_url', originalLines, ctx.isProxyUrl))
+            return null;
+        if (originalLines === null)
+            c.note('openai_base_url was removed rather than restored: an earlier Intutic version set it without keeping the value it replaced');
+        return lines.join('\n');
+    });
+}
+function codexHooks(plan, file, workspaceRoot) {
+    return json(plan, file, workspaceRoot, (doc, c) => allEdits(removeGateEntries(doc, c, ['PreToolUse'], 'codex-check.js'), restoreKey(doc, ['description'], c, startsWith('Intutic governance PreToolUse hook'))), true);
+}
+const codex = async (plan, ctx) => {
+    await envIntutic(plan, ctx);
+    await forEachWorkspace(ctx, async (root) => {
+        await gateScripts(plan, root, ['codex-check.js']);
+        await codexHooks(plan, join(root, '.codex', 'hooks.json'), root);
+    });
+    await codexHooks(plan, join(codexHome(), 'hooks.json'), home());
+    await codexConfig(plan, ctx);
+};
+const sdkAdapter = (plan, ctx) => envIntutic(plan, ctx);
+// ─── Aider ───────────────────────────────────────────────────────────────────
+/** `.aider.conf.yml` without the header the merger writes above the user's content. */
+const aiderFormat = {
+    parse(raw) {
+        const stripped = stripAiderHeader(raw);
+        return { doc: yamlFormat.parse(stripped), hadHeader: stripped !== raw };
+    },
+    toJS: (h) => yamlFormat.toJS(h.doc),
+    write: (h, next, raw, original) => yamlFormat.write(h.doc, next, raw, original?.doc ?? null),
+};
+/** Keys the merger removes from the user's file while it is connected; put back from the original. */
+const AIDER_REMOVED_KEYS = ['test-cmd', 'lint-cmd', 'auto-test', 'auto-lint', 'test_cmd', 'lint_cmd'];
+function removeFromList(doc, key, isOurs, ctx) {
+    const value = doc[key];
+    if (!Array.isArray(value))
+        return false;
+    const kept = value.filter((v) => !isOurs(v));
+    if (kept.length === value.length)
+        return false;
+    doc[key] = kept;
+    pruneEmpty(doc, [key], ctx.original);
+    return true;
+}
+function aiderConfig(plan, root, ctx) {
+    return reverseStructuredFile(plan, join(root, '.aider.conf.yml'), root, aiderFormat, (doc, c) => {
+        const hadHeader = c.handle.hadHeader;
+        const envIsOurs = (v) => typeof v === 'string' && v.startsWith('ANTHROPIC_BASE_URL=') && ctx.isProxyUrl(v.slice('ANTHROPIC_BASE_URL='.length));
+        const changed = allEdits(hadHeader, restoreKey(doc, ['openai-api-base'], c, ctx.isProxyUrl), removeFromList(doc, 'set-env', envIsOurs, c), removeFromList(doc, 'read', (v) => v === AIDER_SOPS_FILE, c));
+        if (!changed || c.original === null)
+            return changed;
+        // The merger dropped the user's own ANTHROPIC_BASE_URL entry and the
+        // auto-run keys, and turned a single `set-env`/`read` value into a list:
+        // all of it comes back.
+        const original = c.original;
+        const userEnv = asList(original['set-env']).filter((v) => typeof v === 'string' && v.startsWith('ANTHROPIC_BASE_URL='));
+        if (userEnv.length > 0)
+            doc['set-env'] = [...asList(doc['set-env']), ...userEnv];
+        for (const key of ['set-env', 'read']) {
+            const was = original[key];
+            if (was !== undefined && !Array.isArray(was) && isDeepStrictEqual(doc[key], [was]))
+                doc[key] = was;
+        }
+        for (const key of AIDER_REMOVED_KEYS) {
+            if (original[key] !== undefined && doc[key] === undefined)
+                doc[key] = structuredClone(original[key]);
+        }
+        orderLike(doc, original);
+        return true;
+    });
+}
+function asList(v) {
+    return Array.isArray(v) ? v : v === undefined || v === null ? [] : [v];
+}
+const aider = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await aiderConfig(plan, root, ctx);
+        await intuticFile(plan, join(root, AIDER_SOPS_FILE));
+    });
+};
+// ─── OpenHands ───────────────────────────────────────────────────────────────
+/**
+ * An OpenHands `config.toml`: the `[intutic]` table the adapter appends, and
+ * every `base_url` the two writers pointed at the proxy (one of them replaced
+ * the first `base_url` line in the file, whichever table held it).
+ */
+function openHandsConfig(plan, file, workspaceRoot, ctx) {
+    return reverseTextFile(plan, file, workspaceRoot, parseToml, (text, c) => {
+        const lines = text.split('\n');
+        const originalLines = c.originalText === null ? null : c.originalText.split('\n');
+        let changed = removeTable(lines, 'intutic');
+        const tables = new Set(tomlSections(lines).map((s) => s.name));
+        for (const table of tables)
+            changed = restoreKeyLine(lines, table, 'base_url', originalLines, ctx.isProxyUrl) || changed;
+        if (!changed)
+            return null;
+        const originalHadLlm = originalLines !== null && tomlSections(originalLines).some((s) => s.name === 'llm');
+        if (!originalHadLlm)
+            removeEmptyTable(lines, 'llm');
+        if (originalLines === null)
+            c.note('base_url was removed rather than restored where Intutic had set it: an earlier version kept no record of the value it replaced');
+        // The appended table ended the file; its removal must not take the final newline with it.
+        const out = lines.join('\n');
+        return text.endsWith('\n') && !out.endsWith('\n') ? out + '\n' : out;
+    });
+}
+const openhands = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await openHandsConfig(plan, join(root, 'config.toml'), root, ctx);
+        await gateScripts(plan, root, ['openhands-check.sh']);
+        await reverseOwnedFile(plan, join(root, '.openhands', 'hooks.json'), root, OWN_HOOK_FILE);
+        await json(plan, join(root, '.openhands', 'mcp.json'), root, (doc, c) => unwrapServersAt(doc, ['mcpServers'], c.original), true);
+    });
+    await openHandsConfig(plan, join(home(), '.openhands', 'config.toml'), home(), ctx);
+};
+// ─── Antigravity (Gemini CLI) ────────────────────────────────────────────────
+const antigravity = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await gateScripts(plan, root, ['antigravity-check.sh']);
+        await json(plan, join(root, '.gemini', 'settings.json'), root, (doc, c) => restoreKey(doc, ['customInstructions'], c, (v) => typeof v === 'string' && startsWithRulesHeader(v)), true);
+    });
+    await json(plan, join(home(), '.gemini', 'settings.json'), home(), (doc, c) => removeGateEntries(doc, c, ['BeforeTool'], 'antigravity-check.sh'));
+};
+// ─── Continue ────────────────────────────────────────────────────────────────
+function continueSettings(plan, file, workspaceRoot) {
+    return json(plan, file, workspaceRoot, (doc, c) => allEdits(removeGateEntries(doc, c, ['PreToolUse'], 'continue-check.js'), removeOwnKeys(doc, ['_intutic_comment', '_intutic_last_sync'])), true);
+}
+const continueHarness = async (plan, ctx) => {
+    await forEachWorkspace(ctx, async (root) => {
+        await gateScripts(plan, root, ['continue-check.js']);
+        await continueSettings(plan, join(root, '.continue', 'settings.json'), root);
+    });
+    const dir = join(home(), '.continue');
+    await continueSettings(plan, join(dir, 'settings.json'), home());
+    await reverseStructuredFile(plan, join(dir, 'config.yaml'), home(), yamlFormat, (doc, c) => restoreMatchingValues(doc, c, ctx.isProxyUrl));
+    await json(plan, continueConfigPath(), home(), (doc, c) => unwrapContinueServers(doc, c.original));
+};
+// ─── Goose ───────────────────────────────────────────────────────────────────
+async function goosePlugin(plan) {
+    const plugin = join(home(), '.agents', 'plugins', 'intutic-governance');
+    for (const file of [join(plugin, 'hooks', 'hooks.json'), join(plugin, 'scripts', 'intutic-check.sh')]) {
+        // Hardened read-only and immutable while connected: the flag comes off first.
+        await reverseOwnedFile(plan, file, home(), contains('Intutic'), { beforeApply: () => unharden(file) });
+        plan.removeIfEmpty(node_path.dirname(file));
+    }
+    plan.removeIfEmpty(plugin);
+}
+const goose = async (plan, ctx) => {
+    await goosePlugin(plan);
+    await reverseStructuredFile(plan, gooseConfigPath(), home(), yamlFormat, (doc, c) => allEdits(unwrapServersAt(doc, ['mcp'], c.original), restoreMatchingValues(doc, c, ctx.isProxyUrl), restoreKey(doc, ['hooks', 'pre_tool_use'], c, (v) => typeof v === 'string' && v.endsWith(join('intutic-governance', 'scripts', 'intutic-check.sh')))));
+};
+// ─── Hermes, Pi, OpenClaw, n8n, Open WebUI ───────────────────────────────────
+/** A per-harness env snippet in a workspace's `.intutic/env/`. */
+async function envSnippet(plan, ctx, name) {
+    await forEachWorkspace(ctx, async (root) => {
+        await intuticFile(plan, join(root, '.intutic', 'env', name));
+        plan.removeIfEmpty(join(root, '.intutic', 'env'));
+    });
+}
+const hermes = async (plan, ctx) => {
+    await gateScripts(plan, home(), ['hermes-check.sh']);
+    await reverseStructuredFile(plan, join(home(), '.hermes', 'config.yaml'), home(), yamlFormat, (doc, c) => restoreKey(doc, ['hooks', 'preToolUse', 'command'], c, (v) => runsGate(v, 'hermes-check.sh')));
+    const skill = join(home(), '.hermes', 'skills', 'intutic-governance');
+    await reverseOwnedFile(plan, join(skill, 'SKILL.md'), home(), contains('name: intutic-governance'));
+    plan.removeIfEmpty(skill);
+    await envSnippet(plan, ctx, 'hermes.env');
+};
+const pi = async (plan, ctx) => {
+    await gateScripts(plan, home(), ['pi-check.sh']);
+    await json(plan, join(home(), '.pi', 'hooks.json'), home(), (doc, c) => removeGateEntries(doc, c, ['PreToolUse'], 'pi-check.sh'), true);
+    await json(plan, join(home(), '.pi', 'models.json'), home(), (doc, c) => allEdits(restoreKey(doc, ['providers', 'anthropic', 'baseUrl'], c, ctx.isProxyUrl), restoreKey(doc, ['providers', 'openai', 'baseUrl'], c, ctx.isProxyUrl)), true);
+    await envSnippet(plan, ctx, 'pi.env');
+};
+/** OpenClaw's config is JSON5-like; the writer re-serialises it as JSON, and so does this. */
+const json5LikeFormat = { ...jsonFormat, parse: (raw) => (raw.trim() === '' ? {} : parseJson5Like(raw)) };
+const openclaw = async (plan, ctx) => {
+    await gateScripts(plan, home(), ['openclaw-check.js']);
+    await reverseStructuredFile(plan, join(home(), '.openclaw', 'openclaw.json'), home(), json5LikeFormat, (doc, c) => {
+        const path = ['hooks', 'internal', 'entries', 'intutic-governance'];
+        const entry = getPath(doc, path);
+        if (!isObject(entry) || !runsGate(entry.command, 'openclaw-check.js'))
+            return false;
+        deletePath(doc, path);
+        pruneEmpty(doc, path.slice(0, -1), c.original);
+        return true;
+    }, { deleteIfEmptyWithoutRecord: true });
+    await envSnippet(plan, ctx, 'openclaw.env');
+};
+/** n8n's local files. The workflow variables connect sets over n8n's API are undone by the CLI. */
+const n8n = async (plan, ctx) => {
+    await gateScripts(plan, home(), ['n8n-governance-hook.js']);
+    for (const name of ['governance-workflow.json', 'INSTALL.md'])
+        await intuticFile(plan, join(home(), '.intutic', 'n8n', name));
+    plan.removeIfEmpty(join(home(), '.intutic', 'n8n'));
+    await envSnippet(plan, ctx, 'n8n.env');
+};
+const openWebui = async (plan, ctx) => {
+    await reverseOwnedFile(plan, join(home(), '.open-webui', 'intutic-governance-filter.py'), home(), contains('Intutic'));
+    await envSnippet(plan, ctx, 'open-webui.env');
+};
+// ─── dsh ─────────────────────────────────────────────────────────────────────
+const DSH_ROW_ID = 'intutic-governance';
+const DSH_LLM_ENTRY_ID = 'llm-deepseek';
+/** A dsh `cordis.patch.yml`, whose root is a list of patch rows. */
+const dshPatchFormat = {
+    parse(raw) {
+        const doc = parseDocument(raw.trim() === '' ? '[]' : raw);
+        if (doc.errors.length > 0)
+            throw doc.errors[0];
+        if (doc.contents !== null && !isSeq(doc.contents))
+            throw new Error('not a patch list');
+        return doc;
+    },
+    toJS: (doc) => ({ rows: doc.toJS() ?? [] }),
+    write: (doc) => doc.toString(),
+};
+/** Whether a patch row is the plugin row the writer inserts (alone, or inside an `insert:` block it wrote). */
+function isDshPluginRow(row) {
+    if (!isObject(row))
+        return false;
+    if (row.id === DSH_ROW_ID)
+        return true;
+    return Array.isArray(row.insert) && row.insert.length === 1 && isObject(row.insert[0]) && row.insert[0].id === DSH_ROW_ID;
+}
+function dshPatch(plan, file, dshHome, ctx) {
+    return reverseStructuredFile(plan, file, dshHome, dshPatchFormat, (doc, c) => {
+        const yaml = c.handle;
+        const rows = doc.rows;
+        const originalRows = c.original ? c.original.rows : null;
+        let changed = false;
+        // Last first, so the indexes of the rows still to visit stay put.
+        for (let i = rows.length - 1; i >= 0; i--) {
+            const row = rows[i];
+            if (isDshPluginRow(row)) {
+                yaml.deleteIn([i]);
+                changed = true;
+                continue;
+            }
+            if (!isObject(row) || row.id !== DSH_LLM_ENTRY_ID || 'insert' in row)
+                continue;
+            const baseUrl = getPath(row, ['config', 'baseURL']);
+            if (!ctx.isProxyUrl(baseUrl))
+                continue;
+            const originalRow = originalRows?.find((r) => isObject(r) && r.id === DSH_LLM_ENTRY_ID && !('insert' in r));
+            const was = originalRow ? getPath(originalRow, ['config', 'baseURL']) : undefined;
+            const onlyBaseUrl = isObject(row.config) && Object.keys(row.config).length === 1 && Object.keys(row).length === 2;
+            if (was !== undefined)
+                yaml.setIn([i, 'config', 'baseURL'], was);
+            else if (onlyBaseUrl && originalRow === undefined)
+                yaml.deleteIn([i]);
+            else
+                yaml.deleteIn([i, 'config', 'baseURL']);
+            if (originalRows === null)
+                c.note('the llm-deepseek baseURL was removed rather than restored: an earlier Intutic version kept no record of the value it replaced');
+            changed = true;
+        }
+        doc.rows = yaml.toJS() ?? [];
+        return changed;
+    });
+}
+const DSH_GATE_RANGE = '^2.0.0';
+const dsh = async (plan, ctx) => {
+    // dsh's files live under $DSH_HOME, and their records with them (see dshHooks.ts).
+    const dshHome = resolveDshHome();
+    for (const profile of await listDshProfileDirs(dshHome)) {
+        await dshPatch(plan, join(profile, 'cordis.patch.yml'), dshHome, ctx);
+        await json(plan, join(profile, 'package.json'), dshHome, (doc, c) => {
+            // Added only when the profile declared none; with no record, it may be the user's own `dsh plugin add`.
+            if (c.original === null || getPath(doc, ['dependencies', '@intutic/gate']) !== DSH_GATE_RANGE)
+                return false;
+            if (getPath(c.original, ['dependencies', '@intutic/gate']) !== undefined)
+                return false;
+            deletePath(doc, ['dependencies', '@intutic/gate']);
+            pruneEmpty(doc, ['dependencies'], c.original);
+            return true;
+        });
+    }
+    await reverseOwnedFile(plan, join(dshHome, 'INSTALL.md'), dshHome, startsWith('# Intutic governance for dsh'));
+    plan.quiet(join(dshHome, '.intutic', 'originals'), () => pruneLedger(dshHome));
+};
+// ─── Registry ────────────────────────────────────────────────────────────────
+/** The reverser for each harness id; harnesses connect writes nothing for are absent. */
+export const HARNESS_REVERSERS = {
+    'claude-code': claudeCode,
+    'claude-desktop': claudeDesktop,
+    cursor,
+    windsurf,
+    'github-copilot': githubCopilot,
+    'muse-code': muse,
+    grok,
+    opencode,
+    'roo-code': rooCode,
+    cline,
+    codex,
+    aider,
+    openhands,
+    antigravity,
+    continue: continueHarness,
+    goose,
+    hermes,
+    pi,
+    openclaw,
+    n8n,
+    'open-webui': openWebui,
+    dsh,
+    ...Object.fromEntries(ENV_INTUTIC_WRITERS.filter((h) => h !== 'codex').map((h) => [h, sdkAdapter])),
+};
+//# sourceMappingURL=harnesses.js.map