packlight-cli 0.0.0-stage → 0.1.1

package/dist/adapters/claude-code/logs.d.ts

@@ -0,0 +1,54 @@
+import type { BudgetObservation, SessionRecord, ToolListing } from '../../core/types.js';
+/** Top-level line types seen in Claude Code logs up to 2.1.293 (eng A2). Anything else is counted as an unknown shape. */
+export declare const KNOWN_LINE_TYPES: Set<string>;
+export interface Use {
+    ts: string | null;
+    project: string | null;
+}
+export interface HookFiring {
+    event: string;
+    command: string;
+    ts: string | null;
+    project: string | null;
+    durationMs: number | null;
+    /** Output Claude Code recorded on the success line (used when no separate context line follows). */
+    ownChars: number;
+    /** Characters from additional-context/system-message lines linked to this firing. */
+    linkedChars: number;
+    /** Linked text was shared with other hooks on the same tool call and could not be split. */
+    shared: boolean;
+}
+export interface LogScan {
+    sessions: SessionRecord[];
+    skillUses: Map<string, Use[]>;
+    agentUses: Map<string, Use[]>;
+    mcpUses: Map<string, Use[]>;
+    hookFirings: HookFiring[];
+    /** Initial skill listings, oldest first. */
+    listings: BudgetObservation[];
+    /** One per main session file that logged a tool list, oldest first. */
+    toolListings: ToolListing[];
+    unattributedHookChars: number;
+    linesTotal: number;
+    linesUnknownShape: number;
+    /** Unknown-shape lines that looked like usage evidence (tool calls, hooks, listings). */
+    linesUnknownRelevant: number;
+    linesUnreadable: number;
+    unknownByVersion: Record<string, number>;
+    versions: string[];
+}
+export interface LogOptions {
+    /** Maps a working directory to its project root, or null when it belongs to no known project. */
+    projectOf: (cwd: string) => string | null;
+    since?: string;
+}
+/** Every .jsonl under the projects folder; subagent transcripts belong to their parent session. */
+export declare function logFiles(projectsDir: string): {
+    file: string;
+    sessionId: string;
+    isSubagent: boolean;
+}[];
+export declare function scanLogs(projectsDir: string, opts: LogOptions): Promise<LogScan>;
+/** A server name in the form tool names use: "plugin:x:y" and "My Server" become "plugin_x_y" and "My_Server". */
+export declare const toolKey: (name: string) => string;
+export declare function compareVersions(a: string, b: string): number;

package/dist/adapters/claude-code/logs.js

