@adrive/cli 0.3.0 → 1.1.0

package/dist/index.js

@@ -16,7 +16,10 @@ import { cmdBilling } from './commands/billing.js';
 import { cmdPlan } from './commands/plan.js';
 import { cmdPrivacy } from './commands/privacy.js';
 import { cmdWatch } from './commands/watch.js';
-import { cmdTranscriptsIngest } from './commands/transcripts.js';
+import { cmdHook } from './commands/hook.js';
+import { cmdSync } from './commands/sync.js';
+import { cmdResume } from './commands/resume.js';
+import { cmdTimeline } from './commands/timeline.js';
 // Read from the bundled package.json so we never drift again.
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
@@ -103,7 +106,14 @@ program
     workspace: opts.workspace,
 })));
 program
-    .command('context <task>')
+    .command('timeline')
+    .description('Cross-agent activity stream for your org')
+    .option('--today', 'Only events since midnight UTC')
+    .option('--since <iso>', 'Only events strictly after this ISO datetime')
+    .option('--limit <n>', 'Max events to show (default 200, max 1000)')
+    .action(wrap((opts) => cmdTimeline(opts)));
+program
+    .command('context [task]')
     .description('Auto-pull relevant artifacts for a task')
     .option('--limit <n>', 'Max artifacts to return')
     .option('-w, --workspace <id>', 'Restrict to one workspace')
@@ -142,24 +152,29 @@ program
     noEncrypt: opts.encrypt === false,
     debounce: opts.debounce,
 })));
-const transcripts = program.command('transcripts').description('Ingest chat transcripts from local agent hosts');
-transcripts
-    .command('ingest')
-    .description('Read recent transcripts, redact secrets, upload to AgentDrive')
-    .option('--platform <p>', 'Only ingest one platform (default: claude-code)', 'claude-code')
-    .option('-w, --workspace <id>', 'Target workspace id')
-    .option('--since <date>', 'Ignore transcripts older than this ISO date')
-    .option('--limit <n>', 'Cap how many to ingest', (v) => Number(v))
-    .option('--dry-run', 'Print what would be uploaded; never write')
-    .option('--reingest', 'Re-upload sessions already in the manifest')
-    .action(wrap((opts) => cmdTranscriptsIngest({
-    platform: opts.platform,
-    workspace: opts.workspace,
-    since: opts.since,
-    limit: opts.limit,
-    dryRun: opts.dryRun,
-    reingest: opts.reingest,
-})));
+program
+    .command('hook <harness>')
+    .description('Lifecycle hook entry for claude-code | codex | opencode | gemini-cli | cursor (reads the event JSON on stdin)')
+    .action((harness) => cmdHook(harness));
+program
+    .command('sync')
+    .description('Upload agent sessions and the untracked files they wrote to AgentDrive')
+    .option('--harness <h>', 'claude-code | codex | opencode | gemini-cli | cursor')
+    .option('--session <id>', 'Sync this harness session (with --harness)')
+    .option('--transcript <path>', 'Transcript file of that session')
+    .option('--cwd <dir>', 'Session working directory, used when the transcript has none')
+    .option('--force', 'Ignore the debounce and mark the named session finished')
+    .option('--start', 'Session-start sync: always sweep for recent sessions')
+    .option('--all', 'Sweep full history instead of changes since the last sweep')
+    .option('--quiet', 'Log to sync.log in the config dir instead of stdout')
+    .option('--dry-run', 'Parse and report; never upload')
+    .action(wrap((opts) => cmdSync(opts)));
+program
+    .command('resume [id]')
+    .description('Print a handoff for a prior session of this project (latest if no id)')
+    .option('--list', 'List recent sessions for this project')
+    .option('--max-chars <n>', 'Handoff size budget in characters', (v) => Number(v))
+    .action(wrap((id, opts) => cmdResume(id, { list: opts.list, maxChars: opts.maxChars })));
 program
     .command('privacy')
     .description('Show or change your privacy + memory preferences')

package/dist/lib/api-client.js

@@ -47,12 +47,13 @@ export class CliApiClient {
         }
         return json.data;
     }
