@oqura/wisdom 0.0.0-stage → 0.3.1-beta.0

package/dist/src/doctor.js

@@ -0,0 +1,145 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { call } from './client.js';
+import { CAPTURE_API } from './daemon.js';
+import { harnessHome, movedFrom, spoolDir } from './paths.js';
+import { hookCommand, hookState, resolveCommand, skillState } from './harnesses/launch.js';
+import { hookEvents, inspectHooks, requireTrustedHooks } from './harnesses/codex/launch.js';
+import { piCommand } from './harnesses/pi/launch.js';
+/** The newest harness versions real sessions were recorded with. A newer one may well work;
+ * doctor only says so, because native formats can change between versions.
+ */
+const testedWith = { 'claude-code': '2.1.317', codex: '0.164.0', pi: '1.2.0' };
+export function wisdomVersion() {
+    return JSON.parse(fs.readFileSync(new URL('../../package.json', import.meta.url), 'utf8')).version;
+}
+/** The version a harness reports, or undefined when it cannot be found or run. */
+function versionOf(program) {
+    try {
+        const { command, args } = program();
+        const text = execFileSync(command, [...args, '--version'], { encoding: 'utf8', windowsHide: true, timeout: 10000, stdio: ['ignore', 'pipe', 'ignore'] });
+        return /\d+\.\d+\.\d+/.exec(text)?.[0] ?? 'unknown';
+    }
+    catch {
+        return undefined;
+    }
+}
+/** What is working and what is not, for one project. It changes nothing: it never starts the
+ * daemon or writes hooks, so what it reports is the state you were in when you ran it.
+ */
+export async function diagnose(dataDir, bins = {}) {
+    const project = path.dirname(path.resolve(dataDir));
+    const checks = [await daemonCheck(dataDir)];
+    checks.push(dashboardCheck(dataDir, checks[0]));
+    const version = (key, found) => found === testedWith[key] || found === 'unknown'
+        ? `version ${found}` : `version ${found}, last tested with ${testedWith[key]}`;
+    // A connected harness is reported as connected; otherwise as set up for wisdom track.
+    const placeOf = (key) => hookState(dataDir, key, 'project') === 'none' ? 'home' : 'project';
+    const harness = (name, key, found) => {
+        const place = placeOf(key);
+        const fix = place === 'project' ? 'wisdom connect' : 'wisdom init';
+        const where = place === 'project' ? ' in the project\'s settings (your own login)' : '';
+        const state = hookState(dataDir, key, place);
+        if (state === 'stale')
+            return { level: 'problem', name, detail: 'its hooks point to a copy of Wisdom that has moved or gone, so live recording has stopped', fix };
+        if (state === 'other')
+            return { level: 'problem', name, detail: 'its hooks run a different copy of Wisdom, such as one left under an earlier Node version', fix };
+        if (state === 'none')
+            return found
+                ? { level: 'note', name, detail: `installed (${version(key, found)}), but not set up in this project`, fix: 'wisdom connect' }
+                : { level: 'note', name, detail: 'not installed' };
+        if (!found)
+            return { level: 'note', name, detail: 'hooks are set up, but the harness itself was not found' };
+        const differs = found !== testedWith[key] && found !== 'unknown';
+        const skill = skillState(dataDir, key, place);
+        if (skill !== 'current')
+            return { level: 'note', name, detail: `hooks in place${where}, ${version(key, found)}. Its reading skill is ${skill}, so its agents may not know how to read recordings.`, fix };
+        return { level: differs ? 'note' : 'ok', name, detail: `hooks in place${where}, skill installed, ${version(key, found)}` };
+    };
+    checks.push(harness('Claude Code', 'claude-code', versionOf(() => resolveCommand(bins.claude ?? 'claude'))));
+    const codexBin = bins.codex ?? 'codex';
+    const codex = harness('Codex', 'codex', versionOf(() => resolveCommand(codexBin)));
+    checks.push(codex.detail.startsWith('hooks in place') ? await codexTrust(codex, codexBin, dataDir, project, placeOf('codex')) : codex);
+    checks.push(harness('Pi', 'pi', (bins.pi ?? (() => versionOf(piCommand)))()));
+    const waiting = countFiles(spoolDir(dataDir));
+    checks.push(waiting
+        ? { level: 'note', name: 'Spool', detail: `${waiting} event${waiting === 1 ? '' : 's'} waiting, recorded when the daemon next starts`, fix: 'wisdom daemon start' }
+        : { level: 'ok', name: 'Spool', detail: 'no events waiting' });
+    const moved = movedFrom(dataDir);
+    if (moved)
+        checks.push({ level: 'note', name: 'Project', detail: `moved from ${moved}. Recorded sessions follow it when the daemon next starts.` });
+    return checks;
+}
+async function daemonCheck(dataDir) {
+    const name = 'Daemon';
+    const file = path.join(dataDir, 'daemon.json');
+    const stopped = { level: 'note', name, detail: 'not running. It starts with the next hook or wisdom command.', fix: 'wisdom daemon start' };
+    let connection;
+    try {
+        connection = JSON.parse(fs.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return stopped;
+    }
+    let health;
+    try {
+        health = await call(connection, '/health', undefined, 3000);
+    }
+    catch {
+        return stopped;
+    }
+    if (health.captureApi !== CAPTURE_API)
+        return { level: 'problem', name, detail: `running from a different version of Wisdom (PID ${connection.pid})`, fix: 'wisdom daemon stop, then wisdom daemon start', health };
+    return { level: 'ok', name, detail: `running at ${connection.url} (PID ${connection.pid}), ${health.captures} session${health.captures === 1 ? '' : 's'}`, health };
+}
+function dashboardCheck(dataDir, daemon) {
+    const name = 'Dashboard';
+    const viewer = daemon.health?.dashboard;
+    if (!viewer)
+        return { level: 'note', name, detail: 'starts with the daemon' };
+    if (viewer.url && viewer.status !== 'exited')
+        return { level: 'ok', name, detail: viewer.url };
+    if (viewer.url)
+        return { level: 'problem', name, detail: `stopped unexpectedly. Read ${path.join(dataDir, 'dashboard.log')}` };
+    return { level: 'note', name, detail: viewer.reason };
+}
+/** Codex runs a hook only after it is trusted, so being set up is not the same as working.
+ * Reads Codex's hook list without starting a thread or calling a model.
+ */
+async function codexTrust(check, command, dataDir, project, place) {
+    // Connected, the project's hooks are reviewed in the person's own Codex, which also asks to trust the project.
+    const fix = place === 'project' ? 'codex, here: trust this project, then review Wisdom\'s hooks in /hooks' : 'wisdom track codex --setup-hooks';
+    try {
+        const env = place === 'project' ? process.env : { ...process.env, CODEX_HOME: harnessHome(dataDir, 'codex') };
+        requireTrustedHooks(await inspectHooks(resolveCommand(command), [], project, env), hookCommand('codex', dataDir, place === 'project'), false, place);
+        return check;
+    }
+    catch (error) {
+        const untrusted = error instanceof Error && error.message.includes('untrusted');
+        return { level: 'note', name: check.name, detail: untrusted
+                ? `hooks are not trusted yet (${hookEvents.length} to review), so sessions are read from their files only`
+                : 'could not check hook trust', fix: untrusted ? fix : undefined };
+    }
+}
+function countFiles(folder) {
+    try {
+        return fs.readdirSync(folder, { recursive: true, withFileTypes: true }).filter(item => item.isFile() && item.name.endsWith('.json')).length;
+    }
+    catch {
+        return 0;
+    }
+}
+/** Plain text, one line per check, with the command that fixes it underneath. */
+export function formatChecks(project, checks) {
+    const lines = [`Wisdom ${wisdomVersion()} · Node ${process.versions.node}`, `Project ${project}`, ''];
+    for (const check of checks) {
+        lines.push(`${check.level.padEnd(8)} ${check.name.padEnd(12)} ${check.detail}`);
+        if (check.fix)
+            lines.push(`${' '.repeat(22)}fix: ${check.fix}`);
+    }
+    const problems = checks.filter(check => check.level === 'problem').length;
+    lines.push('', problems ? `${problems} problem${problems === 1 ? '' : 's'} found.` : 'No problems found.');
+    return lines.join('\n');
+}
+//# sourceMappingURL=doctor.js.map

package/dist/src/evidence.js

@@ -0,0 +1,37 @@
+import { isSurfaceRecord, surfaceText } from './content.js';
+import { nativeMessage } from './harnesses/index.js';
+/** Cache source bytes only for the lifetime of one read. Several references can
+ * point to the same native message without causing repeated file reads.
+ */
+export class EvidenceReader {
+    captures;
+    bodies = new Map();
+    constructor(captures) {
+        this.captures = captures;
+    }
+    read(record, section) {
+        const key = `${record.captureId}:${section === 'patch' ? record.patchRef
+            : record.dataRef ?? `${record.sourceOffset}:${record.sourceLength}`}:${section === 'patch' ? 'patch' : 'data'}`;
+        if (!this.bodies.has(key)) {
+            const ledger = this.captures.get(record.captureId);
+            this.bodies.set(key, section === 'patch' ? record.patchRef ? ledger.readPayload(record.patchRef) : undefined
+                : record.dataRef ? ledger.readPayload(record.dataRef)
+                    : record.sourceOffset !== undefined ? ledger.readSource(record) : undefined);
+        }
+        const raw = this.bodies.get(key);
+        if (raw === undefined || section !== 'content' || !isSurfaceRecord(record))
+            return raw;
+        // Native lines are read through their harness adapter; hook bodies are already neutral.
+        return surfaceText(record.type === 'source_record'
+            ? nativeMessage(this.captures.get(record.captureId).manifest.harness, raw, record.toolCallId) : JSON.parse(raw));
+    }
+}
+/** Every read is pinned to one committed revision, so its answer cannot move while a session records. */
+export function evidenceVersion(captures, requested) {
+    const version = requested ?? captures.database.revision;
+    if (!Number.isSafeInteger(version) || version < 0 || version > captures.database.revision) {
+        throw new Error(`Version ${requested} is not available: the ledger is at version ${captures.database.revision}.`);
+    }
+    return version;
+}
+//# sourceMappingURL=evidence.js.map

package/dist/src/handoff.js

@@ -0,0 +1,60 @@
+import { randomUUID } from 'node:crypto';
+import { call } from './client.js';
+import { adapter } from './harnesses/index.js';
+/** `wisdom track` names harnesses by their command; the ledger by their adapter. */
+export const harnessByCommand = { claude: 'claude-code', codex: 'codex', pi: 'pi' };
+/** A target this long already fills much of a context window before it reads anything. */
+const LONG_SESSION_TOKENS = 150_000;
+/** The session to read when none is named: the most recently active one of this project's
+ * own that is not the target, and from another harness when a new session starts. A shared
+ * session is read only when named.
+ */
+export function chooseSource(sessions, target) {
+    return [...sessions].sort((a, b) => b.lastObservedAt.localeCompare(a.lastObservedAt))
+        .find(session => !session.shared && session.captureId !== target.captureId && (target.captureId || session.harness !== target.harness));
+}
+/** The first prompt. It names the full session ID, so the agent never mistakes itself for `latest`. */
+export function handoffPrompt(from, resumed, words = '') {
+    const read = `run \`wisdom glance ${from.captureId}\`, then \`wisdom open <turn> --capture ${from.captureId}\` for the turns you need.`;
+    const prompt = resumed
+        ? `While you were away, Wisdom session ${from.captureId} (${from.harness}) continued this work. Before going on, read it: ${read}`
+        : `Continue the work from Wisdom session ${from.captureId} (${from.harness}). Before changing anything, read it: ${read}`;
+    return words.trim() ? `${prompt}\n\n${words.trim()}` : prompt;
+}
+async function projectSessions(connection) {
+    const { projects } = await call(connection, '/view', { view: 'projects' });
+    const views = await Promise.all(projects.map((project) => call(connection, '/view', { view: 'project', workspaceRoot: project.workspaceRoot })));
+    const shared = await call(connection, '/view', { view: 'shared' });
+    return [...views.flatMap(view => view.sessions), ...shared.sessions];
+}
+/** Work out what to start. `target` is a harness command (a new session) or a full
+ * session ID (an existing session, resumed). Nothing is started here.
+ */
+export async function planHandoff(connection, target, from, words) {
+    const sessions = await projectSessions(connection);
+    const harness = harnessByCommand[target];
+    const existing = harness ? undefined : sessions.find(session => session.captureId === target);
+    if (!harness && !existing) {
+        throw new Error(`${target} is neither a harness (claude, codex, pi) nor a recorded session's full ID. glance lists sessions.`);
+    }
+    if (existing?.shared)
+        throw new Error(`A shared session is read-only, so it cannot be resumed. Start a new one that reads it: wisdom handoff claude|codex|pi --from ${existing.captureId}`);
+    // This project's own sessions are listed before shared copies, so its own recording wins.
+    const source = from ? sessions.find(session => session.captureId === from) : chooseSource(sessions, existing ?? { harness });
+    if (!source)
+        throw new Error(from ? `No recorded session has the ID ${from}. Use the full session ID; glance lists them.`
+            : 'There is no other recorded session to hand off from.');
+    if (source.captureId === existing?.captureId)
+        throw new Error('A session cannot continue itself.');
+    const prompt = handoffPrompt(source, Boolean(existing), words);
+    const env = { WISDOM_HANDOFF: JSON.stringify({ id: randomUUID(), from: source.captureId }) };
+    if (!existing)
+        return { command: target, args: [prompt], env, prompt, from: source };
+    const { workspaceRoot, source: targetSource } = await call(connection, '/resolve', { session: existing.captureId });
+    const [command, ...args] = adapter(existing.harness).resume(existing.captureId);
+    const note = existing.tokens.total > LONG_SESSION_TOKENS
+        ? `${existing.captureId} is long (${existing.tokens.total.toLocaleString('en-US')} tokens). A new session starts lighter: wisdom handoff ${command} --from ${source.captureId}`
+        : undefined;
+    return { command, args: [...args, prompt], cwd: workspaceRoot, env, prompt, from: source, target: existing, targetSource, note };
+}
+//# sourceMappingURL=handoff.js.map

package/dist/src/harnesses/claude-code/adapter.js

@@ -0,0 +1,79 @@
+import path from 'node:path';
+import { contentText, count, jsonlFiles } from '../types.js';
+// Claude Code calls this format internal, so this reader is best-effort; hooks
+// remain the primary evidence. Verified against Claude Code 2.1.306.
+const direct = new Set(['Read', 'Edit', 'MultiEdit', 'Write', 'NotebookEdit', 'Glob', 'Grep', 'WebFetch', 'WebSearch', 'TodoWrite', 'ToolSearch']);
+function messages(entry) {
+    const message = entry?.message;
+    if (!message || (entry.type !== 'user' && entry.type !== 'assistant'))
+        return [];
+    if (!Array.isArray(message.content))
+        return [{ role: message.role ?? entry.type, content: message.content ?? null }];
+    if (entry.type === 'assistant') {
+        return [{ role: 'assistant', content: message.content.map((block) => block?.type === 'tool_use'
+                    ? { type: 'toolCall', id: block.id, name: block.name, arguments: block.input }
+                    // Claude Code keeps a signature and duration but may omit the text (thinkingDisplay).
+                    : block?.type === 'thinking' ? { type: 'thinking', thinking: block.thinking ?? '', redacted: !block.thinking || undefined,
+                        durationMs: typeof entry.thinkingDurationMs === 'number' ? entry.thinkingDurationMs : undefined }
+                        : block?.type === 'redacted_thinking' ? { type: 'thinking', thinking: '', redacted: true }
+                            : block) }];
+    }
+    // A user entry carries tool results, possibly several, beside any typed text.
+    const results = message.content.filter((block) => block?.type === 'tool_result');
+    const rest = message.content.filter((block) => block?.type !== 'tool_result');
+    return [...results.map((block) => ({ role: 'toolResult', toolCallId: block.tool_use_id,
+            content: block.content ?? null, isError: block.is_error === true })),
+        ...(rest.length ? [{ role: 'user', content: rest }] : [])];
+}
+/** One API response is written as several entries (one per content block), each
+ * repeating the same usage, so the key is the response's message.id. input_tokens
+ * excludes cache tokens. cost-state is Claude Code's own running session cost.
+ */
+function usage(entry) {
+    const raw = entry?.message?.usage;
+    if (entry?.type === 'assistant' && raw && typeof entry.message.id === 'string') {
+        return [{ key: entry.message.id, scope: 'call', model: entry.message.model, provider: 'anthropic',
+                input: count(raw.input_tokens), cacheRead: count(raw.cache_read_input_tokens), cacheWrite: count(raw.cache_creation_input_tokens),
+                output: count(raw.output_tokens), reasoning: count(raw.output_tokens_details?.thinking_tokens) }];
+    }
+    if (entry?.type === 'cost-state' && typeof entry.totalCostUSD === 'number') {
+        return [{ key: 'cost-state', scope: 'session-total', input: 0, cacheRead: 0, cacheWrite: 0, output: 0, costUsd: entry.totalCostUSD }];
+    }
+    return [];
+}
+export const claudeCode = {
+    name: 'claude-code',
+    homeEnv: 'CLAUDE_CONFIG_DIR',
+    defaultHome: ['.claude'],
+    resume: sessionId => ['claude', '--resume', sessionId],
+    toolTarget: (_toolName, input) => typeof input?.file_path === 'string' ? input.file_path
+        : typeof input?.notebook_path === 'string' ? input.notebook_path : undefined,
+    isDirectFileTool: toolName => direct.has(toolName),
+    toolView: toolName => ['Write', 'Edit', 'MultiEdit', 'NotebookEdit'].includes(toolName) ? 'patch' : toolName === 'Read' ? 'file' : 'full',
+    nativeSession: entry => typeof entry?.sessionId === 'string' ? entry.sessionId : undefined,
+    nativeCwd: entry => typeof entry?.cwd === 'string' ? entry.cwd : undefined,
+    // Every line names its session and folder.
+    cloneLine: (entry, { sessionId, move }) => !entry || typeof entry !== 'object' ? entry
+        : { ...entry, ...(typeof entry.sessionId === 'string' ? { sessionId } : {}), ...(typeof entry.cwd === 'string' ? { cwd: move(entry.cwd) } : {}) },
+    // projects/<the folder, every character not a letter or digit as ->/<session>.jsonl
+    sessionFile: (home, sessionId, cwd) => path.join(home, 'projects', cwd.replace(/[^a-zA-Z0-9]/g, '-'), `${sessionId}.jsonl`),
+    nativeVersion: entry => typeof entry?.version === 'string' ? entry.version : undefined,
+    nativeChanges: () => [],
+    isScriptStep: () => false,
+    nativeForkedFrom: entry => typeof entry?.forkedFrom?.sessionId === 'string' ? entry.forkedFrom.sessionId : undefined,
+    // A finished background command wakes the agent with this, through the prompt hook.
+    isNotice: text => /^\s*<task-notification>/.test(text),
+    // What starts a turn under hooks: not a tool result, a meta line, a compaction summary, a
+    // slash command's own lines, or a line written only to the transcript (a fork's first notice).
+    nativePrompt: entry => {
+        if (entry?.type !== 'user' || entry.isMeta || entry.isCompactSummary || entry.queueTranscriptOnly || entry.toolUseResult !== undefined)
+            return undefined;
+        const text = contentText(entry.message?.content)?.trim();
+        return text && !/^<(?:command-|local-command-)/.test(text) ? text : undefined;
+    },
+    // projects/<folder>/<session>.jsonl; subagent files sit one folder deeper.
+    sessionFiles: home => jsonlFiles(path.join(home, 'projects'), 1),
+    nativeEntry: entry => ({ id: entry?.uuid, parentId: entry?.parentUuid, timestamp: entry?.timestamp,
+        kind: String(entry?.type ?? 'unknown'), messages: messages(entry), usage: usage(entry) }),
+};
+//# sourceMappingURL=adapter.js.map

package/dist/src/harnesses/claude-code/hook.js

@@ -0,0 +1,63 @@
+import { randomUUID } from 'node:crypto';
+import { deliver, handoffFromEnv } from '../../client.js';
+import { hookDataDir, wisdomHomeData } from '../../paths.js';
+/** Map one Claude Code hook payload to a neutral observation. Verified against
+ * Claude Code 2.1.306 payloads; unknown events are ignored, not guessed.
+ */
+export function observation(event) {
+    const agent = typeof event.agent_id === 'string' ? { agentId: event.agent_id } : {};
+    const tool = { toolCallId: event.tool_use_id, toolName: event.tool_name, ...agent };
+    switch (event.hook_event_name) {
+        case 'SessionStart': return { type: 'session_started',
+            data: { sessionId: event.session_id, source: event.transcript_path, origin: event.source } };
+        case 'SessionEnd': return { type: 'session_ended', data: { sessionId: event.session_id, reason: event.reason } };
+        case 'UserPromptSubmit': return { type: 'input', data: { text: event.prompt, promptId: event.prompt_id } };
+        case 'PreToolUse': return { type: 'tool_started', ...tool, data: { input: event.tool_input } };
+        case 'PostToolUse': return { type: 'tool_finished', ...tool, isError: false,
+            ...(typeof event.tool_response?.agentId === 'string' ? { childAgentId: event.tool_response.agentId } : {}),
+            data: { response: event.tool_response, durationMs: event.duration_ms } };
+        case 'PostToolUseFailure': return { type: 'tool_finished', ...tool, isError: true,
+            data: { error: event.error, isInterrupt: event.is_interrupt, durationMs: event.duration_ms } };
+        case 'Stop': return { type: 'agent_settled', data: { lastAssistantMessage: event.last_assistant_message } };
+        case 'SubagentStart': return { type: 'subagent_started', ...agent, data: { agentType: event.agent_type } };
+        case 'SubagentStop': return { type: 'subagent_stopped', ...agent,
+            data: { agentType: event.agent_type, transcriptPath: event.agent_transcript_path, lastAssistantMessage: event.last_assistant_message } };
+        case 'PreCompact': return { type: 'session_compact', data: { trigger: event.trigger } };
+        default: return undefined;
+    }
+}
+/** Runs for every hook of every Claude Code process that uses Wisdom's home, however it
+ * was started. It never stops Claude Code: an event the daemon cannot take is kept in
+ * the spool, and exit code 1 shows the warning without blocking.
+ */
+export async function main(named = process.argv[2], place = process.argv[3]) {
+    let input = '';
+    for await (const chunk of process.stdin)
+        input += chunk;
+    // The project's copy of the hook stands aside in a tracked session: its home's copy records it.
+    if (place === 'project' && wisdomHomeData('claude-code', process.env.CLAUDE_CONFIG_DIR))
+        return;
+    const event = JSON.parse(input);
+    const mapped = observation(event);
+    if (!mapped)
+        return;
+    try {
+        const dataDir = hookDataDir('claude-code', process.env.CLAUDE_CONFIG_DIR, named);
+        // Every hook names its session, so /clear, /resume and forks reach the right record. A
+        // subagent's hooks name the parent session; its transcript is copied at SubagentStop.
+        if (typeof event.session_id !== 'string' || !event.session_id)
+            throw new Error('Claude Code hook has no session_id');
+        const identity = { sessionId: event.session_id, ...(typeof event.agent_id === 'string' ? {} : { source: event.transcript_path }) };
+        const { spooled } = await deliver(dataDir, { harness: 'claude-code', cwd: typeof event.cwd === 'string' ? event.cwd : process.cwd(), ...handoffFromEnv(),
+            observation: { observationId: randomUUID(), ...identity, ...mapped } });
+        if (spooled) {
+            process.stderr.write(`Wisdom kept this ${event.hook_event_name} to record when its daemon is back (${spooled}). File changes meanwhile are not observed.\n`);
+            process.exitCode = 1;
+        }
+    }
+    catch (error) {
+        process.stderr.write(`Wisdom could not record or keep this ${event.hook_event_name}: ${error instanceof Error ? error.message : error}.\n`);
+        process.exitCode = 1;
+    }
+}
+//# sourceMappingURL=hook.js.map

package/dist/src/harnesses/claude-code/launch.js

@@ -0,0 +1,58 @@
+import { execFileSync } from 'node:child_process';
+import { home, hookCommand, installSkill, readSettings, resolveCommand, saveOrRemoveSettings, saveSettings, settingsFile, withHooks, withoutHooks } from '../launch.js';
+export const hookEvents = ['SessionStart', 'SessionEnd', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse',
+    'PostToolUseFailure', 'Stop', 'SubagentStart', 'SubagentStop', 'PreCompact'];
+const toolEvents = new Set(['PreToolUse', 'PostToolUse', 'PostToolUseFailure']);
+/** Put Wisdom's hooks in one Claude Code settings file, keeping any other hooks there. */
+function writeHooks(dataDir, place) {
+    const file = settingsFile(dataDir, 'claude-code', place);
+    const settings = readSettings(file);
+    settings.hooks = withHooks(settings.hooks, hookEvents, hookCommand('claude-code', dataDir, place === 'project'), event => toolEvents.has(event) ? { matcher: '*' } : {});
+    saveSettings(file, settings);
+}
+/** Write Wisdom's hooks into the settings of Claude Code's home in Wisdom's folder.
+ * Every Claude Code process that uses this home (a fork's background process, a
+ * branch, a resume, a worktree) loads them; ~/.claude is never touched.
+ */
+export function installClaudeCode(dataDir) {
+    const folder = home(dataDir, 'claude-code');
+    writeHooks(dataDir, 'home');
+    installSkill(folder);
+    return folder;
+}
+/** Wisdom's hooks in the project's `.claude/settings.local.json`, which Claude Code loads when
+ * it starts in the project's folder, with the person's own home and login. Returns the file.
+ */
+export function connectClaudeCode(dataDir) {
+    writeHooks(dataDir, 'project');
+    return settingsFile(dataDir, 'claude-code', 'project');
+}
+/** Take Wisdom's hooks out of the project's settings, leaving everything else as it was. */
+export function disconnectClaudeCode(dataDir) {
+    const file = settingsFile(dataDir, 'claude-code', 'project');
+    const settings = readSettings(file);
+    const hooks = withoutHooks(settings.hooks);
+    if (hooks)
+        settings.hooks = hooks;
+    else
+        delete settings.hooks;
+    saveOrRemoveSettings(file, settings);
+}
+/** Claude Code with its home in Wisdom's folder (its files, sessions and login stay there), or,
+ * in a connected project, with the person's own home, where the project's settings record it.
+ */
+export function launchClaudeCode(options) {
+    const name = options.command ?? 'claude';
+    let program;
+    try {
+        program = resolveCommand(name);
+        execFileSync(program.command, [...program.args, '--version'], { encoding: 'utf8', windowsHide: true });
+    }
+    catch {
+        throw new Error(`Cannot run Claude Code (${name}). Install it or pass --claude-bin.`);
+    }
+    const mcp = { mcpServers: { wisdom: { command: process.execPath, args: [options.cliPath, 'mcp', '--data', options.dataDir] } } };
+    return { command: program.command, env: options.place === 'project' ? {} : { CLAUDE_CONFIG_DIR: installClaudeCode(options.dataDir) },
+        args: [...program.args, '--mcp-config', JSON.stringify(mcp), ...options.args] };
+}
+//# sourceMappingURL=launch.js.map

package/dist/src/harnesses/codex/adapter.js

@@ -0,0 +1,144 @@
+import path from 'node:path';
+import { contentText, count, jsonlFiles } from '../types.js';
+/** Codex's command envelope ("Exit code: 1\nWall time: ..."). Verified in 0.147.0 rollouts,
+ * where a failed command sent no PostToolUse; on 0.164.0 hooks still use it for apply_patch.
+ * Arbitrary tool-output prose is not interpreted.
+ */
+export function exitEnvelope(text) {
+    const match = typeof text === 'string'
+        ? /(?:^|\n)(?:Process exited with code |Exit code: )(-?\d+)\r?(?:\n|$)/.exec(text) : null;
+    return match ? Number(match[1]) !== 0 : undefined;
+}
+/** What actually ran, on 0.164.0: the model's `exec` script calls tools inside it, and each
+ * ends as an item whose ID is the hook's tool_use_id. An unknown status stays unknown.
+ */
+function itemFailed(item) {
+    if (typeof item.exit_code === 'number' && item.exit_code !== 0)
+        return true;
+    return item.status === 'failed' ? true : item.status === 'completed' ? false : undefined;
+}
+function itemMessages(item) {
+    if (!item?.id || !['CommandExecution', 'FileChange'].includes(item.type))
+        return [];
+    const command = item.type === 'CommandExecution';
+    const input = command ? { command: item.parsed_cmd?.[0]?.cmd ?? item.command } : { files: Object.keys(item.changes ?? {}) };
+    return [
+        // A session read from its file has no hook, so this is the only record of the call.
+        { role: 'assistant', content: [{ type: 'toolCall', id: item.id, name: command ? 'Bash' : 'apply_patch', arguments: input }] },
+        { role: 'toolResult', toolCallId: item.id, isError: itemFailed(item),
+            content: command ? item.aggregated_output ?? '' : [item.stdout, item.stderr].filter(Boolean).join('\n') },
+    ];
+}
+/** Rollouts are an internal format. Keep unknown records as raw evidence and
+ * normalize only recognized response items; other event_msg lines repeat their content.
+ */
+function messages(entry) {
+    const item = entry?.payload;
+    if (entry?.type === 'event_msg' && item?.type === 'item_completed')
+        return itemMessages(item.item);
+    if (entry?.type !== 'response_item' || !item)
+        return [];
+    if (item.type === 'message')
+        return [{ role: item.role, content: Array.isArray(item.content)
+                    ? item.content.map((block) => ['input_text', 'output_text'].includes(block?.type)
+                        ? { type: 'text', text: block.text } : block) : item.content }];
+    // Reasoning is encrypted by the provider; its summary is only present when reasoning
+    // summaries are enabled. Record that it happened without inventing text.
+    if (item.type === 'reasoning') {
+        const summary = Array.isArray(item.summary) ? item.summary.map((part) => part?.text).filter(Boolean).join('\n\n') : '';
+        return [{ role: 'assistant', content: [{ type: 'thinking', thinking: summary, redacted: !summary || undefined }] }];
+    }
+    if (item.type === 'function_call' || item.type === 'custom_tool_call') {
+        let input = item.arguments ?? item.input;
+        if (item.type === 'function_call' && typeof input === 'string') {
+            try {
+                input = JSON.parse(input);
+            }
+            catch { /* Preserve non-JSON arguments. */ }
+        }
+        return [{ role: 'assistant', content: [{ type: 'toolCall', id: item.call_id, name: item.name, arguments: input }] }];
+    }
+    if (item.type === 'function_call_output' || item.type === 'custom_tool_call_output') {
+        return [{ role: 'toolResult', toolCallId: item.call_id, content: item.output, isError: exitEnvelope(item.output) }];
+    }
+    return [];
+}
+/** One token_count event per model call. Codex's input_tokens includes the cached
+ * and cache-write parts, so fresh input is the remainder. The running total is
+ * strictly increasing, so it keys a call and drops repeated events. No cost is reported.
+ */
+function usage(entry) {
+    const info = entry?.type === 'event_msg' && entry.payload?.type === 'token_count' ? entry.payload.info : undefined;
+    const last = info?.last_token_usage;
+    if (!last || typeof info.total_token_usage?.total_tokens !== 'number')
+        return [];
+    const cacheRead = count(last.cached_input_tokens), cacheWrite = count(last.cache_write_input_tokens);
+    return [{ key: `total:${info.total_token_usage.total_tokens}`, scope: 'call', provider: 'openai',
+            input: Math.max(0, count(last.input_tokens) - cacheRead - cacheWrite), cacheRead, cacheWrite,
+            output: count(last.output_tokens), reasoning: count(last.reasoning_output_tokens) }];
+}
+export const codex = {
+    name: 'codex',
+    homeEnv: 'CODEX_HOME',
+    defaultHome: ['.codex'],
+    resume: sessionId => ['codex', 'resume', sessionId],
+    // apply_patch can change several files; shell and MCP calls can write anywhere.
+    toolTarget: () => undefined,
+    isDirectFileTool: () => false,
+    toolView: toolName => toolName === 'apply_patch' ? 'patch' : 'full',
+    // A subagent's rollout has its own session_meta with an object source ({subagent: …}).
+    nativeSession: entry => entry?.type === 'session_meta' && typeof entry.payload?.id === 'string'
+        && typeof entry.payload.source !== 'object' ? entry.payload.id : undefined,
+    nativeCwd: entry => entry?.type === 'session_meta' && typeof entry.payload?.cwd === 'string' ? entry.payload.cwd : undefined,
+    nativeChanges: entry => {
+        const item = entry?.type === 'event_msg' && entry.payload?.type === 'item_completed' ? entry.payload.item : undefined;
+        if (item?.type !== 'FileChange' || !item.changes || typeof item.changes !== 'object')
+            return [];
+        return Object.entries(item.changes).map(([file, change]) => ({ path: file, content: change?.content, diff: change?.unified_diff,
+            operation: change?.type === 'add' ? 'create' : change?.type === 'delete' ? 'delete' : 'modify' }));
+    },
+    isScriptStep: toolName => toolName === 'exec' || toolName === 'wait',
+    // A fork points to its parent and copies no lines, so no line of it needs tracing.
+    nativeForkedFrom: () => undefined,
+    isNotice: () => false,
+    nativeVersion: entry => entry?.type === 'session_meta' && typeof entry.payload?.cli_version === 'string' ? entry.payload.cli_version : undefined,
+    // Codex adds its own user-role messages (AGENTS.md, <environment_context>); they are not typed.
+    nativePrompt: entry => {
+        const item = entry?.payload;
+        if (entry?.type !== 'response_item' || item?.type !== 'message' || item.role !== 'user')
+            return undefined;
+        const text = contentText(item.content)?.trim();
+        return text && !/^(?:# AGENTS\.md instructions for |<[a-z_]+>)/.test(text) ? text : undefined;
+    },
+    // sessions/YYYY/MM/DD/rollout-….jsonl
+    sessionFiles: home => jsonlFiles(path.join(home, 'sessions'), 3),
+    // The session's own header names it and its folders; a turn's context names its folder.
+    cloneLine: (entry, { from, sessionId, move }) => {
+        const payload = entry?.payload;
+        if (entry?.type === 'session_meta' && payload?.id === from) {
+            return { ...entry, payload: { ...payload, id: sessionId, ...(payload.session_id === undefined ? {} : { session_id: sessionId }),
+                    ...(typeof payload.cwd === 'string' ? { cwd: move(payload.cwd) } : {}),
+                    ...(Array.isArray(payload.runtime_workspace_roots) ? { runtime_workspace_roots: payload.runtime_workspace_roots.map((root) => typeof root === 'string' ? move(root) : root) } : {}) } };
+        }
+        if (entry?.type === 'turn_context' && typeof payload?.cwd === 'string')
+            return { ...entry, payload: { ...payload, cwd: move(payload.cwd) } };
+        return entry;
+    },
+    // sessions/YYYY/MM/DD/rollout-YYYY-MM-DDTHH-MM-SS-<session>.jsonl, in local time as Codex names them.
+    sessionFile: (home, sessionId, _cwd, now) => {
+        const two = (n) => String(n).padStart(2, '0');
+        const [year, month, day] = [String(now.getFullYear()), two(now.getMonth() + 1), two(now.getDate())];
+        const time = `${two(now.getHours())}-${two(now.getMinutes())}-${two(now.getSeconds())}`;
+        return path.join(home, 'sessions', year, month, day, `rollout-${year}-${month}-${day}T${time}-${sessionId}.jsonl`);
+    },
+    nativeEntry: entry => ({
+        id: typeof entry?.payload?.id === 'string' && entry.payload.id ? entry.payload.id : undefined,
+        timestamp: entry?.timestamp,
+        turnId: typeof entry?.payload?.turn_id === 'string' ? entry.payload.turn_id : undefined,
+        kind: [entry?.type ?? 'unknown', entry?.payload?.type].filter(Boolean).join(':'),
+        messages: messages(entry),
+        usage: usage(entry),
+        model: entry?.type === 'turn_context' && typeof entry.payload?.model === 'string' ? entry.payload.model : undefined,
+    }),
+};
+//# sourceMappingURL=adapter.js.map