@adrive/cli 1.0.0 → 1.1.0

package/README.md

@@ -65,19 +65,18 @@ If the browser does not auto-launch (e.g. headless server, SSH session), the URL
 
 ## Auto-detect + wire
 
-`adrive init` looks for these config files and merges the AgentDrive MCP server entry in (preserving any servers you already have):
+`adrive init` logs you in, then wires every agent harness it finds. API keys stay in `~/.config/agentdrive/config.json`; no harness config ever holds one.
 
-| Tool | Config path |
+| Tool | What init writes |
 |---|---|
-| Claude Code | `~/.claude/mcp-servers.json` |
-| Claude Desktop | `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS), `%APPDATA%/Claude/claude_desktop_config.json` (Windows), `~/.config/Claude/claude_desktop_config.json` (Linux) |
-| Codex CLI | `~/.codex/config.toml` |
-| Cursor | `~/.cursor/mcp.json` |
-| Cline | `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json` (or the Linux equivalent) |
-| Continue | `~/.continue/config.json` |
-| Zed | `~/.config/zed/settings.json` |
-
-Existing entries are merged, not overwritten. An existing `agentdrive` entry is replaced in place.
+| Claude Code | Installs the `agentdrive` plugin (`claude plugin marketplace add Rakesh1002/agentdrive` + `claude plugin install agentdrive@agentdrive`) |
+| Codex CLI | `~/.codex/hooks.json`, `[mcp_servers.agentdrive]` in `~/.codex/config.toml`, `~/.codex/prompts/agentdrive-*.md`, `~/.codex/skills/agentdrive/` |
+| OpenCode | `~/.config/opencode/plugins/agentdrive.ts`, `mcp.agentdrive` in `opencode.json`, `commands/agentdrive-*.md`, `skills/agentdrive/` |
+| Gemini CLI | `hooks` + `mcpServers` in `~/.gemini/settings.json`, `~/.gemini/commands/agentdrive/*.toml` |
+| Cursor | `~/.cursor/hooks.json`, `~/.cursor/mcp.json`, `~/.cursor/commands/agentdrive-*.md`, `~/.cursor/skills/agentdrive/` |
+| Claude Desktop, Cline, Continue, Zed | MCP server entry in their existing config |
+
+Merges preserve everything else in each file, the first change to an existing file saves `<file>.bak`, and re-running init changes nothing. Codex runs new hooks only after you approve them in Codex via `/hooks`.
 
 ## License
 

package/dist/commands/auth-login.js

@@ -1,23 +1,28 @@
 import kleur from 'kleur';
 import { CliApiClient } from '../lib/api-client.js';
-import { DEFAULT_API_URL, readConfig, writeConfig } from '../lib/config.js';
+import { DEFAULT_API_URL, hasSavedPreferences, readConfig, writeConfig } from '../lib/config.js';
+import { ensureCaptureConsent } from '../lib/consent.js';
 import { pollAuth } from '../lib/poll-auth.js';
 export async function cmdAuthLogin(opts = {}) {
     const existing = await readConfig();
+    const preferencesSaved = await hasSavedPreferences();
     const apiUrl = opts.apiUrl ?? existing?.api_url ?? DEFAULT_API_URL;
     const client = new CliApiClient({ baseUrl: apiUrl, agentPlatform: 'cli' });
     const result = await pollAuth(client);
-    await writeConfig({
+    const saved = {
+        ...existing,
         api_url: apiUrl,
         api_key: result.api_key,
         agent_id: result.agent_id,
         org_id: result.org_id,
         agent_platform: 'cli',
-        default_workspace: existing?.default_workspace,
-    });
+    };
+    await writeConfig(saved);
     process.stdout.write(`${kleur.green('[ok]')} API key saved.\n`);
     if (result.agent_id)
         process.stdout.write(`     agent_id: ${result.agent_id}\n`);
     if (result.org_id)
         process.stdout.write(`     org_id:   ${result.org_id}\n`);
+    const authed = new CliApiClient({ baseUrl: apiUrl, apiKey: result.api_key, agentPlatform: 'cli' });
+    await writeConfig(await ensureCaptureConsent(saved, authed, { interactive: !!process.stdin.isTTY, preferencesSaved }));
 }

package/dist/commands/context.js

@@ -1,18 +1,12 @@
 import kleur from 'kleur';
 import { CliApiClient } from '../lib/api-client.js';
 import { requireLogin } from '../lib/config.js';
-import { installClaudeSkill, describeSkillAction } from '../lib/skill.js';
 function truncate(s, n) {
     if (!s)
         return '';
     return s.length <= n ? s : `${s.slice(0, n - 1)}…`;
 }
 export async function cmdContext(task, opts = {}) {
-    if (opts.installSkill) {
-        const result = await installClaudeSkill({ force: opts.force });
-        process.stdout.write(`Claude skill ${describeSkillAction(result.action)}: ${kleur.dim(result.path)}\n`);
-        return;
-    }
     if (!task) {
         process.stderr.write('error: missing required argument <task>\n');
         process.exit(1);

package/dist/commands/hook.js

@@ -0,0 +1,152 @@
+import { spawn } from 'node:child_process';
+import { projectKeyFor, scopeProjectKey } from '@adrive/mcp-server/project';
+import { sessionActivityAt, sessionRunId } from '@adrive/mcp-server/session';
+import { CliApiClient } from '../lib/api-client.js';
+import { configDir, readConfig } from '../lib/config.js';
+import { HARNESSES } from '../lib/sync.js';
+import { recordSessionCwd } from '../lib/session-cwd.js';
+import { asObj, asStr, truncate } from '../lib/transcripts/util.js';
+// Entry point for every harness lifecycle hook. Hooks run inline with the
+// agent (Codex gives SessionEnd 1s), so this answers fast, hands the real
+// work to a detached `adrive sync`, never throws, and always exits 0. stdout
+// is reserved for the harness's JSON protocol.
+const STDIN_TIMEOUT_MS = 1000;
+const CONTEXT_TIMEOUT_MS = 1500;
+const MAX_CONTEXT_SESSIONS = 3;
+const NOT_CONNECTED = 'AgentDrive is installed but not connected: run `adrive auth login`.';
+const START_EVENTS = new Set(['SessionStart', 'sessionStart', 'session.created']);
+const FORCE_EVENTS = new Set(['SessionEnd', 'sessionEnd', 'PreCompact', 'preCompact', 'PreCompress']);
+const TURN_EVENTS = new Set(['Stop', 'stop', 'AfterAgent', 'session.idle']);
+export function classifyEvent(name) {
+    if (START_EVENTS.has(name))
+        return 'start';
+    if (FORCE_EVENTS.has(name))
+        return 'force';
+    if (TURN_EVENTS.has(name))
+        return 'turn';
+    if (name === 'afterFileEdit')
+        return 'file-edit';
+    return 'other';
+}
+function spawnDetachedSync(args) {
+    const child = spawn(process.execPath, [process.argv[1], 'sync', ...args], { detached: true, stdio: 'ignore' });
+    child.on('error', () => undefined);
+    child.unref();
+}
+function age(ms) {
+    const minutes = Math.max(1, Math.round(ms / 60_000));
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    return hours < 48 ? `${hours}h ago` : `${Math.round(hours / 24)}d ago`;
+}
+async function recentSessions(cfg, harness, cwd, sessionId, now) {
+    const client = new CliApiClient({ baseUrl: cfg.api_url, apiKey: cfg.api_key, agentPlatform: harness, agentRole: cfg.agent_role });
+    const runs = await client.listRuns({ project: scopeProjectKey(projectKeyFor(cwd), !!cfg.preferences?.private_workspace), limit: 5, timeoutMs: CONTEXT_TIMEOUT_MS }).catch(() => []);
+    const current = sessionId ? sessionRunId(harness, sessionId) : undefined;
+    const lines = runs
+        .filter((r) => r.run_id !== current)
+        .slice(0, MAX_CONTEXT_SESSIONS)
+        .map((r) => {
+        const title = truncate(asStr(r.metadata?.title) || r.task, 120);
+        return `- ${r.agent_platform} · ${age(now - sessionActivityAt(r))} · "${title}" (id ${r.run_id})`;
+    });
+    if (lines.length === 0)
+        return undefined;
+    return [
+        'Recent AgentDrive sessions in this project:',
+        ...lines,
+        'To continue one, call the drive_resume tool (or /agentdrive:resume) with its id.',
+    ].join('\n');
+}
+function formatContext(harness, context) {
+    if (!context || harness === 'opencode')
+        return '';
+    if (harness === 'cursor')
+        return JSON.stringify({ additional_context: context });
+    return JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: context } });
+}
+function parsePayload(raw) {
+    try {
+        return asObj(JSON.parse(raw)) ?? {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function runHook(harness, raw, deps = {}) {
+    // Gemini and Cursor parse stdout as JSON on every event.
+    const emptyOut = harness === 'gemini-cli' || harness === 'cursor' ? '{}' : '';
+    let out = '';
+    try {
+        if (!HARNESSES.includes(harness))
+            return emptyOut;
+        const h = harness;
+        const payload = parsePayload(raw);
+        const event = classifyEvent(asStr(payload.hook_event_name) ?? '');
+        const cursorRoot = h === 'cursor' && Array.isArray(payload.workspace_roots) ? asStr(payload.workspace_roots[0]) : undefined;
+        const sessionId = asStr(h === 'cursor' ? payload.conversation_id ?? payload.session_id : payload.session_id);
+        const knownCwd = cursorRoot ?? asStr(payload.cwd);
+        const cwd = knownCwd ?? process.cwd();
+        const transcript = asStr(payload.transcript_path);
+        const cfg = await readConfig();
+        const capturing = !!cfg?.preferences?.capture_transcripts || !!cfg?.preferences?.capture_artifacts;
+        if (cfg?.api_key && capturing && sessionId && knownCwd) {
+            await recordSessionCwd(configDir(), sessionRunId(h, sessionId), knownCwd);
+        }
+        if (event === 'other' || event === 'file-edit')
+            return emptyOut;
+        if (event === 'start') {
+            const context = !cfg?.api_key
+                ? NOT_CONNECTED
+                : cfg.preferences?.auto_context
+                    ? await recentSessions(cfg, h, cwd, sessionId, deps.now ?? Date.now())
+                    : undefined;
+            out = formatContext(h, context);
+        }
+        if (cfg?.api_key && capturing) {
+            (deps.spawnSync ?? spawnDetachedSync)([
+                '--quiet',
+                '--harness',
+                h,
+                ...(sessionId ? ['--session', sessionId] : []),
+                ...(transcript ? ['--transcript', transcript] : []),
+                '--cwd',
+                cwd,
+                ...(event === 'force' ? ['--force'] : event === 'start' ? ['--start'] : []),
+            ]);
+        }
+    }
+    catch {
+        // A hook failure must never surface in, or block, the agent session.
+    }
+    return out || emptyOut;
+}
+function readStdin(timeoutMs) {
+    return new Promise((resolve) => {
+        if (process.stdin.isTTY)
+            return resolve('');
+        let data = '';
+        const done = () => {
+            clearTimeout(timer);
+            process.stdin.destroy();
+            resolve(data);
+        };
+        const timer = setTimeout(done, timeoutMs);
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (chunk) => (data += chunk));
+        process.stdin.on('end', done);
+        process.stdin.on('error', done);
+    });
+}
+export async function cmdHook(harness) {
+    try {
+        const out = await runHook(harness, await readStdin(STDIN_TIMEOUT_MS));
+        if (out)
+            process.stdout.write(`${out}\n`);
+    }
+    catch {
+        // runHook already swallows; this guards stdin/stdout edge cases.
+    }
+    process.exitCode = 0;
+}

package/dist/commands/init.js

@@ -1,11 +1,15 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
 import prompts from 'prompts';
 import kleur from 'kleur';
 import { CliApiClient } from '../lib/api-client.js';
-import { DEFAULT_API_URL, DEFAULT_PREFERENCES, readConfig, writeConfig, } from '../lib/config.js';
+import { DEFAULT_API_URL, DEFAULT_PREFERENCES, hasSavedPreferences, readConfig, writeConfig, } from '../lib/config.js';
+import { ensureCaptureConsent } from '../lib/consent.js';
 import { pollAuth } from '../lib/poll-auth.js';
 import { detectInstalledAgents, wireAgent } from '../lib/detect-agents.js';
 import { writeAllInstructions } from '../lib/auto-context.js';
-import { installClaudeSkill } from '../lib/skill.js';
+import { CLAUDE_MANUAL_STEPS, CODEX_TRUST_NOTE, HARNESS_LABELS, HOOK_HARNESSES, harnessInstalled, installClaudePlugin, wireHarness, } from '../lib/harness-wiring.js';
 async function runPrivacyOptIn(existing, yes) {
     const start = { ...DEFAULT_PREFERENCES, ...(existing ?? {}) };
     process.stdout.write(`\n${kleur.bold('Your AI memory')}\n`);
@@ -61,114 +65,134 @@ async function runPrivacyOptIn(existing, yes) {
     process.stdout.write(`${kleur.dim('Change anytime with `adrive privacy`.')}\n`);
     return { preferences };
 }
+async function confirm(yes, message) {
+    if (yes)
+        return true;
+    const res = (await prompts({ type: 'confirm', name: 'ok', message, initial: true }));
+    return !!res.ok;
+}
+function errorMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+async function wireClaudeCode(yes, home) {
+    if (!(await dirExists(join(home, '.claude'))))
+        return 'skipped (not installed)';
+    if (!(await confirm(yes, 'Install the AgentDrive plugin into Claude Code?')))
+        return 'skipped (declined)';
+    const result = installClaudePlugin();
+    if (result.status === 'installed')
+        return 'wired (plugin agentdrive@agentdrive)';
+    process.stdout.write(`  In Claude Code, run:\n${CLAUDE_MANUAL_STEPS.map((s) => `      ${s}`).join('\n')}\n`);
+    return result.status === 'no-claude'
+        ? 'manual step needed (`claude` not on PATH; see above)'
+        : `manual step needed (${result.detail}; see above)`;
+}
+async function dirExists(p) {
+    try {
+        return (await fs.stat(p)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
 export async function cmdInit(opts = {}) {
+    const yes = !!opts.yes;
+    const home = homedir();
     const existing = await readConfig();
+    const preferencesSaved = await hasSavedPreferences();
     const apiUrl = opts.apiUrl ?? existing?.api_url ?? DEFAULT_API_URL;
-    let apiKey = existing?.api_key;
-    let agentId = existing?.agent_id;
-    let orgId = existing?.org_id;
-    if (apiKey) {
-        process.stdout.write(`Already logged in (api key ${apiKey.slice(0, 12)}...).\n`);
-        if (!opts.yes) {
+    let config = { ...existing, api_url: apiUrl, agent_platform: 'cli' };
+    if (config.api_key) {
+        process.stdout.write(`Already logged in (api key ${config.api_key.slice(0, 12)}...).\n`);
+        if (!yes) {
             const res = await prompts({
                 type: 'confirm',
                 name: 'relogin',
                 message: 'Log in again?',
                 initial: false,
             });
-            if (res.relogin) {
-                apiKey = undefined;
-            }
+            if (res.relogin)
+                config.api_key = undefined;
         }
     }
-    if (!apiKey) {
+    if (!config.api_key) {
         process.stdout.write(`${kleur.bold('Step 1.')} Log in.\n`);
-        const client = new CliApiClient({ baseUrl: apiUrl, agentPlatform: 'cli' });
-        const auth = await pollAuth(client);
-        apiKey = auth.api_key;
-        agentId = auth.agent_id;
-        orgId = auth.org_id;
-    }
-    // Step 2 — wire detected MCP clients.
-    process.stdout.write(`\n${kleur.bold('Step 2.')} Detect installed agent tools.\n`);
-    const installed = await detectInstalledAgents();
-    if (installed.length === 0) {
-        process.stdout.write('  No agent configs found. Skipping MCP wiring.\n');
+        const auth = await pollAuth(new CliApiClient({ baseUrl: apiUrl, agentPlatform: 'cli' }));
+        config = { ...config, api_key: auth.api_key, agent_id: auth.agent_id, org_id: auth.org_id };
     }
-    else {
-        process.stdout.write(`  Found: ${installed.map((t) => t.name).join(', ')}\n`);
-    }
-    const wired = [];
-    const skipped = [];
-    for (const t of installed) {
-        let go = opts.yes ?? false;
-        if (!go) {
-            const res = await prompts({
-                type: 'confirm',
-                name: 'wire',
-                message: `Wire AgentDrive MCP into ${t.name} (${t.configPath})?`,
-                initial: true,
-            });
-            go = !!res.wire;
+    config = await ensureCaptureConsent(config, new CliApiClient({ baseUrl: apiUrl, apiKey: config.api_key, agentPlatform: 'cli' }), { interactive: !yes, preferencesSaved });
+    // Saved before wiring: hooks and the MCP server read the key from this file.
+    await writeConfig(config);
+    process.stdout.write(`\n${kleur.bold('Step 2.')} Connect agent harnesses.\n`);
+    const summary = [];
+    summary.push(['Claude Code', await wireClaudeCode(yes, home)]);
+    let codexWired = false;
+    for (const h of HOOK_HARNESSES) {
+        const label = HARNESS_LABELS[h];
+        if (!(await harnessInstalled(h, home))) {
+            summary.push([label, 'skipped (not installed)']);
+            continue;
+        }
+        if (!(await confirm(yes, `Wire AgentDrive into ${label} (hooks, MCP, commands)?`))) {
+            summary.push([label, 'skipped (declined)']);
+            continue;
+        }
+        try {
+            const wiring = await wireHarness(h, home);
+            for (const p of wiring.changed)
+                process.stdout.write(`  ${kleur.green('+')} ${p}\n`);
+            for (const w of wiring.warnings)
+                process.stdout.write(`  ${kleur.yellow('!')} ${label}: ${w}\n`);
+            summary.push([label, wiring.changed.length ? 'wired' : 'wired (already up to date)']);
+            if (h === 'codex')
+                codexWired = true;
         }
-        if (!go) {
-            skipped.push(t.name);
+        catch (err) {
+            summary.push([label, `skipped (${errorMessage(err)})`]);
+        }
+    }
+    for (const t of await detectInstalledAgents({ home })) {
+        if (!(await confirm(yes, `Wire AgentDrive MCP into ${t.name} (${t.configPath})?`))) {
+            summary.push([t.name, 'skipped (declined)']);
             continue;
         }
         try {
-            await wireAgent(t, { apiKey: apiKey, apiUrl, agentPlatform: t.defaultPlatform });
-            wired.push(t.name);
+            const action = await wireAgent(t);
+            summary.push([t.name, action === 'unchanged' ? 'MCP wired (already up to date)' : 'MCP wired']);
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            skipped.push(`${t.name} (${msg})`);
+            summary.push([t.name, `skipped (${errorMessage(err)})`]);
         }
     }
-    // Step 3 — privacy + memory preferences (WhatsApp-style opt-in screen).
     process.stdout.write(`\n${kleur.bold('Step 3.')} Privacy + memory preferences.\n`);
-    const { preferences } = await runPrivacyOptIn(existing?.preferences, !!opts.yes);
-    // Step 4 — write auto-context instructions to detected agent hosts so the
-    // agent automatically reaches for AgentDrive at the right moments.
-    let instructionsWritten = [];
+    const { preferences } = await runPrivacyOptIn(config.preferences, yes);
     if (preferences.auto_context) {
         process.stdout.write(`\n${kleur.bold('Step 4.')} Write auto-context instructions.\n`);
-        const results = await writeAllInstructions();
-        instructionsWritten = results
-            .filter((r) => r.action !== 'unchanged')
-            .map((r) => r.path);
-        if (instructionsWritten.length > 0) {
-            for (const p of instructionsWritten) {
-                process.stdout.write(`  ${kleur.green('+')} ${p}\n`);
-            }
+        try {
+            const written = (await writeAllInstructions(home)).filter((r) => r.action !== 'unchanged');
+            for (const r of written)
+                process.stdout.write(`  ${kleur.green('+')} ${r.path}\n`);
+            if (written.length === 0)
+                process.stdout.write('  No new instructions to write.\n');
         }
-        else {
-            process.stdout.write('  No new instructions to write.\n');
+        catch (err) {
+            process.stdout.write(`  ${kleur.yellow('!')} ${errorMessage(err)}\n`);
         }
     }
-    // Step 4b — install the Claude Code skill file. Skips silently when ~/.claude
-    // is missing OR when the auto-context preflight was just written above
-    // (would double-fire on the same triggers).
-    const skillResult = await installClaudeSkill();
-    if (skillResult.action === 'created' || skillResult.action === 'updated') {
-        process.stdout.write(`  ${kleur.green('+')} ${skillResult.path}\n`);
-    }
-    await writeConfig({
-        api_url: apiUrl,
-        api_key: apiKey,
-        agent_id: agentId,
-        org_id: orgId,
-        agent_platform: 'cli',
-        default_workspace: existing?.default_workspace,
-        preferences,
-    });
+    await writeConfig({ ...config, preferences });
     process.stdout.write(`\n${kleur.bold('Summary')}\n`);
-    process.stdout.write(`  Wired:        ${wired.length ? wired.join(', ') : '(none)'}\n`);
-    process.stdout.write(`  Skipped:      ${skipped.length ? skipped.join(', ') : '(none)'}\n`);
-    process.stdout.write(`  Auto-context: ${preferences.auto_context ? 'on' : 'off'}\n`);
-    process.stdout.write(`  Capture:      artifacts ${preferences.capture_artifacts ? 'on' : 'off'}, transcripts ${preferences.capture_transcripts ? 'on' : 'off'}\n`);
-    process.stdout.write(`  Encryption:   ${preferences.private_workspace ? 'on (E2E)' : 'off'}\n`);
+    const width = Math.max(...summary.map(([name]) => name.length)) + 2;
+    for (const [name, status] of summary) {
+        process.stdout.write(`  ${name.padEnd(width)}${status}\n`);
+    }
+    process.stdout.write(`  ${'Auto-context'.padEnd(width)}${preferences.auto_context ? 'on' : 'off'}\n`);
+    process.stdout.write(`  ${'Capture'.padEnd(width)}transcripts ${preferences.capture_transcripts ? 'on' : 'off'}, artifacts ${preferences.capture_artifacts ? 'on' : 'off'}\n`);
+    process.stdout.write(`  ${'Encryption'.padEnd(width)}${preferences.private_workspace ? 'on (E2E)' : 'off'}\n`);
+    if (codexWired) {
+        process.stdout.write(`\n${kleur.bold('One-time step')}\n  ${CODEX_TRUST_NOTE}\n`);
+    }
     process.stdout.write('\nNext steps:\n');
-    process.stdout.write('  - Open Claude Code, Cursor, or Codex — AgentDrive is wired.\n');
-    process.stdout.write('  - Try: `adrive search "what did I work on yesterday"`\n');
+    process.stdout.write('  - Start a session in any wired harness; it is captured in the background.\n');
+    process.stdout.write('  - Pick it up anywhere with the resume command (/agentdrive:resume in Claude Code) or `adrive resume`.\n');
     process.stdout.write('  - Change preferences anytime with `adrive privacy`.\n');
 }

package/dist/commands/resume.js

@@ -0,0 +1,41 @@
+import { projectKeyFor, scopeProjectKey } from '@adrive/mcp-server/project';
+import { buildHandoff, isEncrypted, sessionActivityAt } from '@adrive/mcp-server/session';
+import { CliApiClient } from '../lib/api-client.js';
+import { requireLogin } from '../lib/config.js';
+import { decryptContentAsync } from '../lib/crypto.js';
+function title(run) {
+    const t = run.metadata?.title;
+    return typeof t === 'string' && t ? t : run.task;
+}
+export async function cmdResume(id, opts = {}) {
+    const cfg = await requireLogin();
+    const client = new CliApiClient({
+        baseUrl: cfg.api_url,
+        apiKey: cfg.api_key,
+        agentPlatform: cfg.agent_platform ?? 'cli',
+        agentRole: cfg.agent_role,
+    });
+    const project = scopeProjectKey(projectKeyFor(process.cwd()), !!cfg.preferences?.private_workspace);
+    if (opts.list) {
+        const runs = await client.listRuns({ project, limit: 10 });
+        if (runs.length === 0) {
+            process.stdout.write(`No sessions for project ${project}.\n`);
+            return;
+        }
+        for (const r of runs) {
+            const when = new Date(sessionActivityAt(r)).toISOString();
+            process.stdout.write(`${r.run_id}  ${r.agent_platform}  ${when}  ${title(r)}\n`);
+        }
+        return;
+    }
+    const run = id ? await client.getRun(id) : (await client.listRuns({ project, limit: 1 }))[0];
+    if (!run)
+        throw new Error(`No sessions for project ${project}.`);
+    const transcriptPath = run.metadata?.transcript_path;
+    if (typeof transcriptPath !== 'string' || !run.workspace_id) {
+        throw new Error(`Session ${run.run_id} has no uploaded transcript.`);
+    }
+    const file = await client.readFileByPath(run.workspace_id, transcriptPath);
+    const markdown = isEncrypted(file.content) ? await decryptContentAsync(cfg.api_key, file.content) : file.content;
+    process.stdout.write(`${buildHandoff(markdown, opts.maxChars)}\n`);
+}

package/dist/commands/sync.js

@@ -0,0 +1,24 @@
+import kleur from 'kleur';
+import { HARNESSES, runSync } from '../lib/sync.js';
+export async function cmdSync(opts = {}) {
+    if (opts.harness && !HARNESSES.includes(opts.harness)) {
+        throw new Error(`Unknown harness: ${opts.harness}. Supported: ${HARNESSES.join(', ')}.`);
+    }
+    const result = await runSync({ ...opts, harness: opts.harness });
+    if (opts.quiet)
+        return;
+    if (result.skipped) {
+        const hint = {
+            'not-logged-in': 'not logged in; run `adrive auth login`',
+            'capture-off': 'capture is off; enable with `adrive privacy --capture-transcripts on` or `--capture-artifacts on`',
+            locked: 'another sync is running',
+            'no-workspace': 'several workspaces and no default_workspace in your config',
+        };
+        process.stdout.write(`${kleur.yellow('[skip]')} ${hint[result.skipped]}\n`);
+        return;
+    }
+    for (const [harness, s] of Object.entries(result.perHarness)) {
+        process.stdout.write(`${harness}: ${s.parsed} sessions, ${s.files} files${opts.dryRun ? ' (dry run)' : ''}\n`);
+    }
+    process.stdout.write(`${kleur.bold('Synced')} ${result.synced.length}, unchanged ${result.unchanged}, debounced ${result.debounced}, failed ${result.failed}.\n`);
+}

package/dist/index.js

@@ -16,7 +16,9 @@ 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';
@@ -115,8 +117,6 @@ program
     .description('Auto-pull relevant artifacts for a task')
     .option('--limit <n>', 'Max artifacts to return')
     .option('-w, --workspace <id>', 'Restrict to one workspace')
-    .option('--install-skill', 'Install the Claude Code SKILL.md (~/.claude/skills/agentdrive/)')
-    .option('--force', 'With --install-skill, write even if the auto-context preflight is already in CLAUDE.md')
     .action(wrap((task, opts) => cmdContext(task, opts)));
 program
     .command('run-log <task>')
@@ -152,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>', 'claude-code | codex | cursor | all (default: all)', 'all')
-    .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')