-    async requestPage(method, path, body) {
+    async requestPage(method, path, body, signal) {
         const url = `${this.baseUrl}/v1${path}`;
         const res = await fetch(url, {
             method,
             headers: this.headers(true),
             body: body ? JSON.stringify(body) : undefined,
+            signal,
         });
         const json = await res.json();
         if (!res.ok || !json.success) {
@@ -94,6 +95,9 @@ export class CliApiClient {
         }
         return all;
     }
+    async createWorkspace(name) {
+        return this.request('POST', '/workspaces', { name });
+    }
     async writeFile(workspaceId, path, content, message) {
         return this.request('POST', `/workspaces/${workspaceId}/files`, { path, content, message });
     }
@@ -113,10 +117,37 @@ export class CliApiClient {
     async logRun(body) {
         return this.request('POST', '/runs', body);
     }
+    async listRuns(query) {
+        const params = new URLSearchParams({ project: query.project });
+        if (query.platform)
+            params.set('platform', query.platform);
+        if (query.limit)
+            params.set('limit', String(query.limit));
+        const signal = query.timeoutMs ? AbortSignal.timeout(query.timeoutMs) : undefined;
+        return (await this.requestPage('GET', `/runs?${params.toString()}`, undefined, signal)).items;
+    }
+    async getRun(runId) {
+        return this.request('GET', `/runs/${encodeURIComponent(runId)}`);
+    }
     async billingPortal() {
         return this.request('POST', '/billing/portal', {});
     }
     async billingPlan() {
         return this.request('GET', '/billing/plan');
     }
+    async timeline(opts = {}) {
+        const params = new URLSearchParams();
+        if (opts.since)
+            params.set('since', opts.since);
+        if (typeof opts.limit === 'number')
+            params.set('limit', String(opts.limit));
+        const query = params.toString() ? `?${params.toString()}` : '';
+        const url = `${this.baseUrl}/v1/org/timeline${query}`;
+        const res = await fetch(url, { method: 'GET', headers: this.headers(true) });
+        const json = (await res.json());
+        if (!res.ok || !json.success) {
+            throw new Error(json.error ?? `API request failed (${res.status})`);
+        }
+        return { items: (json.data ?? []), truncated: !!json.truncated };
+    }
 }

package/dist/lib/auto-context.js

@@ -1,8 +1,9 @@
 import { promises as fs } from 'node:fs';
 import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
+import { readTextIfExists, writeFileIfChanged } from './write-file.js';
 // Small instructions block written into each agent host's persistent
-// preamble (CLAUDE.md, AGENTS.md, cursor rules). Tells the agent when to
+// preamble (AGENTS.md, GEMINI.md, cursor rules). Tells the agent when to
 // reach for the AgentDrive MCP tools without the user having to ask each
 // time. Idempotent: bracketed with markers so re-running adrive init
 // updates the same region instead of stacking copies.
@@ -11,31 +12,30 @@ const END = '<!-- agentdrive:auto-context:end -->';
 const INSTRUCTIONS = `${BEGIN}
 ## AgentDrive — your cross-agent memory
 
-You have AgentDrive tools available via MCP. Use them like this without
-waiting to be asked:
+AgentDrive records the user's agent sessions across Claude Code, Codex,
+OpenCode, Gemini CLI, and Cursor. Use its MCP tools without waiting to be
+asked:
 
-- **Session start** — call \`drive_context\` with a short summary of the
-  task. It returns the most relevant artifacts and run history from your
-  own and other agents' prior work in the same workspace.
-- **Saving work** — after producing any file or artifact worth keeping,
-  call \`drive_write\` so the user's other agents can see it. The user
-  has opted into automatic capture if they want everything saved.
-- **Recall** — when the user asks "what did the last session do?",
-  "show me what Codex wrote", or anything cross-session, call
-  \`drive_search\` (semantic search) or \`drive_recall\` (extracted
-  facts).
-- **Run logging** — at the end of a meaningful session, call
-  \`drive_log_run\` so the next agent in the chain can see what you did.
+- **Session start** — if the user wants to continue earlier work, call
+  \`drive_resume\` (or \`drive_sessions\` to pick a session) and check the
+  files it mentions on disk before continuing. For a new task, call
+  \`drive_context\` with a short summary of the task.
+- **Recall** — for "what did the last session do?" or "show me what Codex
+  wrote", call \`drive_sessions\`, \`drive_search\`, or \`drive_recall\`.
+- **Saving work** — after producing a file worth sharing with the user's
+  other agents, call \`drive_write\`.
 
-Privacy: the user controls capture and encryption. If they have
-"Private workspace" on, written content is end-to-end encrypted on
-their device; the AgentDrive server stores only ciphertext.
+Privacy: the user controls capture and encryption with \`adrive privacy\`.
+With "Private workspace" on, content is end-to-end encrypted on their
+device; the AgentDrive server stores only ciphertext.
 ${END}`;
 export function getInstructionsTargets(home = homedir()) {
+    const opencode = join(home, '.config', 'opencode');
     return [
-        { path: join(home, '.claude', 'CLAUDE.md'), format: 'markdown' },
-        { path: join(home, '.codex', 'AGENTS.md'), format: 'markdown' },
-        { path: join(home, '.cursor', 'rules', 'agentdrive.mdc'), format: 'cursor-mdc' },
+        { root: join(home, '.codex'), path: join(home, '.codex', 'AGENTS.md'), format: 'markdown' },
+        { root: opencode, path: join(opencode, 'AGENTS.md'), format: 'markdown' },
+        { root: join(home, '.gemini'), path: join(home, '.gemini', 'GEMINI.md'), format: 'markdown' },
+        { root: join(home, '.cursor'), path: join(home, '.cursor', 'rules', 'agentdrive.mdc'), format: 'cursor-mdc' },
     ];
 }
 function wrap(format, body) {
@@ -45,50 +45,33 @@ function wrap(format, body) {
     }
     return `\n${body}\n`;
 }
-async function fileExists(p) {
+async function dirExists(p) {
     try {
-        await fs.access(p);
-        return true;
+        return (await fs.stat(p)).isDirectory();
     }
     catch {
         return false;
     }
 }
-async function ensureDir(p) {
-    await fs.mkdir(dirname(p), { recursive: true });
-}
 export async function writeInstructions(target) {
-    const block = wrap(target.format, INSTRUCTIONS);
-    const existed = await fileExists(target.path);
-    if (!existed) {
-        await ensureDir(target.path);
-        await fs.writeFile(target.path, block, 'utf8');
-        return { path: target.path, action: 'created' };
+    const current = await readTextIfExists(target.path);
+    let next;
+    if (current === null) {
+        next = wrap(target.format, INSTRUCTIONS);
+    }
+    else if (current.includes(BEGIN) && current.includes(END)) {
+        next = current.slice(0, current.indexOf(BEGIN)) + INSTRUCTIONS + current.slice(current.indexOf(END) + END.length);
     }
-    const current = await fs.readFile(target.path, 'utf8');
-    if (current.includes(BEGIN) && current.includes(END)) {
-        const beginIdx = current.indexOf(BEGIN);
-        const endIdx = current.indexOf(END) + END.length;
-        const next = current.slice(0, beginIdx) + INSTRUCTIONS + current.slice(endIdx);
-        if (next === current)
-            return { path: target.path, action: 'unchanged' };
-        await fs.writeFile(target.path, next, 'utf8');
-        return { path: target.path, action: 'updated' };
+    else {
+        next = current.trimEnd() + '\n' + wrap(target.format, INSTRUCTIONS);
     }
-    await fs.writeFile(target.path, current.trimEnd() + '\n' + block, 'utf8');
-    return { path: target.path, action: 'updated' };
+    return { path: target.path, action: await writeFileIfChanged(target.path, next, { backup: true }) };
 }
 export async function writeAllInstructions(home = homedir()) {
-    const targets = getInstructionsTargets(home);
     const out = [];
-    for (const t of targets) {
-        try {
+    for (const t of getInstructionsTargets(home)) {
+        if (await dirExists(t.root))
             out.push(await writeInstructions(t));
-        }
-        catch {
-            // Best-effort across hosts. A missing parent dir for an
-            // agent the user hasn't installed is fine to skip silently.
-        }
     }
     return out;
 }

package/dist/lib/config.js

@@ -31,6 +31,7 @@ export async function readConfig(path = configPath()) {
             agent_role: parsed.agent_role,
             default_workspace: parsed.default_workspace,
             preferences: { ...DEFAULT_PREFERENCES, ...(parsed.preferences ?? {}) },
+            capture_notice_at: parsed.capture_notice_at,
         };
     }
     catch (err) {
@@ -40,6 +41,17 @@ export async function readConfig(path = configPath()) {
         throw err;
     }
 }
+// readConfig fills in default preferences, so this reads the raw file to tell
+// a fresh install apart from one where the user already chose.
+export async function hasSavedPreferences(path = configPath()) {
+    try {
+        const parsed = JSON.parse(await fs.readFile(path, 'utf8'));
+        return !!parsed?.preferences && typeof parsed.preferences === 'object';
+    }
+    catch {
+        return false;
+    }
+}
 export async function writeConfig(config, path = configPath()) {
     await fs.mkdir(dirname(path), { recursive: true, mode: 0o700 });
     const payload = JSON.stringify(config, null, 2);

package/dist/lib/consent.js

@@ -0,0 +1,60 @@
+import prompts from 'prompts';
+import kleur from 'kleur';
+import { DEFAULT_PREFERENCES } from './config.js';
+function notice(on) {
+    return `
+${kleur.bold(`AgentDrive capture is ${on ? 'on' : 'off'}`)}
+  - ${on ? 'Captured' : 'When on, captures'}: your agent session transcripts, and files your agents write that git doesn't track.
+  - Secrets are redacted on this device before anything is uploaded.
+  - Turn on "Private workspace" to encrypt everything end-to-end on your device.
+  - ${on ? 'Change or turn it off anytime' : 'Turn it on'}: ${kleur.bold('adrive privacy')}
+`;
+}
+// `preferencesSaved` is whether the on-disk config already had a preferences
+// block: only a fresh install gets capture switched on, so a choice made before
+// the notice existed is never overridden.
+export async function ensureCaptureConsent(config, client, opts) {
+    const next = { ...config };
+    if (!next.capture_notice_at) {
+        if (!opts.preferencesSaved) {
+            next.preferences = { ...DEFAULT_PREFERENCES, ...(next.preferences ?? {}), capture_transcripts: true, capture_artifacts: true };
+        }
+        const prefs = next.preferences;
+        process.stdout.write(notice(!!prefs?.capture_transcripts || !!prefs?.capture_artifacts));
+        next.capture_notice_at = (opts.now ?? (() => new Date()))().toISOString();
+    }
+    if (!next.default_workspace) {
+        try {
+            next.default_workspace = await pickDefaultWorkspace(client, opts.interactive);
+        }
+        catch (err) {
+            // Login already succeeded; a workspace can still be chosen later with --workspace.
+            const msg = err instanceof Error ? err.message : String(err);
+            process.stdout.write(`${kleur.yellow('[warn]')} could not set a default workspace: ${msg}\n`);
+        }
+    }
+    return next;
+}
+async function pickDefaultWorkspace(client, interactive) {
+    const workspaces = await client.listWorkspaces();
+    if (workspaces.length === 0) {
+        const ws = await client.createWorkspace('Personal');
+        process.stdout.write(`Created workspace ${kleur.bold(ws.name)} (${ws.id}) as your default.\n`);
+        return ws.id;
+    }
+    if (workspaces.length === 1)
+        return workspaces[0].id;
+    if (interactive) {
+        const res = (await prompts({
+            type: 'select',
+            name: 'ws',
+            message: 'Default workspace for captured sessions',
+            choices: workspaces.map((w) => ({ title: `${w.name} (${w.id})`, value: w.id })),
+        }));
+        if (res.ws)
+            return res.ws;
+    }
+    const first = workspaces[0];
+    process.stdout.write(`Using ${kleur.bold(first.name)} (${first.id}) as your default workspace. Change it in ~/.config/agentdrive/config.json.\n`);
+    return first.id;
+}

package/dist/lib/detect-agents.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'node:fs';
 import { homedir, platform } from 'node:os';
-import { dirname, join } from 'node:path';
+import { join } from 'node:path';
+import { readJsonObject, writeJsonIfChanged } from './write-file.js';
 export function getAgentTargets(opts = {}) {
     const env = opts.env ?? process.env;
     const home = opts.home ?? homedir();
@@ -11,43 +12,23 @@ export function getAgentTargets(opts = {}) {
             ? join(env.APPDATA ?? join(home, 'AppData', 'Roaming'), 'Claude', 'claude_desktop_config.json')
             : join(home, '.config', 'Claude', 'claude_desktop_config.json');
     return [
-        {
-            name: 'claude-code',
-            configPath: join(home, '.claude', 'mcp-servers.json'),
-            format: 'mcp-json',
-            defaultPlatform: 'claude-code',
-        },
         {
             name: 'claude-desktop',
             configPath: claudeDesktop,
             format: 'mcp-json',
-            defaultPlatform: 'claude-code',
-        },
-        {
-            name: 'codex',
-            configPath: join(home, '.codex', 'config.toml'),
-            format: 'codex-toml',
-            defaultPlatform: 'codex',
-        },
-        {
-            name: 'cursor',
-            configPath: join(home, '.cursor', 'mcp.json'),
-            format: 'cursor-json',
-            defaultPlatform: 'cursor',
+            platform: 'claude-code',
         },
         {
             name: 'continue',
             configPath: join(home, '.continue', 'config.json'),
             format: 'continue-json',
-            defaultPlatform: 'continue',
+            platform: 'continue',
         },
         {
             name: 'zed',
-            configPath: os === 'darwin'
-                ? join(home, '.config', 'zed', 'settings.json')
-                : join(home, '.config', 'zed', 'settings.json'),
+            configPath: join(home, '.config', 'zed', 'settings.json'),
             format: 'zed-json',
-            defaultPlatform: 'zed',
+            platform: 'zed',
         },
         {
             name: 'cline',
@@ -55,7 +36,7 @@ export function getAgentTargets(opts = {}) {
                 ? join(home, 'Library', 'Application Support', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json')
                 : join(home, '.config', 'Code', 'User', 'globalStorage', 'saoudrizwan.claude-dev', 'settings', 'cline_mcp_settings.json'),
             format: 'mcp-json',
-            defaultPlatform: 'cline',
+            platform: 'cline',
         },
     ];
 }
@@ -68,156 +49,95 @@ async function fileExists(path) {
         return false;
     }
 }
-async function readJsonSafe(path) {
-    try {
-        const raw = await fs.readFile(path, 'utf8');
-        if (!raw.trim())
-            return {};
-        return JSON.parse(raw);
-    }
-    catch (err) {
-        const e = err;
-        if (e.code === 'ENOENT')
-            return null;
-        return null;
-    }
-}
-function mcpEntry(env, platformOverride) {
-    const envBlock = {
-        AGENTDRIVE_API_KEY: env.apiKey,
-    };
-    if (env.apiUrl)
-        envBlock.AGENTDRIVE_API_URL = env.apiUrl;
-    const plat = env.agentPlatform ?? platformOverride;
-    if (plat)
-        envBlock.AGENTDRIVE_AGENT_PLATFORM = plat;
+// No API key here: the MCP server reads it from ~/.config/agentdrive/config.json,
+// so harness configs never hold a secret.
+export function mcpEntry(agentPlatform) {
     return {
         command: 'npx',
         args: ['-y', '@adrive/mcp-server'],
-        env: envBlock,
+        env: { AGENTDRIVE_AGENT_PLATFORM: agentPlatform },
     };
 }
-export function mergeMcpJson(existing, env, platformOverride) {
-    const base = existing && typeof existing === 'object' ? { ...existing } : {};
-    const serversRaw = base.mcpServers;
-    const servers = serversRaw && typeof serversRaw === 'object' && !Array.isArray(serversRaw)
-        ? { ...serversRaw }
-        : {};
-    servers.agentdrive = mcpEntry(env, platformOverride);
+function asObject(v) {
+    return v && typeof v === 'object' && !Array.isArray(v) ? { ...v } : {};
+}
+export function mergeMcpJson(existing, agentPlatform) {
+    const base = asObject(existing);
+    const servers = asObject(base.mcpServers);
+    servers.agentdrive = mcpEntry(agentPlatform);
     base.mcpServers = servers;
     return base;
 }
-export function mergeCursorJson(existing, env) {
-    return mergeMcpJson(existing, env, 'cursor');
-}
-export function mergeContinueJson(existing, env) {
-    const base = existing && typeof existing === 'object' ? { ...existing } : {};
-    const rawList = base.mcpServers;
-    const list = Array.isArray(rawList) ? [...rawList] : [];
-    const filtered = list.filter((s) => {
-        if (!s || typeof s !== 'object')
-            return true;
-        return s.name !== 'agentdrive';
-    });
-    filtered.push({
-        name: 'agentdrive',
-        ...mcpEntry(env, 'continue'),
-    });
+export function mergeContinueJson(existing) {
+    const base = asObject(existing);
+    const list = Array.isArray(base.mcpServers) ? base.mcpServers : [];
+    const filtered = list.filter((s) => asObject(s).name !== 'agentdrive');
+    filtered.push({ name: 'agentdrive', ...mcpEntry('continue') });
     base.mcpServers = filtered;
     return base;
 }
-export function mergeZedJson(existing, env) {
-    const base = existing && typeof existing === 'object' ? { ...existing } : {};
-    const ctxRaw = base.context_servers;
-    const ctx = ctxRaw && typeof ctxRaw === 'object' && !Array.isArray(ctxRaw)
-        ? { ...ctxRaw }
-        : {};
-    ctx.agentdrive = mcpEntry(env, 'zed');
+export function mergeZedJson(existing) {
+    const base = asObject(existing);
+    const ctx = asObject(base.context_servers);
+    ctx.agentdrive = mcpEntry('zed');
     base.context_servers = ctx;
     return base;
 }
-export function mergeCodexToml(existing, env) {
-    const blockHeader = '[[mcp_servers]]';
-    const target = 'name = "agentdrive"';
-    const apiKey = env.apiKey.replace(/"/g, '\\"');
-    const apiUrlLine = env.apiUrl ? `, AGENTDRIVE_API_URL = "${env.apiUrl}"` : '';
-    const newBlock = `${blockHeader}\nname = "agentdrive"\ncommand = "npx"\nargs = ["-y", "@adrive/mcp-server"]\n` +
-        `env = { AGENTDRIVE_API_KEY = "${apiKey}", AGENTDRIVE_AGENT_PLATFORM = "codex"${apiUrlLine} }\n`;
-    const trimmed = existing.trimEnd();
-    if (!trimmed)
-        return newBlock;
-    if (!trimmed.includes(target)) {
-        return `${trimmed}\n\n${newBlock}`;
+export function mergeOpencodeJson(existing) {
+    const base = asObject(existing);
+    const mcp = asObject(base.mcp);
+    mcp.agentdrive = {
+        type: 'local',
+        command: ['npx', '-y', '@adrive/mcp-server'],
+        environment: { AGENTDRIVE_AGENT_PLATFORM: 'opencode' },
+        enabled: true,
+    };
+    base.mcp = mcp;
+    return base;
+}
+const CODEX_BLOCK = '[mcp_servers.agentdrive]\ncommand = "npx"\nargs = ["-y", "@adrive/mcp-server"]\n\n' +
+    '[mcp_servers.agentdrive.env]\nAGENTDRIVE_AGENT_PLATFORM = "codex"\n';
+// Line-based so every table we don't own keeps its exact text. Drops our
+// [mcp_servers.agentdrive*] tables plus the [[mcp_servers]] name="agentdrive"
+// array entry older CLIs wrote, which would make the file invalid TOML next
+// to a [mcp_servers.*] table.
+export function mergeCodexToml(existing) {
+    const sections = [];
+    for (const line of existing.split(/(?<=\n)/)) {
+        if (sections.length === 0 || /^\s*\[/.test(line))
+            sections.push(line);
+        else
+            sections[sections.length - 1] += line;
     }
-    // Replace the existing agentdrive block in place: scan blocks, swap the matching one.
-    const blocks = trimmed.split(/(?=^\[\[mcp_servers\]\]$)/m);
-    const updated = blocks.map((block) => {
-        if (block.includes(target))
-            return newBlock.trimEnd();
-        return block.trimEnd();
+    const kept = sections.filter((section, i) => {
+        const header = section.split('\n', 1)[0].trim();
+        if (i === 0 && !header.startsWith('['))
+            return true;
+        if (/^\[mcp_servers\.agentdrive(\.[^\]]+)?\]$/.test(header))
+            return false;
+        if (header === '[[mcp_servers]]' && /^\s*name\s*=\s*"agentdrive"\s*$/m.test(section))
+            return false;
+        return true;
     });
-    return `${updated.join('\n\n')}\n`;
+    const rest = kept.join('').trimEnd();
+    return rest ? `${rest}\n\n${CODEX_BLOCK}` : CODEX_BLOCK;
 }
-export async function wireAgent(target, env, opts = {}) {
-    const exists = await fileExists(target.configPath);
-    if (!exists && !opts.writeIfMissing) {
+export async function wireAgent(target) {
+    const existing = await readJsonObject(target.configPath);
+    if (existing === null)
         throw new Error(`Config not found: ${target.configPath}`);
-    }
-    await fs.mkdir(dirname(target.configPath), { recursive: true });
-    if (target.format === 'codex-toml') {
-        const existing = exists ? await fs.readFile(target.configPath, 'utf8') : '';
-        const merged = mergeCodexToml(existing, env);
-        await fs.writeFile(target.configPath, merged, 'utf8');
-        return;
-    }
-    const existing = exists ? await readJsonSafe(target.configPath) : {};
-    let merged;
-    switch (target.format) {
-        case 'mcp-json':
-            merged = mergeMcpJson(existing, env, target.defaultPlatform);
-            break;
-        case 'cursor-json':
-            merged = mergeCursorJson(existing, env);
-            break;
-        case 'continue-json':
-            merged = mergeContinueJson(existing, env);
-            break;
-        case 'zed-json':
-            merged = mergeZedJson(existing, env);
-            break;
-        default:
-            throw new Error(`Unknown format: ${String(target.format)}`);
-    }
-    await fs.writeFile(target.configPath, `${JSON.stringify(merged, null, 2)}\n`, 'utf8');
+    const merged = target.format === 'continue-json'
+        ? mergeContinueJson(existing)
+        : target.format === 'zed-json'
+            ? mergeZedJson(existing)
+            : mergeMcpJson(existing, target.platform);
+    return writeJsonIfChanged(target.configPath, merged);
 }
 export async function detectInstalledAgents(opts = {}) {
-    const targets = getAgentTargets(opts);
     const present = [];
-    for (const t of targets) {
+    for (const t of getAgentTargets(opts)) {
         if (await fileExists(t.configPath))
             present.push(t);
     }
     return present;
 }
-export async function wireAllInstalled(env, opts = {}) {
-    const all = getAgentTargets(opts);
-    const wired = [];
-    const skipped = [];
-    for (const t of all) {
-        const exists = await fileExists(t.configPath);
-        const forceWrite = opts.includeMissing?.includes(t.name) ?? false;
-        if (!exists && !forceWrite) {
-            skipped.push({ name: t.name, reason: 'config not found' });
-            continue;
-        }
-        try {
-            await wireAgent(t, env, { writeIfMissing: forceWrite });
-            wired.push(t.name);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            skipped.push({ name: t.name, reason: msg });
-        }
-    }
-    return { wired, skipped };
-}