@@ -0,0 +1,359 @@
+import { createReadStream, readdirSync } from 'node:fs';
+import { basename, join, relative, sep } from 'node:path';
+import { createInterface } from 'node:readline';
+/** Top-level line types seen in Claude Code logs up to 2.1.293 (eng A2). Anything else is counted as an unknown shape. */
+export const KNOWN_LINE_TYPES = new Set([
+    'agent-name', 'ai-title', 'artifact-autoreact-ledger', 'artifact-comment-monitor', 'assistant', 'atis-latch', 'attachment',
+    'bridge-session', 'cost-state', 'custom-title', 'dev-mods', 'failed', 'file-history-delta', 'file-history-snapshot',
+    'frame-link', 'last-prompt', 'launched', 'mode', 'pr-link', 'queue-operation', 'relocated', 'result', 'started',
+    'summary', 'system', 'user',
+]);
+const HOOK_ATTACHMENTS = new Set(['hook_success', 'hook_additional_context', 'hook_system_message']);
+/** Text length of an attachment's content, which is a string or a list of strings/text blocks. */
+function contentChars(c) {
+    if (typeof c === 'string')
+        return c.length;
+    if (Array.isArray(c))
+        return c.reduce((n, x) => n + (typeof x === 'string' ? x.length : typeof x?.text === 'string' ? x.text.length : 0), 0);
+    return 0;
+}
+function push(map, key, use) {
+    const list = map.get(key);
+    if (list)
+        list.push(use);
+    else
+        map.set(key, [use]);
+}
+function listingSplit(content, names) {
+    const byLength = [...names].sort((a, b) => b.length - a.length);
+    const withDescription = [];
+    const dropped = [];
+    const entries = [];
+    let current = null;
+    for (const line of content.split('\n')) {
+        if (!line.startsWith('- ')) {
+            // A description that runs over several lines: its size belongs to the entry above.
+            if (current)
+                current.chars += line.length + 1;
+            continue;
+        }
+        const body = line.slice(2);
+        const name = byLength.find(n => body === n || body.startsWith(`${n}:`) || body.startsWith(`${n} (`));
+        if (!name) {
+            current = null;
+            continue;
+        }
+        const rest = body.slice(name.length).replace(/^ \([^)]*\)/, '');
+        const described = rest.startsWith(': ');
+        (described ? withDescription : dropped).push(name);
+        current = { name, chars: line.length + 1, described };
+        entries.push(current);
+    }
+    return { withDescription, dropped, entries };
+}
+/** Every .jsonl under the projects folder; subagent transcripts belong to their parent session. */
+export function logFiles(projectsDir) {
+    const out = [];
+    const walk = (dir) => {
+        let entries;
+        try {
+            entries = readdirSync(dir, { withFileTypes: true });
+        }
+        catch {
+            return;
+        }
+        for (const e of entries) {
+            const p = join(dir, e.name);
+            if (e.isDirectory())
+                walk(p);
+            else if (e.name.endsWith('.jsonl')) {
+                const parts = relative(projectsDir, p).split(sep);
+                // <project>/<session>.jsonl, or <project>/<session>/subagents/<agent>.jsonl
+                const isSubagent = parts.length > 2;
+                out.push({ file: p, sessionId: isSubagent ? parts[1] : basename(e.name, '.jsonl'), isSubagent });
+            }
+        }
+    };
+    walk(projectsDir);
+    return out.sort((a, b) => a.file.localeCompare(b.file));
+}
+export async function scanLogs(projectsDir, opts) {
+    const scan = {
+        sessions: [], skillUses: new Map(), agentUses: new Map(), mcpUses: new Map(), hookFirings: [], listings: [], toolListings: [],
+        unattributedHookChars: 0, linesTotal: 0, linesUnknownShape: 0, linesUnknownRelevant: 0, linesUnreadable: 0,
+        unknownByVersion: {}, versions: [],
+    };
+    const versions = new Set();
+    const sessions = new Map();
+    for (const { file, sessionId, isSubagent } of logFiles(projectsDir)) {
+        let s = sessions.get(sessionId);
+        if (!s) {
+            s = { id: sessionId, file, projectRoot: null, start: null, end: null, lines: 0, unknownShapeLines: 0, unreadableLines: 0, versions: [], versionSet: new Set() };
+            sessions.set(sessionId, s);
+        }
+        if (!isSubagent)
+            s.file = file;
+        // Lines without a cwd inherit the last one seen in this file (eng A3).
+        let cwd = null;
+        let version = null;
+        // Hook success lines waiting for their context lines, keyed by tool call and hook name.
+        const pending = new Map();
+        // This session's tool list, built from its deltas (main session files only: subagents get their own lists).
+        let tools = null;
+        const toolLines = new Map();
+        const server = (key) => (tools.servers[key] ??= { tools: 0, chars: 0, instructionChars: 0 });
+        const rl = createInterface({ input: createReadStream(file, { encoding: 'utf8' }), crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line)
+                continue;
+            scan.linesTotal++;
+            s.lines++;
+            let e;
+            try {
+                e = JSON.parse(line);
+            }
+            catch {
+                scan.linesUnreadable++;
+                s.unreadableLines++;
+                continue;
+            }
+            if (!e || typeof e !== 'object') {
+                scan.linesUnreadable++;
+                s.unreadableLines++;
+                continue;
+            }
+            if (typeof e.cwd === 'string')
+                cwd = e.cwd;
+            if (typeof e.version === 'string') {
+                const v = e.version;
+                version = v;
+                versions.add(v);
+                s.versionSet.add(v);
+            }
+            const ts = typeof e.timestamp === 'string' ? e.timestamp : null;
+            if (ts && opts.since && ts < opts.since)
+                continue;
+            if (ts) {
+                if (!s.start || ts < s.start)
+                    s.start = ts;
+                if (!s.end || ts > s.end)
+                    s.end = ts;
+            }
+            const project = cwd ? opts.projectOf(cwd) : null;
+            if (project && !isSubagent && !s.projectRoot)
+                s.projectRoot = project;
+            const use = { ts, project };
+            // Session counts hold only unknown lines that looked like usage evidence; they drive "usage uncertain".
+            const unknown = (relevant) => {
+                scan.linesUnknownShape++;
+                if (relevant) {
+                    s.unknownShapeLines++;
+                    scan.linesUnknownRelevant++;
+                    const v = version ?? 'unknown';
+                    scan.unknownByVersion[v] = (scan.unknownByVersion[v] ?? 0) + 1;
+                }
+            };
+            const type = e.type;
+            if (typeof type !== 'string' || !KNOWN_LINE_TYPES.has(type)) {
+                unknown(/"tool_use"|"hook[A-Z_]|skill_listing/.test(line));
+                continue;
+            }
+            if (type === 'assistant') {
+                const content = e.message?.content;
+                if (!Array.isArray(content)) {
+                    if (line.includes('"tool_use"'))
+                        unknown(true);
+                    continue;
+                }
+                for (const b of content) {
+                    if (b?.type !== 'tool_use')
+                        continue;
+                    if (typeof b.name !== 'string') {
+                        unknown(true);
+                        continue;
+                    }
+                    const input = b.input ?? {};
+                    if (b.name === 'Skill') {
+                        if (typeof input.skill === 'string')
+                            push(scan.skillUses, input.skill.replace(/^\//, ''), use);
+                        else
+                            unknown(true);
+                    }
+                    else if (b.name === 'Agent' || b.name === 'Task') {
+                        push(scan.agentUses, typeof input.subagent_type === 'string' ? input.subagent_type : 'general-purpose', use);
+                    }
+                    else if (b.name.startsWith('mcp__')) {
+                        const server = b.name.split('__')[1];
+                        if (server)
+                            push(scan.mcpUses, server, use);
+                    }
+                }
+            }
+            else if (type === 'user') {
+                if (!line.includes('<command-name>'))
+                    continue;
+                const c = e.message?.content;
+                const text = typeof c === 'string' ? c : Array.isArray(c) ? c.map((x) => (typeof x?.text === 'string' ? x.text : '')).join('') : '';
+                const m = /<command-name>\/?([^<]+)<\/command-name>/.exec(text);
+                if (m?.[1])
+                    push(scan.skillUses, m[1].trim(), use);
+            }
+            else if (type === 'attachment') {
+                const a = e.attachment;
+                if (!a || typeof a !== 'object')
+                    continue;
+                const at = a.type;
+                if (typeof at === 'string' && at.startsWith('hook_') && !HOOK_ATTACHMENTS.has(at)) {
+                    unknown(true);
+                    continue;
+                }
+                if (at === 'hook_success') {
+                    if (typeof a.command !== 'string' || typeof a.hookEvent !== 'string') {
+                        unknown(true);
+                        continue;
+                    }
+                    const firing = {
+                        event: a.hookEvent, command: a.command, ts, project,
+                        durationMs: typeof a.durationMs === 'number' ? a.durationMs : null,
+                        ownChars: contentChars(a.content) || (typeof a.stdout === 'string' ? a.stdout.length : 0),
+                        linkedChars: 0, shared: false,
+                    };
+                    scan.hookFirings.push(firing);
+                    const key = `${a.toolUseID ?? ''}|${a.hookName ?? ''}`;
+                    const list = pending.get(key);
+                    if (list)
+                        list.push(firing);
+                    else
+                        pending.set(key, [firing]);
+                }
+                else if (at === 'hook_additional_context' || at === 'hook_system_message') {
+                    const chars = contentChars(a.content);
+                    const firings = pending.get(`${a.toolUseID ?? ''}|${a.hookName ?? ''}`);
+                    if (!firings?.length) {
+                        scan.unattributedHookChars += chars;
+                        continue;
+                    }
+                    // Only hooks that printed something can have produced the text.
+                    const producers = firings.filter(f => f.ownChars > 0);
+                    const targets = producers.length ? producers : firings;
+                    if (targets.length === 1)
+                        targets[0].linkedChars += chars;
+                    else
+                        for (const f of targets) {
+                            f.linkedChars += chars / targets.length;
+                            f.shared = true;
+                        }
+                }
+                else if ((at === 'deferred_tools_delta' || at === 'mcp_instructions_delta') && !isSubagent) {
+                    tools ??= { sessionId, timestamp: ts, version, projectRoot: project, servers: {}, builtIn: { tools: 0, chars: 0 } };
+                    const added = Array.isArray(a.addedNames) ? a.addedNames : [];
+                    const removed = Array.isArray(a.removedNames) ? a.removedNames : [];
+                    if (at === 'deferred_tools_delta') {
+                        const lines = Array.isArray(a.addedLines) ? a.addedLines : [];
+                        added.forEach((n, i) => {
+                            if (typeof n !== 'string')
+                                return;
+                            const text = typeof lines[i] === 'string' ? lines[i] : n;
+                            const key = n.startsWith('mcp__') ? n.split('__')[1] ?? null : null;
+                            const prev = toolLines.get(n);
+                            if (prev) {
+                                if (prev.key) {
+                                    server(prev.key).tools--;
+                                    server(prev.key).chars -= prev.chars;
+                                }
+                                else {
+                                    tools.builtIn.tools--;
+                                    tools.builtIn.chars -= prev.chars;
+                                }
+                            }
+                            toolLines.set(n, { key, chars: text.length + 1 });
+                            if (key) {
+                                const s = server(key);
+                                s.tools++;
+                                s.chars += text.length + 1;
+                                const short = n.split('__').slice(2).join('__');
+                                if (short && (s.sample ??= []).length < 4 && !s.sample.includes(short))
+                                    s.sample.push(short);
+                            }
+                            else {
+                                tools.builtIn.tools++;
+                                tools.builtIn.chars += text.length + 1;
+                            }
+                        });
+                        for (const n of removed) {
+                            const prev = typeof n === 'string' ? toolLines.get(n) : undefined;
+                            if (!prev)
+                                continue;
+                            toolLines.delete(n);
+                            if (prev.key) {
+                                server(prev.key).tools--;
+                                server(prev.key).chars -= prev.chars;
+                            }
+                            else {
+                                tools.builtIn.tools--;
+                                tools.builtIn.chars -= prev.chars;
+                            }
+                        }
+                    }
+                    else {
+                        const blocks = Array.isArray(a.addedBlocks) ? a.addedBlocks : [];
+                        added.forEach((n, i) => {
+                            if (typeof n !== 'string')
+                                return;
+                            const block = typeof blocks[i] === 'string' ? blocks[i] : '';
+                            const s = server(toolKey(n));
+                            s.instructionChars = block.length;
+                            // Connectors are named by id; their block's first line after the heading names the service.
+                            // Only a short name before a colon ("Claude Docs: living docs…") counts; a sentence is instructions, not a name.
+                            const name = /^[^\n]*\n([^:\n.]{1,32}):/.exec(block)?.[1]?.trim();
+                            const label = name && name.split(/\s+/).length <= 4 && !/^(use|prefer|always|never|when|do|call)\b/i.test(name) ? name : undefined;
+                            if (label)
+                                s.label = label;
+                        });
+                        for (const n of removed)
+                            if (typeof n === 'string' && tools.servers[toolKey(n)])
+                                tools.servers[toolKey(n)].instructionChars = 0;
+                    }
+                }
+                else if (at === 'skill_listing') {
+                    if (!Array.isArray(a.names) || typeof a.content !== 'string') {
+                        unknown(true);
+                        continue;
+                    }
+                    if (a.isInitial === false)
+                        continue;
+                    scan.listings.push({
+                        sessionId, timestamp: ts, version, projectRoot: project, skillCount: typeof a.skillCount === 'number' ? a.skillCount : a.names.length,
+                        listingChars: a.content.length, ...listingSplit(a.content, a.names),
+                    });
+                }
+            }
+        }
+        if (tools) {
+            for (const [k, v] of Object.entries(tools.servers))
+                if (v.tools <= 0 && v.instructionChars <= 0)
+                    delete tools.servers[k];
+            scan.toolListings.push(tools);
+        }
+    }
+    scan.toolListings.sort((a, b) => (a.timestamp ?? '').localeCompare(b.timestamp ?? ''));
+    for (const s of sessions.values()) {
+        const { versionSet, ...rest } = s;
+        scan.sessions.push({ ...rest, versions: [...versionSet].sort() });
+    }
+    scan.listings.sort((a, b) => (a.timestamp ?? '').localeCompare(b.timestamp ?? ''));
+    scan.versions = [...versions].sort(compareVersions);
+    return scan;
+}
+/** A server name in the form tool names use: "plugin:x:y" and "My Server" become "plugin_x_y" and "My_Server". */
+export const toolKey = (name) => name.replace(/[^A-Za-z0-9_-]/g, '_');
+export function compareVersions(a, b) {
+    const pa = a.split('.').map(Number);
+    const pb = b.split('.').map(Number);
+    for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+        const d = (pa[i] ?? 0) - (pb[i] ?? 0);
+        if (d)
+            return d;
+    }
+    return 0;
+}

package/dist/adapters/codex/inventory.d.ts

@@ -0,0 +1,17 @@
+import type { Item } from '../../core/types.js';
+import { type TomlTable } from './toml.js';
+export interface CodexPaths {
+    home: string;
+    root: string;
+    config: string;
+    skills: string;
+    pluginCache: string;
+    prompts: string;
+    sessions: string;
+    agentsMd: string;
+}
+export declare function codexPaths(home: string): CodexPaths;
+export declare function readCodexConfig(paths: CodexPaths): TomlTable[];
+/** Project roots Codex knows: its [projects."<path>"] tables. */
+export declare function codexProjects(paths: CodexPaths): string[];
+export declare function collectCodexInventory(paths: CodexPaths, projectRoots: string[]): Item[];

package/dist/adapters/codex/inventory.js

@@ -0,0 +1,130 @@
+// What a Codex setup holds: skills (personal, built-in, from plugins), plugins, MCP servers, custom prompts and
+// AGENTS.md files. Read from ~/.codex (or $CODEX_HOME). Plugins and MCP servers are switched off in config.toml,
+// which packlight does not edit: their removal is "manual" with the exact line to change.
+import { existsSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { dirs, files, firstSeenOf, makeItem, readText } from '../claude-code/inventory.js';
+import { frontmatter } from '../../core/frontmatter.js';
+import { pathFingerprint, valueFingerprint } from '../../core/hash.js';
+import { readToml } from './toml.js';
+export function codexPaths(home) {
+    const root = process.env.CODEX_HOME && home === process.env.HOME ? process.env.CODEX_HOME : join(home, '.codex');
+    return {
+        home, root, config: join(root, 'config.toml'), skills: join(root, 'skills'), pluginCache: join(root, 'plugins', 'cache'),
+        prompts: join(root, 'prompts'), sessions: join(root, 'sessions'), agentsMd: join(root, 'AGENTS.md'),
+    };
+}
+const item = (i) => makeItem({ ...i, agent: 'codex' });
+const tilde = (p, home) => (p.startsWith(home) ? `~${p.slice(home.length)}` : p);
+/** A skill's line in Codex's skill listing: "- name: description (file: rN/…/SKILL.md)". */
+const listingChars = (name, description) => `- ${name}: ${description} (file: r0/${name}/SKILL.md)\n`.length;
+const newestDir = (p) => {
+    const ds = dirs(p).map(d => join(p, d));
+    ds.sort((a, b) => { try {
+        return statSync(b).mtimeMs - statSync(a).mtimeMs;
+    }
+    catch {
+        return 0;
+    } });
+    return ds[0] ?? null;
+};
+function skill(dir, name, opts) {
+    const file = join(dir, 'SKILL.md');
+    if (!existsSync(file))
+        return null;
+    const description = frontmatter(readText(file)).description ?? '';
+    return item({
+        kind: 'skill', name, source: opts.source, path: dir, enabled: opts.enabled, description,
+        standingChars: opts.enabled === false ? 0 : listingChars(name, description), fingerprint: pathFingerprint(dir),
+        ...(opts.firstSeen ?? firstSeenOf(dir)), logKeys: [name], plugin: opts.plugin, removal: opts.removal,
+    });
+}
+export function readCodexConfig(paths) {
+    return readToml(readText(paths.config));
+}
+/** Project roots Codex knows: its [projects."<path>"] tables. */
+export function codexProjects(paths) {
+    return readCodexConfig(paths).filter(t => t.path[0] === 'projects' && t.path.length === 2).map(t => t.path[1]);
+}
+export function collectCodexInventory(paths, projectRoots) {
+    const items = [];
+    const config = readCodexConfig(paths);
+    const cfgFile = tilde(paths.config, paths.home);
+    // Personal skills move into packlight's archive like Claude Code's; built-in ones ship with Codex.
+    for (const d of dirs(paths.skills)) {
+        if (d.startsWith('.'))
+            continue;
+        const s = skill(join(paths.skills, d), d, { source: 'personal', removal: { method: 'move' } });
+        if (s)
+            items.push(s);
+    }
+    for (const d of dirs(join(paths.skills, '.system'))) {
+        const s = skill(join(paths.skills, '.system', d), d, { source: 'built into Codex', removal: { method: 'manual', where: 'built into Codex', suite: true } });
+        if (s)
+            items.push(s);
+    }
+    // Plugins: every cached plugin, newest version; on unless config.toml says enabled = false.
+    const pluginCfg = new Map(config.filter(t => t.path[0] === 'plugins' && t.path.length === 2).map(t => [t.path[1], t]));
+    for (const market of dirs(paths.pluginCache)) {
+        for (const name of dirs(join(paths.pluginCache, market))) {
+            const key = `${name}@${market}`;
+            const version = newestDir(join(paths.pluginCache, market, name));
+            if (!version)
+                continue;
+            const cfg = pluginCfg.get(key);
+            const enabled = cfg?.values.enabled !== false;
+            const where = cfg ? `${cfgFile}, under [plugins."${key}"]: set enabled = false` : `Codex › Plugins (or add [plugins."${key}"] enabled = false to ${cfgFile})`;
+            const removal = { method: 'manual', where };
+            const seen = firstSeenOf(version);
+            const parts = [];
+            for (const s of dirs(join(version, 'skills'))) {
+                const it = skill(join(version, 'skills', s), `${name}:${s}`, { source: `plugin:${name}`, enabled, plugin: key, removal, firstSeen: seen });
+                if (it)
+                    parts.push(it);
+            }
+            const manifest = readText(join(version, '.codex-plugin', 'plugin.json'));
+            let description = '';
+            try {
+                description = String(JSON.parse(manifest).description ?? '');
+            }
+            catch { /* no manifest */ }
+            items.push(item({
+                kind: 'plugin', name, source: `marketplace:${market}`, path: version, enabled, description,
+                fingerprint: valueFingerprint({ key, version: basename(version), enabled }), ...seen, logKeys: [name], plugin: key,
+                members: parts.length ? { skill: parts.length } : {}, removal,
+                declarations: cfg ? [{ file: paths.config, scope: 'user', enabled }] : [],
+            }), ...parts);
+        }
+    }
+    // MCP servers: [mcp_servers.<name>]; enabled = false keeps them listed but off.
+    for (const t of config.filter(t => t.path[0] === 'mcp_servers' && t.path.length === 2)) {
+        const name = t.path[1];
+        const enabled = t.values.enabled !== false;
+        items.push(item({
+            kind: 'mcp', name, source: 'user config', path: paths.config, enabled,
+            description: typeof t.values.command === 'string' ? `${t.values.command}` : typeof t.values.url === 'string' ? `${t.values.url}` : '',
+            fingerprint: valueFingerprint(t.values), logKeys: [name.replace(/[^A-Za-z0-9_-]/g, '_')],
+            removal: { method: 'manual', where: `${cfgFile}, under [mcp_servers.${name}]: set enabled = false` },
+            declarations: [{ file: paths.config, scope: 'user', enabled }],
+        }));
+    }
+    // Custom prompts (slash commands) live as markdown files.
+    for (const f of files(paths.prompts, '.md')) {
+        const path = join(paths.prompts, f);
+        const name = f.replace(/\.md$/, '');
+        const description = frontmatter(readText(path)).description ?? '';
+        items.push(item({ kind: 'command', name, source: 'personal', path, description, fingerprint: pathFingerprint(path), ...firstSeenOf(path), logKeys: [name], removal: { method: 'move' } }));
+    }
+    // AGENTS.md: the global one and each known project's; loaded in full, edited by hand.
+    const agents = [[paths.agentsMd, null], ...projectRoots.map(r => [join(r, 'AGENTS.md'), r])];
+    for (const [path, root] of agents) {
+        const text = readText(path);
+        if (!text.trim())
+            continue;
+        items.push(item({
+            kind: 'instructions', name: root ? `${basename(root)}/AGENTS.md` : 'AGENTS.md', source: root ? 'project' : 'personal', path, projectRoot: root,
+            standingChars: text.length, fingerprint: pathFingerprint(path), ...firstSeenOf(path), removal: { method: 'manual', where: tilde(path, paths.home) },
+        }));
+    }
+    return items;
+}

package/dist/adapters/codex/logs.d.ts

@@ -0,0 +1,22 @@
+import type { CodexStart, SessionRecord } from '../../core/types.js';
+import type { Use } from '../claude-code/logs.js';
+export interface CodexLogScan {
+    sessions: SessionRecord[];
+    skillUses: Map<string, Use[]>;
+    mcpUses: Map<string, Use[]>;
+    /** One per session that logged a world_state, oldest first; firstRequestTokens holds that session's only. */
+    starts: CodexStart[];
+    linesTotal: number;
+    linesUnknownShape: number;
+    linesUnreadable: number;
+    unknownByVersion: Record<string, number>;
+    versions: string[];
+}
+/** Skills a tool call opened: Codex reads a skill by reading its SKILL.md. Plugin skills are "<plugin>:<skill>". */
+export declare function skillsIn(text: string): string[];
+/** MCP servers a tool call used: "mcp__<server>__<tool>" as the tool name, or called from Codex's code mode. */
+export declare function mcpServersIn(name: unknown, input: string): string[];
+export declare function scanCodexLogs(dir: string, opts: {
+    projectOf: (cwd: string) => string | null;
+    since?: string;
+}): Promise<CodexLogScan>;