@adrive/cli 0.3.0 → 1.0.0

package/README.md

@@ -1,6 +1,6 @@
 # @adrive/cli
 
-The `adrive` binary — a thin CLI for [AgentDrive](https://agentdrive.sh), the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph.
+The `adrive` binary — a thin CLI for [AgentDrive](https://agentdrive.sh), the cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph.
 
 ## Install
 

package/dist/commands/context.js

@@ -1,12 +1,22 @@
 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);
+    }
     const cfg = await requireLogin();
     const client = new CliApiClient({
         baseUrl: cfg.api_url,
@@ -25,8 +35,15 @@ export async function cmdContext(task, opts = {}) {
         return;
     }
     for (const a of res.artifacts) {
-        const score = a.score.toFixed(2);
+        const score = a.score === null ? 'keyword' : a.score.toFixed(2);
         process.stdout.write(`${kleur.cyan(a.path)} · score=${score} · by=${a.agent_id}@${a.agent_platform}\n`);
+        if (a.attribution?.reasons?.length) {
+            process.stdout.write(`  ${kleur.dim('why: ' + a.attribution.reasons.join(' · '))}\n`);
+        }
+        if (a.last_run) {
+            const lr = a.last_run;
+            process.stdout.write(`  ${kleur.dim('last run: ' + truncate(lr.task, 80) + ` [${lr.status}, ${lr.agent_platform}]`)}\n`);
+        }
         if (a.snippet)
             process.stdout.write(`  ${kleur.dim(truncate(a.snippet, 500))}\n`);
     }

package/dist/commands/init.js

@@ -5,6 +5,7 @@ import { DEFAULT_API_URL, DEFAULT_PREFERENCES, readConfig, writeConfig, } from '
 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';
 async function runPrivacyOptIn(existing, yes) {
     const start = { ...DEFAULT_PREFERENCES, ...(existing ?? {}) };
     process.stdout.write(`\n${kleur.bold('Your AI memory')}\n`);
@@ -144,6 +145,13 @@ export async function cmdInit(opts = {}) {
             process.stdout.write('  No new instructions to write.\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,

package/dist/commands/timeline.js

@@ -0,0 +1,65 @@
+import kleur from 'kleur';
+import { CliApiClient } from '../lib/api-client.js';
+import { requireLogin } from '../lib/config.js';
+// Platform tints inspired by D4 (variant 2A "tinted pill with letter glyph").
+// Falls through to no-color on unknown / undefined platforms.
+const PLATFORM_GLYPH = {
+    'claude-code': { glyph: 'CC', tint: (s) => kleur.magenta().bold(s) },
+    codex: { glyph: 'CX', tint: (s) => kleur.cyan().bold(s) },
+    cursor: { glyph: 'CR', tint: (s) => kleur.blue().bold(s) },
+    langgraph: { glyph: 'LG', tint: (s) => kleur.yellow().bold(s) },
+    crewai: { glyph: 'CA', tint: (s) => kleur.green().bold(s) },
+    autogen: { glyph: 'AG', tint: (s) => kleur.green().bold(s) },
+    hermes: { glyph: 'HM', tint: (s) => kleur.red().bold(s) },
+    openclaw: { glyph: 'OC', tint: (s) => kleur.red().bold(s) },
+};
+function badge(platform) {
+    const key = platform ?? 'unknown';
+    const entry = PLATFORM_GLYPH[key];
+    if (!entry)
+        return kleur.dim('— ');
+    return entry.tint(entry.glyph);
+}
+function actorLabel(ev) {
+    if (ev.actor_type === 'human')
+        return ev.actor_id;
+    return ev.actor_id.length > 14 ? `${ev.actor_id.slice(0, 14)}…` : ev.actor_id;
+}
+function formatTimestamp(iso) {
+    const d = new Date(iso);
+    const yyyy = d.getUTCFullYear();
+    const mm = String(d.getUTCMonth() + 1).padStart(2, '0');
+    const dd = String(d.getUTCDate()).padStart(2, '0');
+    const hh = String(d.getUTCHours()).padStart(2, '0');
+    const min = String(d.getUTCMinutes()).padStart(2, '0');
+    return `${yyyy}-${mm}-${dd} ${hh}:${min}Z`;
+}
+function startOfTodayIso() {
+    const now = new Date();
+    return new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate())).toISOString();
+}
+export async function cmdTimeline(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 limit = opts.limit ? Number.parseInt(opts.limit, 10) : undefined;
+    const since = opts.today ? startOfTodayIso() : opts.since;
+    const { items, truncated } = await client.timeline({ since, limit });
+    if (items.length === 0) {
+        process.stdout.write('No events in window.\n');
+        return;
+    }
+    for (const ev of items) {
+        const action = kleur.cyan(ev.action.padEnd(16));
+        const target = ev.target_path ?? ev.target_id;
+        process.stdout.write(`${kleur.dim(formatTimestamp(ev.created_at))}  ${badge(ev.agent_platform)}  ` +
+            `${action} ${kleur.dim(actorLabel(ev))} ${kleur.dim('→')} ${target}\n`);
+    }
+    if (truncated) {
+        process.stdout.write(kleur.dim(`\n${items.length} shown; capped by --limit. Re-run with a tighter --since to page back.\n`));
+    }
+}

package/dist/commands/transcripts.js

@@ -1,111 +1,26 @@
-import { promises as fs } from 'node:fs';
-import { homedir } from 'node:os';
-import { join, basename } from 'node:path';
 import kleur from 'kleur';
-import { CliApiClient } from '../lib/api-client.js';
-import { requireLogin, configDir } from '../lib/config.js';
-import { encryptContentAsync } from '../lib/crypto.js';
-import { redact, summarizeHits } from '../lib/redactor.js';
-function manifestPath() {
-    return join(configDir(), 'transcripts.manifest.json');
-}
-async function readManifest() {
-    try {
-        const raw = await fs.readFile(manifestPath(), 'utf8');
-        return JSON.parse(raw);
-    }
-    catch {
-        return { ingested: {} };
-    }
-}
-async function writeManifest(m) {
-    await fs.mkdir(configDir(), { recursive: true, mode: 0o700 });
-    await fs.writeFile(manifestPath(), JSON.stringify(m, null, 2), { encoding: 'utf8', mode: 0o600 });
-}
-async function findClaudeTranscripts() {
-    const projectsDir = join(homedir(), '.claude', 'projects');
-    let projects;
-    try {
-        projects = await fs.readdir(projectsDir);
-    }
-    catch {
-        return [];
-    }
-    const out = [];
-    for (const p of projects) {
-        const pdir = join(projectsDir, p);
-        let files;
-        try {
-            files = await fs.readdir(pdir);
-        }
-        catch {
-            continue;
-        }
-        for (const f of files) {
-            if (!f.endsWith('.jsonl'))
-                continue;
-            const full = join(pdir, f);
-            let stat;
-            try {
-                stat = await fs.stat(full);
-            }
-            catch {
-                continue;
-            }
-            out.push({
-                sessionId: f.replace(/\.jsonl$/, ''),
-                path: full,
-                mtime: stat.mtime,
-                projectDir: p,
-            });
-        }
-    }
-    return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
-}
-function extractTurn(line) {
-    let obj;
-    try {
-        obj = JSON.parse(line);
-    }
-    catch {
-        return null;
-    }
-    const type = obj.type ?? '';
-    const ts = obj.timestamp ?? undefined;
-    if (type === 'user' || type === 'assistant') {
-        const msg = obj.message;
-        if (!msg)
-            return null;
-        const role = msg.role ?? type;
-        const content = msg.content;
-        let text = '';
-        if (typeof content === 'string') {
-            text = content;
-        }
-        else if (Array.isArray(content)) {
-            for (const part of content) {
-                if (typeof part === 'string')
-                    text += part;
-                else if (part && typeof part === 'object' && 'text' in part) {
-                    text += String(part.text);
-                }
-            }
-        }
-        if (!text.trim())
-            return null;
-        return { role, text, ts };
-    }
-    return null;
-}
-function formatTranscript(turns) {
-    const lines = [];
-    for (const t of turns) {
-        lines.push(`## ${t.role}${t.ts ? `  _(${t.ts})_` : ''}`);
-        lines.push('');
-        lines.push(t.text);
-        lines.push('');
-    }
-    return lines.join('\n');
+import { requireLogin } from '../lib/config.js';
+import { claudeSource } from '../lib/transcripts/claude.js';
+import { codexSource } from '../lib/transcripts/codex.js';
+import { cursorSource } from '../lib/transcripts/cursor.js';
+import { ingestSource } from '../lib/transcripts/ingest.js';
+const SOURCES = {
+    'claude-code': claudeSource,
+    codex: codexSource,
+    cursor: cursorSource,
+};
+function selectSources(platform) {
+    if (!platform || platform === 'all') {
+        // Cursor is intentionally excluded from --all until Phase 2.5 because its
+        // enumerate() throws. Users that want it must opt in explicitly with
+        // --platform cursor and get the "not yet" error.
+        return [claudeSource, codexSource];
+    }
+    const source = SOURCES[platform];
+    if (!source) {
+        throw new Error(`Unknown platform: ${platform}. Supported: claude-code, codex, cursor, all.`);
+    }
+    return [source];
 }
 export async function cmdTranscriptsIngest(opts = {}) {
     const cfg = await requireLogin();
@@ -115,96 +30,27 @@ export async function cmdTranscriptsIngest(opts = {}) {
             `       or run a one-off dry-run with \`adrive transcripts ingest --dry-run\`.\n`);
         process.exit(2);
     }
-    const platform = opts.platform ?? 'claude-code';
-    if (platform !== 'claude-code') {
-        throw new Error(`Transcript ingestion for ${platform} is not implemented yet.`);
-    }
-    const all = await findClaudeTranscripts();
-    let entries = all;
-    if (opts.since) {
-        const since = new Date(opts.since);
-        if (Number.isNaN(since.getTime()))
-            throw new Error('Invalid --since date.');
-        entries = entries.filter((e) => e.mtime > since);
-    }
-    if (typeof opts.limit === 'number')
-        entries = entries.slice(0, opts.limit);
-    if (entries.length === 0) {
-        process.stdout.write('No transcripts found.\n');
-        return;
-    }
-    const manifest = await readManifest();
-    const client = new CliApiClient({
-        baseUrl: cfg.api_url,
-        apiKey: cfg.api_key,
-        agentPlatform: cfg.agent_platform ?? 'cli',
-        agentRole: cfg.agent_role,
-    });
-    let workspaceId = opts.workspace ?? cfg.default_workspace;
-    if (!workspaceId && !opts.dryRun) {
-        const list = await client.listWorkspaces();
-        if (list.length === 1)
-            workspaceId = list[0].id;
-        else if (list.length === 0)
-            throw new Error('No workspaces. Create one first.');
-        else
-            throw new Error('Multiple workspaces — specify --workspace <id>.');
-    }
-    const encrypt = !!cfg.preferences?.private_workspace;
-    process.stdout.write(`${kleur.bold(`Found ${entries.length} ${platform} transcripts.`)}\n`);
-    let ingested = 0;
-    let skipped = 0;
-    for (const e of entries) {
-        if (!opts.reingest && manifest.ingested[e.sessionId]) {
-            skipped++;
-            continue;
-        }
-        let raw;
+    const sources = selectSources(opts.platform);
+    let totalIngested = 0;
+    let totalSkipped = 0;
+    for (const source of sources) {
         try {
-            raw = await fs.readFile(e.path, 'utf8');
-        }
-        catch {
-            continue;
-        }
-        const turns = [];
-        for (const line of raw.split(/\r?\n/)) {
-            if (!line.trim())
-                continue;
-            const turn = extractTurn(line);
-            if (turn)
-                turns.push(turn);
-        }
-        if (turns.length === 0) {
-            skipped++;
-            continue;
-        }
-        const md = `# Transcript — ${platform} / ${e.sessionId}\n\n` +
-            `Project: ${e.projectDir}\nLast modified: ${e.mtime.toISOString()}\nTurns: ${turns.length}\n\n` +
-            formatTranscript(turns);
-        const { redacted, hits } = redact(md);
-        const remotePath = `transcripts/${platform}/${e.sessionId}.md`;
-        const tag = summarizeHits(hits);
-        if (opts.dryRun) {
-            process.stdout.write(`${kleur.dim('[dry]')} ${remotePath} ${kleur.dim(`(${turns.length} turns, redactor: ${tag})`)}\n`);
-            ingested++;
-            continue;
-        }
-        try {
-            const body = encrypt ? await encryptContentAsync(cfg.api_key, redacted) : redacted;
-            await client.writeFile(workspaceId, remotePath, body, `transcript ingest (${tag})`);
-            manifest.ingested[e.sessionId] = new Date().toISOString();
-            ingested++;
-            process.stdout.write(`${kleur.green('[ok]')}  ${remotePath}` +
-                (encrypt ? kleur.cyan(' (encrypted)') : '') +
-                (hits.length ? kleur.yellow(` (redacted: ${tag})`) : '') +
-                '\n');
+            const result = await ingestSource(source, cfg, {
+                workspace: opts.workspace,
+                since: opts.since,
+                dryRun: opts.dryRun,
+                limit: opts.limit,
+                reingest: opts.reingest,
+            });
+            totalIngested += result.ingested;
+            totalSkipped += result.skipped;
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            process.stderr.write(`${kleur.red('[err]')} ${basename(e.path)}: ${msg}\n`);
+            process.stderr.write(`${kleur.red('[err]')} ${source.platform}: ${msg}\n`);
         }
     }
-    if (!opts.dryRun)
-        await writeManifest(manifest);
-    process.stdout.write(`\nIngested ${ingested}, skipped ${skipped}.\n`);
+    if (sources.length > 1) {
+        process.stdout.write(`\n${kleur.bold('Total')}: ${totalIngested} ingested, ${totalSkipped} skipped.\n`);
+    }
 }

package/dist/index.js

@@ -17,6 +17,7 @@ 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 { 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,10 +104,19 @@ 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')
+    .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>')
@@ -146,7 +156,7 @@ const transcripts = program.command('transcripts').description('Ingest chat tran
 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('--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))

package/dist/lib/api-client.js

@@ -119,4 +119,19 @@ export class CliApiClient {
     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/skill.js

@@ -0,0 +1,117 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+// Source-of-truth for the Claude Code skill file. The shell installer
+// (apps/installer/install.sh) inlines this content too — keep them in sync
+// when SKILL_MARKDOWN changes.
+export const SKILL_MARKDOWN = `---
+name: agentdrive
+description: |
+  Persistent cross-platform workspace for AI agents. Use this skill when the
+  user wants to share files between agent sessions, retrieve prior context,
+  log a run, or work with the AgentDrive MCP server but those tools are not
+  available. Calls the local \`adrive\` CLI as a fallback.
+---
+
+# AgentDrive — shared artifact workspace for multi-agent workflows
+
+If the \`drive_*\` MCP tools are wired, prefer them. Use the \`adrive\` CLI when
+the MCP server is not available or for shell-level workflows.
+
+## When to use this skill
+
+Trigger on any of these patterns:
+
+- "Share this with Codex / Cursor / my other agent"
+- "What did the last session produce?"
+- "What did Codex / Cursor / Claude work on?"
+- "Pull context for this task"
+- "Save this artifact so the next agent can find it"
+- "Log this run" / "remember what I just did"
+- "Search my workspace for X"
+- The user mentions a workspace, share link, or cross-agent handoff
+
+## Commands
+
+\`\`\`
+adrive context "<task>" [--limit N]                  # auto-pull relevant artifacts
+adrive search "<query>" [--top-k N]                  # semantic search
+adrive push <file> [--workspace ws] [--remote-path]  # write artifact
+adrive pull <ws-id>/<path> [-o out]                  # read artifact
+adrive run-log "<task>" --status success             # log a run
+adrive ls                                            # list workspaces
+adrive whoami                                        # show principal
+\`\`\`
+
+\`adrive\` reads its config from \`~/.config/agentdrive/config.json\` so the user
+is already authenticated. If the user is NOT authenticated, prompt them to
+run \`adrive init\` first instead of guessing.
+
+## Output handling
+
+\`adrive context\` returns each artifact with an \`attribution\` block. When
+you cite the artifact to the user, mention *why* it surfaced
+(\`reasons: ["high semantic match", "still fresh"]\`). When the artifact has a
+\`last_run\` block, mention the prior run's task so the user sees the
+narrative thread.
+
+## Privacy
+
+Respect \`adrive privacy\` settings. If the user has "Private workspace" on,
+written content is encrypted client-side; server stores only ciphertext.
+`;
+// Marker that auto-context.ts writes into CLAUDE.md. If present, the user
+// already has the MCP preflight wired and the skill would double-fire.
+const AUTO_CONTEXT_MARKER = '<!-- agentdrive:auto-context:begin -->';
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function installClaudeSkill(opts = {}) {
+    const home = opts.home ?? homedir();
+    const claudeDir = join(home, '.claude');
+    const skillPath = join(claudeDir, 'skills', 'agentdrive', 'SKILL.md');
+    if (!(await fileExists(claudeDir))) {
+        return { path: skillPath, action: 'skipped-no-claude' };
+    }
+    if (!opts.force) {
+        const claudeMdPath = join(claudeDir, 'CLAUDE.md');
+        if (await fileExists(claudeMdPath)) {
+            const claudeMd = await fs.readFile(claudeMdPath, 'utf8');
+            if (claudeMd.includes(AUTO_CONTEXT_MARKER)) {
+                return { path: skillPath, action: 'skipped-preflight-installed' };
+            }
+        }
+    }
+    const existed = await fileExists(skillPath);
+    if (existed) {
+        const current = await fs.readFile(skillPath, 'utf8');
+        if (current === SKILL_MARKDOWN) {
+            return { path: skillPath, action: 'unchanged' };
+        }
+        await fs.writeFile(skillPath, SKILL_MARKDOWN, 'utf8');
+        return { path: skillPath, action: 'updated' };
+    }
+    await fs.mkdir(dirname(skillPath), { recursive: true });
+    await fs.writeFile(skillPath, SKILL_MARKDOWN, 'utf8');
+    return { path: skillPath, action: 'created' };
+}
+export function describeSkillAction(action) {
+    switch (action) {
+        case 'created':
+            return 'created';
+        case 'updated':
+            return 'updated';
+        case 'unchanged':
+            return 'already up to date';
+        case 'skipped-no-claude':
+            return 'skipped (no ~/.claude directory; Claude Code not installed)';
+        case 'skipped-preflight-installed':
+            return 'skipped (auto-context preflight is already in CLAUDE.md — use --force to override)';
+    }
+}

package/dist/lib/transcripts/claude.js

@@ -0,0 +1,112 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+// Claude Code session format:
+//   ~/.claude/projects/<encoded-cwd>/<session-id>.jsonl
+//
+// Each line is a JSON object. We care about lines where
+//   type === 'user' or 'assistant'
+// with a nested `message: { role, content }`. Content is a string OR
+// an array of message parts. Tool calls and intermediate states are
+// skipped — agents already see the natural-language turns.
+export const claudeSource = {
+    platform: 'claude-code',
+    async enumerate({ home, since }) {
+        const projectsDir = join(home, '.claude', 'projects');
+        let projects;
+        try {
+            projects = await fs.readdir(projectsDir);
+        }
+        catch {
+            return [];
+        }
+        const out = [];
+        for (const p of projects) {
+            const pdir = join(projectsDir, p);
+            let files;
+            try {
+                files = await fs.readdir(pdir);
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                if (!f.endsWith('.jsonl'))
+                    continue;
+                const full = join(pdir, f);
+                let stat;
+                try {
+                    stat = await fs.stat(full);
+                }
+                catch {
+                    continue;
+                }
+                if (since && stat.mtime <= since)
+                    continue;
+                const sessionId = f.replace(/\.jsonl$/, '');
+                out.push({
+                    manifestKey: `claude-code:${sessionId}`,
+                    sessionId,
+                    path: full,
+                    mtime: stat.mtime,
+                    label: p,
+                });
+            }
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        let raw;
+        try {
+            raw = await fs.readFile(entry.path, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        const turns = [];
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const turn = extractTurn(line);
+            if (turn)
+                turns.push(turn);
+        }
+        if (turns.length === 0)
+            return null;
+        return { entry, turns };
+    },
+};
+export function extractTurn(line) {
+    let obj;
+    try {
+        obj = JSON.parse(line);
+    }
+    catch {
+        return null;
+    }
+    const type = obj.type ?? '';
+    const ts = obj.timestamp ?? undefined;
+    if (type === 'user' || type === 'assistant') {
+        const msg = obj.message;
+        if (!msg)
+            return null;
+        const role = msg.role ?? type;
+        const content = msg.content;
+        let text = '';
+        if (typeof content === 'string') {
+            text = content;
+        }
+        else if (Array.isArray(content)) {
+            for (const part of content) {
+                if (typeof part === 'string')
+                    text += part;
+                else if (part && typeof part === 'object' && 'text' in part) {
+                    text += String(part.text);
+                }
+            }
+        }
+        if (!text.trim())
+            return null;
+        return { role, text, ts };
+    }
+    return null;
+}

package/dist/lib/transcripts/codex.js

@@ -0,0 +1,168 @@
+import { promises as fs } from 'node:fs';
+import { join } from 'node:path';
+// OpenAI Codex CLI session format:
+//   ~/.codex/sessions/<YYYY>/<MM>/<DD>/rollout-<ISO-date>-<session-id>.jsonl
+//
+// The first line is a `session_meta` record carrying the session id, cli
+// version, cwd, and base instructions. Subsequent lines carry the turn
+// stream as `{ timestamp, type, payload }`. We extract user + assistant
+// text from `type: 'turn'` records (with `payload.role` + `payload.content`)
+// and from `type: 'response_item'` records (with `payload.type: 'message'`
+// and `payload.content[*].text`). Older Codex versions vary slightly; we
+// only require that text fields exist where we expect them and drop the
+// rest. Tool calls / reasoning / system events are skipped — agents only
+// need the natural-language turns.
+//
+// Per Codex finding #11, the on-disk format may shift between CLI versions.
+// The parser stays permissive: unknown record types are silently ignored
+// rather than crashing the ingest.
+const SESSION_ID_RE = /^rollout-.+-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl$/i;
+async function walkRolloutFiles(root) {
+    // Walks the YYYY/MM/DD tree depth-first. Tolerant of missing dirs.
+    const acc = [];
+    let years;
+    try {
+        years = await fs.readdir(root);
+    }
+    catch {
+        return [];
+    }
+    for (const y of years) {
+        const ydir = join(root, y);
+        let months;
+        try {
+            months = await fs.readdir(ydir);
+        }
+        catch {
+            continue;
+        }
+        for (const m of months) {
+            const mdir = join(ydir, m);
+            let days;
+            try {
+                days = await fs.readdir(mdir);
+            }
+            catch {
+                continue;
+            }
+            for (const d of days) {
+                const ddir = join(mdir, d);
+                let files;
+                try {
+                    files = await fs.readdir(ddir);
+                }
+                catch {
+                    continue;
+                }
+                for (const f of files) {
+                    if (f.startsWith('rollout-') && f.endsWith('.jsonl')) {
+                        acc.push(join(ddir, f));
+                    }
+                }
+            }
+        }
+    }
+    return acc;
+}
+export const codexSource = {
+    platform: 'codex',
+    async enumerate({ home, since }) {
+        const root = join(home, '.codex', 'sessions');
+        const files = await walkRolloutFiles(root);
+        const out = [];
+        for (const full of files) {
+            let stat;
+            try {
+                stat = await fs.stat(full);
+            }
+            catch {
+                continue;
+            }
+            if (since && stat.mtime <= since)
+                continue;
+            const base = full.split('/').pop() ?? full;
+            const idMatch = base.match(SESSION_ID_RE);
+            const sessionId = idMatch ? idMatch[1] : base.replace(/\.jsonl$/, '');
+            // `label` is best-effort — fill from the cwd in session_meta on parse.
+            out.push({
+                manifestKey: `codex:${sessionId}`,
+                sessionId,
+                path: full,
+                mtime: stat.mtime,
+                label: 'codex session',
+            });
+        }
+        return out.sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+    },
+    async parseSession(entry) {
+        let raw;
+        try {
+            raw = await fs.readFile(entry.path, 'utf8');
+        }
+        catch {
+            return null;
+        }
+        const turns = [];
+        let cwd;
+        for (const line of raw.split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            let obj;
+            try {
+                obj = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            const type = obj.type ?? '';
+            const ts = obj.timestamp ?? undefined;
+            const payload = (obj.payload ?? {});
+            if (type === 'session_meta') {
+                const c = payload.cwd;
+                if (typeof c === 'string')
+                    cwd = c;
+                continue;
+            }
+            // Two known shapes for natural-language turns:
+            //   1. payload.role + payload.content (string or array)
+            //   2. payload.type === 'message' with payload.content[*].text
+            let role;
+            let text = '';
+            if (typeof payload.role === 'string' && payload.content !== undefined) {
+                role = payload.role;
+                const c = payload.content;
+                if (typeof c === 'string')
+                    text = c;
+                else if (Array.isArray(c)) {
+                    for (const part of c) {
+                        if (typeof part === 'string')
+                            text += part;
+                        else if (part && typeof part === 'object' && 'text' in part) {
+                            text += String(part.text);
+                        }
+                    }
+                }
+            }
+            else if (payload.type === 'message') {
+                const innerRole = payload.role;
+                if (typeof innerRole === 'string')
+                    role = innerRole;
+                const c = payload.content;
+                if (Array.isArray(c)) {
+                    for (const part of c) {
+                        if (part && typeof part === 'object' && 'text' in part) {
+                            text += String(part.text);
+                        }
+                    }
+                }
+            }
+            if (role && text.trim()) {
+                turns.push({ role, text, ts });
+            }
+        }
+        if (turns.length === 0)
+            return null;
+        const labeled = cwd ? { ...entry, label: cwd } : entry;
+        return { entry: labeled, turns };
+    },
+};

package/dist/lib/transcripts/cursor.js

@@ -0,0 +1,23 @@
+// Cursor stores chat history in a per-workspace SQLite database at
+//   ~/Library/Application Support/Cursor/User/workspaceStorage/<hash>/state.vscdb
+// (macOS) or the analogous path on Linux. Reading it requires `node:sqlite`
+// (Node 22.5+) or `better-sqlite3`. The CLI's `engines.node` is currently
+// `>=20` so neither is available out of the box.
+//
+// Per CEO plan D3 + Codex tension T3 + finding #11, this surface is brittle
+// reverse-engineering and intentionally kept narrow. The full implementation
+// lands in Phase 2.5 (tracked in TODOS.md). For now this source exposes a
+// clear error so users hit explicit "not yet" rather than silent zero hits.
+const CURSOR_NOT_IMPLEMENTED_MESSAGE = 'Cursor transcript ingestion is not yet available. Reading Cursor SQLite ' +
+    "history requires Node 22.5+ (node:sqlite) or a native dependency. " +
+    'Tracking under Phase 2.5 of the v1 plan.';
+export const cursorSource = {
+    platform: 'cursor',
+    async enumerate(_opts) {
+        throw new Error(CURSOR_NOT_IMPLEMENTED_MESSAGE);
+    },
+    async parseSession(_entry) {
+        throw new Error(CURSOR_NOT_IMPLEMENTED_MESSAGE);
+    },
+};
+export { CURSOR_NOT_IMPLEMENTED_MESSAGE };

package/dist/lib/transcripts/ingest.js

@@ -0,0 +1,115 @@
+import { promises as fs } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import kleur from 'kleur';
+import { CliApiClient } from '../api-client.js';
+import { configDir } from '../config.js';
+import { encryptContentAsync } from '../crypto.js';
+import { redact, summarizeHits } from '../redactor.js';
+function manifestPath() {
+    return join(configDir(), 'transcripts.manifest.json');
+}
+async function readManifest() {
+    try {
+        const raw = await fs.readFile(manifestPath(), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch {
+        return { ingested: {} };
+    }
+}
+async function writeManifest(m) {
+    await fs.mkdir(configDir(), { recursive: true, mode: 0o700 });
+    await fs.writeFile(manifestPath(), JSON.stringify(m, null, 2), { encoding: 'utf8', mode: 0o600 });
+}
+function formatTranscript(turns) {
+    const lines = [];
+    for (const t of turns) {
+        lines.push(`## ${t.role}${t.ts ? `  _(${t.ts})_` : ''}`);
+        lines.push('');
+        lines.push(t.text);
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+function buildMarkdown(platform, doc) {
+    return (`# Transcript — ${platform} / ${doc.entry.sessionId}\n\n` +
+        `Project: ${doc.entry.label}\nLast modified: ${doc.entry.mtime.toISOString()}\n` +
+        `Turns: ${doc.turns.length}\n\n` +
+        formatTranscript(doc.turns));
+}
+export async function ingestSource(source, cfg, opts = {}) {
+    const home = opts.home ?? homedir();
+    const since = opts.since ? new Date(opts.since) : undefined;
+    if (since && Number.isNaN(since.getTime())) {
+        throw new Error('Invalid --since date.');
+    }
+    let entries = await source.enumerate({ home, since });
+    if (typeof opts.limit === 'number')
+        entries = entries.slice(0, opts.limit);
+    if (entries.length === 0) {
+        process.stdout.write(`No ${source.platform} transcripts found.\n`);
+        return { platform: source.platform, ingested: 0, skipped: 0 };
+    }
+    const manifest = await readManifest();
+    const client = new CliApiClient({
+        baseUrl: cfg.api_url,
+        apiKey: cfg.api_key,
+        agentPlatform: cfg.agent_platform ?? 'cli',
+        agentRole: cfg.agent_role,
+    });
+    let workspaceId = opts.workspace ?? cfg.default_workspace;
+    if (!workspaceId && !opts.dryRun) {
+        const list = await client.listWorkspaces();
+        if (list.length === 1)
+            workspaceId = list[0].id;
+        else if (list.length === 0)
+            throw new Error('No workspaces. Create one first.');
+        else
+            throw new Error('Multiple workspaces — specify --workspace <id>.');
+    }
+    const encrypt = !!cfg.preferences?.private_workspace;
+    process.stdout.write(`${kleur.bold(`Found ${entries.length} ${source.platform} transcripts.`)}\n`);
+    let ingested = 0;
+    let skipped = 0;
+    for (const entry of entries) {
+        if (!opts.reingest && manifest.ingested[entry.manifestKey]) {
+            skipped++;
+            continue;
+        }
+        const doc = await source.parseSession(entry);
+        if (!doc) {
+            skipped++;
+            continue;
+        }
+        const md = buildMarkdown(source.platform, doc);
+        const { redacted, hits } = redact(md);
+        const tag = summarizeHits(hits);
+        const remotePath = `transcripts/${source.platform}/${entry.sessionId}.md`;
+        if (opts.dryRun) {
+            process.stdout.write(`${kleur.dim('[dry]')} ${remotePath} ${kleur.dim(`(${doc.turns.length} turns, redactor: ${tag})`)}\n`);
+            ingested++;
+            continue;
+        }
+        try {
+            const body = encrypt ? await encryptContentAsync(cfg.api_key, redacted) : redacted;
+            await client.writeFile(workspaceId, remotePath, body, `transcript ingest (${tag})`);
+            manifest.ingested[entry.manifestKey] = new Date().toISOString();
+            ingested++;
+            process.stdout.write(`${kleur.green('[ok]')}  ${remotePath}` +
+                (encrypt ? kleur.cyan(' (encrypted)') : '') +
+                (hits.length ? kleur.yellow(` (redacted: ${tag})`) : '') +
+                '\n');
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const base = entry.path.split('/').pop() ?? entry.path;
+            process.stderr.write(`${kleur.red('[err]')} ${base}: ${msg}\n`);
+        }
+    }
+    if (!opts.dryRun)
+        await writeManifest(manifest);
+    process.stdout.write(`\nIngested ${ingested}, skipped ${skipped}.\n`);
+    return { platform: source.platform, ingested, skipped };
+}
+export { buildMarkdown, formatTranscript };

package/dist/lib/transcripts/types.js

@@ -0,0 +1,10 @@
+// Functional TranscriptSource interface — per eng-review decision E4.
+//
+// A source knows two things:
+// 1. `enumerate(home, opts)` — find candidate session files on disk
+// 2. `parseSession(entry)` — turn one session file into a TranscriptDoc
+//
+// Everything else (redact, encrypt, manifest, upload) is centralized in
+// lib/transcripts/ingest.ts so each source stays small and the cross-cutting
+// concerns can't drift between platforms.
+export {};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@adrive/cli",
-  "version": "0.3.0",
-  "description": "AgentDrive CLI — the persistent workspace your agents share across Claude Code, Codex, Cursor, and LangGraph.",
+  "version": "1.0.0",
+  "description": "AgentDrive CLI — cross-agent artifact workspace with provenance and portable storage across Claude Code, Codex, Cursor, and LangGraph.",
   "license": "Apache-2.0",
   "type": "module",
   "bin": {