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

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

@@ -0,0 +1,102 @@
+import { randomUUID } from 'node:crypto';
+import { deliver, handoffFromEnv } from '../../client.js';
+import { hookDataDir, wisdomHomeData } from '../../paths.js';
+import { exitEnvelope } from './adapter.js';
+/** Unknown tool outcomes stay unknown. A PostToolUse is not proof of success. */
+export function toolError(toolName, response) {
+    if (typeof response?.isError === 'boolean')
+        return response.isError;
+    if (typeof response?.is_error === 'boolean')
+        return response.is_error;
+    if (toolName !== 'Bash')
+        return undefined;
+    const code = response?.exit_code ?? response?.exitCode ?? response?.metadata?.exit_code;
+    if (typeof code === 'number')
+        return code !== 0;
+    return exitEnvelope(response);
+}
+// Codex kills a hook at its 40 s timeout, so delivery (10 s) plus starting the daemon
+// (up to 10 s) stays well inside that window.
+const daemonTimeoutMs = 10000;
+/** A spawned subagent's ID, from Codex spawn_agent's result. */
+function childAgentId(toolName, response) {
+    if (toolName !== 'spawn_agent')
+        return undefined;
+    let value = response;
+    if (typeof value === 'string') {
+        try {
+            value = JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return typeof value?.agent_id === 'string' ? value.agent_id : undefined;
+}
+export function observation(event) {
+    const identity = {
+        ...(typeof event.turn_id === 'string' ? { turnId: event.turn_id } : {}),
+        ...(typeof event.agent_id === 'string' ? { agentId: event.agent_id } : {}),
+    };
+    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: { reason: event.reason } };
+        case 'UserPromptSubmit': return { type: 'input', ...identity, data: { text: event.prompt } };
+        case 'PreToolUse': return { type: 'tool_started', ...identity, toolCallId: event.tool_use_id,
+            toolName: event.tool_name, data: { input: event.tool_input } };
+        case 'PostToolUse': return { type: 'tool_finished', ...identity, toolCallId: event.tool_use_id,
+            toolName: event.tool_name, isError: toolError(event.tool_name, event.tool_response),
+            childAgentId: childAgentId(event.tool_name, event.tool_response), data: { response: event.tool_response } };
+        case 'Stop': return { type: 'agent_settled', ...identity, data: { lastAssistantMessage: event.last_assistant_message } };
+        case 'SubagentStart': return { type: 'subagent_started', ...identity, data: { agentType: event.agent_type } };
+        case 'SubagentStop': return { type: 'subagent_stopped', ...identity,
+            data: { agentType: event.agent_type, transcriptPath: event.agent_transcript_path, lastAssistantMessage: event.last_assistant_message } };
+        case 'PreCompact':
+        case 'PostCompact': return { type: 'session_compact', ...identity,
+            data: { phase: event.hook_event_name, trigger: event.trigger } };
+        default: return undefined;
+    }
+}
+/** Runs for every hook of every Codex process that uses Wisdom's home. It never stops
+ * Codex: an event the daemon cannot take is kept in the spool. It always answers `{}`
+ * (Stop and SubagentStop require JSON); a warning goes to stderr with exit code 1.
+ */
+export async function main(named = process.argv[2], place = process.argv[3]) {
+    let event;
+    let input = '';
+    try {
+        for await (const chunk of process.stdin) {
+            input += chunk;
+            if (Buffer.byteLength(input) > 15 * 1024 * 1024)
+                throw new Error('Hook payload exceeds 15 MiB');
+        }
+        event = JSON.parse(input);
+        const mapped = observation(event);
+        // The project's copy of the hook stands aside in a tracked session: its home's copy records it.
+        if (mapped && !(place === 'project' && wisdomHomeData('codex', process.env.CODEX_HOME))) {
+            const dataDir = hookDataDir('codex', process.env.CODEX_HOME, named);
+            // A subagent's events name its own rollout file; that is not the session transcript
+            // switching. Its transcript is copied separately at SubagentStop.
+            const identity = { sessionId: event.session_id, ...(typeof event.agent_id === 'string' ? {} : { source: event.transcript_path }) };
+            if (typeof identity.sessionId !== 'string' || !identity.sessionId)
+                throw new Error('Codex hook has no session_id');
+            // One request: the neutral observation plus the exact received JSON object,
+            // kept as a separate record so it never enters clean conversation output.
+            const { spooled } = await deliver(dataDir, { harness: 'codex', cwd: typeof event.cwd === 'string' ? event.cwd : process.cwd(), ...handoffFromEnv(),
+                observation: { observationId: randomUUID(), ...identity, ...mapped, harnessEvent: event } }, daemonTimeoutMs);
+            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) {
+        const name = event?.hook_event_name ?? /"hook_event_name"\s*:\s*"(\w+)"/.exec(input)?.[1];
+        process.stderr.write(`Wisdom could not record or keep this ${name ?? 'hook'}: ${String(error instanceof Error ? error.message : error)}.\n`);
+        process.exitCode = 1;
+    }
+    process.stdout.write('{}');
+}
+//# sourceMappingURL=hook.js.map

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

@@ -0,0 +1,194 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execFileSync, spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { home, hookCommand, installSkill, readSettings, resolveCommand, saveOrRemoveSettings, saveSettings, settingsFile, withHooks, withoutHooks } from '../launch.js';
+import { userHome } from '../index.js';
+export const hookEvents = ['SessionStart', 'SessionEnd', 'UserPromptSubmit', 'PreToolUse', 'PostToolUse',
+    'Stop', 'SubagentStart', 'SubagentStop', 'PreCompact', 'PostCompact'];
+/** Put Wisdom's hooks in one Codex `hooks.json`, keeping any other hooks there. Returns the command. */
+function writeHooks(dataDir, place) {
+    const file = settingsFile(dataDir, 'codex', place);
+    const settings = readSettings(file);
+    const command = hookCommand('codex', dataDir, place === 'project');
+    settings.hooks = withHooks(settings.hooks, hookEvents, command, () => ({}), event => ({ timeout: event === 'SessionEnd' ? 3 : 40 }));
+    saveSettings(file, settings);
+    return command;
+}
+/** Write Wisdom's hooks to `hooks.json` in Codex's home in Wisdom's folder (verified on
+ * Codex CLI 0.164.0: listed as user hooks, enabled, untrusted until reviewed in /hooks).
+ * Every Codex process that uses this home loads them; ~/.codex is never touched.
+ */
+export function installCodex(dataDir) {
+    const folder = home(dataDir, 'codex');
+    const command = writeHooks(dataDir, 'home');
+    installSkill(folder);
+    return { home: folder, command };
+}
+/** Wisdom's hooks in the project's `.codex/hooks.json` (verified on Codex CLI 0.166.0: loaded
+ * only once the project is trusted, from its folder or any below it, and listed as project
+ * hooks, untrusted until reviewed in /hooks). Codex uses the person's own home and login.
+ */
+export function connectCodex(dataDir) {
+    writeHooks(dataDir, 'project');
+    return settingsFile(dataDir, 'codex', 'project');
+}
+/** Take Wisdom's hooks out of the project's `.codex/hooks.json`, leaving everything else. */
+export function disconnectCodex(dataDir) {
+    const file = settingsFile(dataDir, 'codex', 'project');
+    const settings = readSettings(file);
+    const hooks = withoutHooks(settings.hooks);
+    if (hooks)
+        settings.hooks = hooks;
+    else
+        delete settings.hooks;
+    saveOrRemoveSettings(file, settings);
+}
+/** Read hook metadata only. No thread is started and no model is called. */
+export async function inspectHooks(program, args, cwd, env = process.env) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(program.command, [...program.args, ...args, 'app-server'], { cwd, env, windowsHide: true, stdio: ['pipe', 'pipe', 'pipe'] });
+        let done = false;
+        const finish = (error, result) => {
+            if (done)
+                return;
+            done = true;
+            clearTimeout(timer);
+            lines.close();
+            child.stdin.end();
+            child.kill();
+            if (error)
+                reject(error);
+            else
+                resolve(result);
+        };
+        const timer = setTimeout(() => finish(new Error('Codex hook inspection timed out')), 15000);
+        const lines = createInterface({ input: child.stdout });
+        child.stderr.resume(); // Do not echo unrelated configuration or authentication diagnostics.
+        const send = (message) => child.stdin.write(JSON.stringify(message) + '\n');
+        child.on('error', error => finish(error));
+        child.stdin.on('error', error => finish(error));
+        child.on('exit', () => finish(new Error('Codex exited before reporting its recording hooks')));
+        lines.on('line', line => {
+            let message;
+            try {
+                message = JSON.parse(line);
+            }
+            catch {
+                return;
+            }
+            if (message.error) {
+                finish(new Error(`Codex hook inspection failed: ${message.error.message}`));
+                return;
+            }
+            if (message.id === 1) {
+                send({ method: 'initialized' });
+                send({ id: 2, method: 'hooks/list', params: { cwds: [cwd] } });
+            }
+            else if (message.id === 2)
+                finish(undefined, message.result);
+        });
+        send({ id: 1, method: 'initialize', params: { clientInfo: { name: 'wisdom', version: '0.3.0' } } });
+    });
+}
+/** Wisdom's hooks in Codex's home are `user` hooks; in a connected project, `project` hooks. */
+export function requireTrustedHooks(result, command, allowUntrusted = false, place = 'home') {
+    const entries = result?.data;
+    if (!Array.isArray(entries) || entries.length !== 1 || entries[0].errors?.length) {
+        throw new Error('Codex could not load Wisdom hooks. Check Codex configuration and managed hook policy.');
+    }
+    const missing = hookEvents.filter(event => !entries[0].hooks?.some((hook) => hook.command === command && hook.eventName === event[0].toLowerCase() + event.slice(1)
+        && hook.source === (place === 'project' ? 'project' : 'user') && hook.enabled && (allowUntrusted || hook.trustStatus === 'trusted')));
+    if (!missing.length)
+        return;
+    throw new Error(place === 'project'
+        ? 'Wisdom hooks in this project are missing, disabled, or untrusted. Start codex in the project, trust the project if it asks, '
+            + 'review Wisdom hooks in /hooks, then quit and retry. Required: ' + missing.join(', ')
+        : 'Wisdom hooks are missing, disabled, or untrusted. Run `wisdom track codex --setup-hooks` '
+            + 'with the same --cwd, review Wisdom hooks in /hooks, then quit and retry. Required: ' + missing.join(', '));
+}
+/** Inspect the same config/profile overrides used by the interactive process. */
+export function inspectionArgs(args) {
+    const result = [];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (/^(?:--cd|-C|--worktree|--remote)(?:=|$)/.test(arg) || /^-C.+/.test(arg)) {
+            throw new Error('Use Wisdom --cwd; changing the Codex workspace or attaching remotely is not supported.');
+        }
+        if (arg === '--dangerously-bypass-hook-trust')
+            throw new Error('Review Wisdom hooks with --setup-hooks, or pass Wisdom\'s --trust-all-hooks.');
+        if (['-c', '--config', '-p', '--profile', '--enable', '--disable'].includes(arg)) {
+            if (!args[i + 1])
+                throw new Error(`Missing Codex value for ${arg}`);
+            result.push(arg, args[++i]);
+        }
+        else if (/^(?:--config=|--profile=|--enable=|--disable=|-c.+|-p.+)/.test(arg))
+            result.push(arg);
+    }
+    for (const arg of result) {
+        const value = arg.replace(/^(?:--config=|-c)/, '').trim();
+        const key = value.split('=', 1)[0].replace(/["'\s]/g, '');
+        if (/^(?:hooks(?:\.|$)|features(?:\.hooks)?$|mcp_servers(?:\.wisdom(?:\.|$)|$))/.test(key)
+            || value === 'hooks' || value === '--disable=hooks') {
+            throw new Error('Codex arguments cannot override Wisdom hooks or its MCP server.');
+        }
+    }
+    return result;
+}
+/** node_repl (shipped with the Codex desktop app) can run shell commands and patches
+ * inside one MCP call, so hooks see only that outer call. Best-effort config check.
+ */
+export function nodeReplEnabled(configText, overrides) {
+    if (overrides.some(arg => /mcp_servers\.node_repl\.enabled\s*=\s*false/.test(arg)))
+        return false;
+    const section = /^\[mcp_servers\.node_repl\]\s*$([\s\S]*?)(?=^\[(?!mcp_servers\.node_repl[.\]])|(?![\s\S]))/m.exec(configText);
+    return !!section && !/^\s*enabled\s*=\s*false\b/m.test(section[1]);
+}
+export const trustAllWarning = 'WARNING: --trust-all-hooks runs every enabled Codex hook without review for this session, '
+    + "including your global hooks and this project's .codex hooks, not only Wisdom's. Use it only in repositories you trust.";
+/** Codex with its home in Wisdom's folder, or, in a connected project, with the person's own
+ * home, where the project's hooks record it. Either way its hooks must be trusted first.
+ */
+export async function launchCodex(options) {
+    const name = options.command ?? 'codex';
+    let program, version;
+    try {
+        program = resolveCommand(name);
+        version = execFileSync(program.command, [...program.args, '--version'], { encoding: 'utf8', windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] }).trim();
+    }
+    catch {
+        throw new Error(`Cannot run Codex (${name}). Install it or pass --codex-bin.`);
+    }
+    const { command } = program;
+    const match = /codex-cli (\d+)\.(\d+)\.(\d+)/.exec(version);
+    if (!match || Number(match[1]) === 0 && Number(match[2]) < 164)
+        throw new Error('Codex CLI 0.164.0 or newer is required.');
+    const own = options.place === 'project';
+    if (own && options.setupHooks)
+        throw new Error('--setup-hooks reviews hooks in Wisdom\'s Codex home; in a connected project, review them in /hooks in codex itself');
+    // Tracked, Codex keeps its sessions, login, hooks and hook trust in Wisdom's folder, not in
+    // ~/.codex. Connected, it keeps its own home; `wisdom connect` wrote the project's hooks.
+    const installed = own ? { home: userHome('codex'), command: hookCommand('codex', options.dataDir, true) } : installCodex(options.dataDir);
+    const env = own ? {} : { CODEX_HOME: installed.home };
+    const overrides = inspectionArgs(options.args);
+    if (options.setupHooks) {
+        if (options.args.length)
+            throw new Error('--setup-hooks does not accept Codex arguments');
+        if (options.trustAllHooks)
+            throw new Error('--setup-hooks and --trust-all-hooks are alternatives; choose one');
+        return { command, env, args: [...program.args, '-C', options.cwd], setupOnly: true };
+    }
+    requireTrustedHooks(await inspectHooks(program, overrides, options.cwd, { ...process.env, ...env }), installed.command, options.trustAllHooks, options.place);
+    if (options.trustAllHooks)
+        console.error(trustAllWarning);
+    const configFile = path.join(installed.home, 'config.toml');
+    if (nodeReplEnabled(fs.existsSync(configFile) ? fs.readFileSync(configFile, 'utf8') : '', overrides)) {
+        console.error('Note: the node_repl MCP server is enabled. Commands it runs inside one call are invisible to hooks; '
+            + 'Wisdom still records their file changes. Add -- -c mcp_servers.node_repl.enabled=false to see each command.');
+    }
+    const mcp = ['-c', `mcp_servers.wisdom.command=${JSON.stringify(process.execPath)}`, '-c',
+        `mcp_servers.wisdom.args=${JSON.stringify([options.cliPath, 'mcp', '--data', options.dataDir])}`];
+    return { command, env, args: [...program.args, '-C', options.cwd, ...mcp,
+            ...(options.trustAllHooks ? ['--dangerously-bypass-hook-trust'] : []), ...options.args] };
+}
+//# sourceMappingURL=launch.js.map

package/dist/src/harnesses/index.js

@@ -0,0 +1,53 @@
+import os from 'node:os';
+import path from 'node:path';
+import { harnessHome, wisdomHomeData } from '../paths.js';
+import { pi } from './pi/adapter.js';
+import { claudeCode } from './claude-code/adapter.js';
+import { codex } from './codex/adapter.js';
+export const harnesses = { pi, 'claude-code': claudeCode, codex };
+export const harnessNames = Object.keys(harnesses);
+export function adapter(name) {
+    const found = harnesses[name];
+    if (!found)
+        throw new Error(`Unknown harness: ${name}`);
+    return found;
+}
+/** The harness's home when a person runs it themselves: its variable, else its default
+ * folder. A Wisdom home in the variable is this process running inside a tracked session,
+ * not the person's own, so it is passed over.
+ */
+export function userHome(name) {
+    const { homeEnv, defaultHome } = adapter(name);
+    const set = process.env[homeEnv];
+    return set && !wisdomHomeData(name, set) ? path.resolve(set) : path.join(os.homedir(), ...defaultHome);
+}
+/** Where a session runs: in its harness's home in Wisdom's folder, or, when its transcript is
+ * kept anywhere else, in the person's own home, where a connected project records it.
+ */
+export function sessionPlace(dataDir, name, source) {
+    if (!source)
+        return 'home';
+    const relative = path.relative(harnessHome(dataDir, name), source);
+    return relative.startsWith('..') || path.isAbsolute(relative) ? 'project' : 'home';
+}
+/** The command a person types to continue a session directly: its folder, its home, its
+ * harness. Wisdom's home is what keeps a tracked session recording, so the command sets it;
+ * a connected session runs in the person's own home, so it is left alone.
+ */
+export function resumeCommands(dataDir, name, sessionId, cwd, source) {
+    const { homeEnv, resume } = adapter(name);
+    const folder = harnessHome(dataDir, name);
+    const command = resume(sessionId).join(' ');
+    const literal = (value, quote) => `'${value.replaceAll("'", quote)}'`;
+    const own = sessionPlace(dataDir, name, source) === 'project';
+    return {
+        powershell: `cd -LiteralPath ${literal(cwd, "''")}; ${own ? '' : `$env:${homeEnv} = ${literal(folder, "''")}; `}${command}`,
+        posix: `cd ${literal(cwd, "'\\''")} && ${own ? '' : `${homeEnv}=${literal(folder, "'\\''")} `}${command}`,
+    };
+}
+/** Normalize one native line at read time, so adapter fixes apply to old captures. */
+export function nativeMessage(name, raw, toolCallId) {
+    const { messages } = adapter(name).nativeEntry(JSON.parse(raw));
+    return (toolCallId ? messages.find(message => message.toolCallId === toolCallId) : undefined) ?? messages[0] ?? null;
+}
+//# sourceMappingURL=index.js.map

package/dist/src/harnesses/launch.js

@@ -0,0 +1,217 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { harnessHome } from '../paths.js';
+import { writeJson } from '../ledger.js';
+/** Find a harness the way the person's shell would. On Windows, Node starts only `.exe` and
+ * `.com` files by name, and refuses a `.cmd` without a shell (CVE-2024-27980), which would not
+ * escape arguments. npm, pnpm and yarn install a command as a `.cmd` shim, so the shim is
+ * followed to the program it starts: an `.exe` itself, a script with this Node. Elsewhere,
+ * and when nothing is found, the command is started as named.
+ */
+export function resolveCommand(name) {
+    if (process.platform !== 'win32')
+        return { command: name, args: [] };
+    const file = /[\\/]/.test(name) ? path.resolve(name) : onPath(name);
+    if (!file)
+        return { command: name, args: [] };
+    const extension = path.extname(file).toLowerCase();
+    if (['.cmd', '.bat'].includes(extension)) {
+        const target = shimTarget(file);
+        if (!target)
+            throw new Error(`${file} does not name the program it starts; pass that program's path instead.`);
+        return ['.exe', '.com'].includes(path.extname(target).toLowerCase()) ? { command: target, args: [] } : { command: process.execPath, args: [target] };
+    }
+    return ['.js', '.mjs', '.cjs'].includes(extension) ? { command: process.execPath, args: [file] } : { command: file, args: [] };
+}
+/** The first match on PATH, trying PATHEXT's runnable extensions in order, as cmd.exe does. */
+function onPath(name) {
+    const runnable = ['.com', '.exe', '.bat', '.cmd'];
+    const extensions = path.extname(name) ? [''] : (process.env.PATHEXT ?? runnable.join(';')).toLowerCase().split(';').filter(ext => runnable.includes(ext));
+    for (const dir of (process.env.PATH ?? '').split(path.delimiter)) {
+        if (!dir)
+            continue;
+        for (const extension of extensions) {
+            const file = path.join(dir.replace(/^"(.*)"$/, '$1'), name + extension);
+            if (isFile(file))
+                return file;
+        }
+    }
+    return undefined;
+}
+/** The program a shim starts: its last quoted path that is a file. cmd-shim (npm, yarn) writes
+ * it as `"%dp0%\…"`, pnpm as `"%~dp0\…"`, both relative to the shim; other shims in full.
+ */
+function shimTarget(file) {
+    const dir = path.dirname(file);
+    return [...fs.readFileSync(file, 'utf8').matchAll(/"([^"]+)"/g)]
+        .map(match => match[1].replace(/^%~?dp0%?[\\/]?/i, dir + path.sep))
+        .filter(value => !value.includes('%')).map(value => path.resolve(dir, value)).filter(isFile).at(-1);
+}
+const isFile = (file) => { try {
+    return fs.statSync(file).isFile();
+}
+catch {
+    return false;
+} };
+/** `node "<integrations/<harness>/hook.mjs>" "<data folder>"`: the hook needs nothing else.
+ * The copy `wisdom connect` puts in a project's settings ends with `project`, so it can stand
+ * aside in a tracked session, whose home holds the same hook.
+ */
+export function hookCommand(harness, dataDir, project = false) {
+    const file = fileURLToPath(new URL(`../../../integrations/${harness}/hook.mjs`, import.meta.url)).replaceAll('\\', '/');
+    const data = path.resolve(dataDir).replaceAll('\\', '/');
+    if (/["\r\n]/.test(file + data))
+        throw new Error('Wisdom and its data folder cannot have quotes or newlines in their paths');
+    return `node "${file}" "${data}"${project ? ' project' : ''}`;
+}
+/** Where a harness's settings name Wisdom: in its home in Wisdom's folder (`wisdom init`), and
+ * in the project (`wisdom connect`), where its own login is used. Skills go under `<skills>/skills`.
+ */
+export const settingsFiles = {
+    home: { 'claude-code': 'settings.json', codex: 'hooks.json', pi: 'settings.json' },
+    project: {
+        'claude-code': { settings: path.join('.claude', 'settings.local.json'), skills: '.claude' },
+        codex: { settings: path.join('.codex', 'hooks.json'), skills: '.agents' },
+        pi: { settings: path.join('.pi', 'settings.json'), skills: '.agents' },
+    },
+};
+/** The settings file that names Wisdom for a harness, in its home or in the project. */
+export function settingsFile(dataDir, harness, place) {
+    return place === 'home' ? path.join(harnessHome(dataDir, harness), settingsFiles.home[harness])
+        : path.join(path.dirname(path.resolve(dataDir)), settingsFiles.project[harness].settings);
+}
+/** A harness home, created on first use. */
+export function home(dataDir, harness) {
+    const folder = harnessHome(dataDir, harness);
+    fs.mkdirSync(folder, { recursive: true });
+    return folder;
+}
+const shippedSkill = fileURLToPath(new URL('../../../skills/wisdom-ledger/', import.meta.url));
+/** Copy the reading skill into a harness home, so any session there knows how to read
+ * recordings, however it was started. Wisdom owns this folder; each install replaces it.
+ */
+export function installSkill(folder) {
+    const target = path.join(folder, 'skills', 'wisdom-ledger');
+    fs.rmSync(target, { recursive: true, force: true });
+    fs.cpSync(shippedSkill, target, { recursive: true });
+}
+/** Take Wisdom's skill out of a folder's `skills`, leaving any other skill as it is. */
+export function removeSkill(folder) {
+    fs.rmSync(path.join(folder, 'skills', 'wisdom-ledger'), { recursive: true, force: true });
+    for (const empty of [path.join(folder, 'skills'), folder])
+        try {
+            fs.rmdirSync(empty);
+        }
+        catch { /* not empty, or gone */ }
+}
+/** Whether a harness's home, or the project, holds this copy of Wisdom's skill. */
+export function skillState(dataDir, harness, place = 'home') {
+    const read = (file) => { try {
+        return fs.readFileSync(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    } };
+    const folder = place === 'home' ? harnessHome(dataDir, harness) : path.join(path.dirname(path.resolve(dataDir)), settingsFiles.project[harness].skills);
+    const installed = read(path.join(folder, 'skills', 'wisdom-ledger', 'SKILL.md'));
+    if (installed === undefined)
+        return 'missing';
+    return installed === read(path.join(shippedSkill, 'SKILL.md')) ? 'current' : 'outdated';
+}
+/** Read a harness's JSON settings, or none. */
+export function readSettings(file) {
+    if (!fs.existsSync(file))
+        return {};
+    const value = JSON.parse(fs.readFileSync(file, 'utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new Error(`${file} is not a JSON object`);
+    return value;
+}
+/** Put Wisdom's hook under each event of a Claude-style `hooks` object, replacing an
+ * earlier Wisdom hook (a moved install) and keeping every other hook as it was.
+ */
+export function withHooks(hooks, events, command, entry, hook = () => ({})) {
+    const result = { ...hooks };
+    for (const event of events) {
+        result[event] = [...(result[event] ?? []).filter(item => !isWisdomHook(item)),
+            { ...entry(event), hooks: [{ type: 'command', command, ...hook(event) }] }];
+    }
+    return result;
+}
+/** A Claude-style `hooks` object without Wisdom's hooks: an event left with none is dropped,
+ * and so is the whole object when nothing else remains. Every other hook stays as it was.
+ */
+export function withoutHooks(hooks) {
+    const result = {};
+    for (const [event, items] of Object.entries(hooks ?? {})) {
+        const kept = (Array.isArray(items) ? items : []).filter(item => !isWisdomHook(item));
+        if (kept.length)
+            result[event] = kept;
+    }
+    return Object.keys(result).length ? result : undefined;
+}
+const isWisdomHook = (item) => Array.isArray(item?.hooks) && item.hooks.some((h) => typeof h?.command === 'string'
+    && /integrations\/(?:claude-code|codex)\/hook\.mjs/.test(h.command.replaceAll('\\', '/')));
+export function saveSettings(file, value) {
+    fs.mkdirSync(path.dirname(file), { recursive: true });
+    writeJson(file, value);
+}
+/** Save settings that no longer name Wisdom; a file left empty is removed, and so is a folder
+ * it leaves empty, since Wisdom made them.
+ */
+export function saveOrRemoveSettings(file, value) {
+    if (Object.keys(value).length) {
+        saveSettings(file, value);
+        return;
+    }
+    fs.rmSync(file, { force: true });
+    try {
+        fs.rmdirSync(path.dirname(file));
+    }
+    catch { /* not empty */ }
+}
+/** Harnesses whose home or project settings point at a Wisdom build that is no longer there (the
+ * install moved). Their hooks cannot run, so only the session files can be read until init repairs them.
+ */
+export function staleHooks(dataDir) {
+    return ['claude-code', 'codex', 'pi'].filter(harness => ['home', 'project']
+        .some(place => hookFiles(dataDir, harness, place).some(file => !fs.existsSync(file))));
+}
+/** How one harness's home, or the project, is connected to this copy of Wisdom. `other` means
+ * its hooks run a different copy, such as one left under a previous Node version.
+ */
+export function hookState(dataDir, harness, place = 'home') {
+    const files = hookFiles(dataDir, harness, place);
+    if (!files.length)
+        return 'none';
+    if (files.some(file => !fs.existsSync(file)))
+        return 'stale';
+    const expected = harness === 'pi' ? new URL('./pi/extension.js', import.meta.url) : new URL(`../../../integrations/${harness}/hook.mjs`, import.meta.url);
+    const same = (file) => path.relative(fileURLToPath(expected), file) === '';
+    return files.every(same) ? 'current' : 'other';
+}
+/** The Wisdom files a harness's settings name, in its home or in the project. */
+function hookFiles(dataDir, harness, place) {
+    let settings;
+    try {
+        settings = readSettings(settingsFile(dataDir, harness, place));
+    }
+    catch {
+        return [];
+    }
+    if (harness === 'pi')
+        return (Array.isArray(settings.extensions) ? settings.extensions : [])
+            .filter((item) => typeof item === 'string' && /harnesses[\\/]pi[\\/]extension\.js$/.test(item));
+    const files = [];
+    for (const items of Object.values(settings.hooks ?? {})) {
+        for (const item of Array.isArray(items) ? items : [])
+            for (const hook of item?.hooks ?? []) {
+                const named = /"([^"]*integrations\/(?:claude-code|codex)\/hook\.mjs)"/.exec(String(hook?.command ?? ''))?.[1];
+                if (named)
+                    files.push(named);
+            }
+    }
+    return files;
+}
+//# sourceMappingURL=launch.js.map

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

@@ -0,0 +1,44 @@
+import path from 'node:path';
+import { contentText, count, jsonlFiles } from '../types.js';
+/** Pi's Usage is already additive (input excludes cache) and carries cost. It appears
+ * on assistant messages, standalone usage entries (cache warming) and compactions.
+ */
+function usage(entry) {
+    const raw = entry?.message?.role === 'assistant' ? entry.message.usage : entry?.usage;
+    if (!raw || typeof raw !== 'object' || typeof entry?.id !== 'string')
+        return [];
+    return [{ key: entry.id, scope: 'call', model: entry.message?.model ?? entry.model, provider: entry.message?.provider ?? entry.provider,
+            input: count(raw.input), cacheRead: count(raw.cacheRead), cacheWrite: count(raw.cacheWrite), output: count(raw.output),
+            reasoning: count(raw.reasoning), costUsd: typeof raw.cost?.total === 'number' ? raw.cost.total : undefined }];
+}
+// Pi's message blocks (text, thinking, toolCall) already match the neutral shape.
+export const pi = {
+    name: 'pi',
+    homeEnv: 'PI_CODING_AGENT_DIR',
+    defaultHome: ['.pi', 'agent'],
+    resume: sessionId => ['pi', '--session', sessionId],
+    toolTarget: (_toolName, input) => typeof input?.path === 'string' ? input.path : undefined,
+    isDirectFileTool: toolName => ['read', 'edit', 'write'].includes(toolName),
+    toolView: toolName => ['edit', 'write'].includes(toolName) ? 'patch' : toolName === 'read' ? 'file' : 'full',
+    nativeSession: entry => entry?.type === 'session' && typeof entry.id === 'string' ? entry.id : undefined,
+    nativeCwd: entry => entry?.type === 'session' && typeof entry.cwd === 'string' ? entry.cwd : undefined,
+    nativeChanges: () => [],
+    isScriptStep: () => false,
+    // A fork's header is dated when it was made, before its copied lines' dates say otherwise.
+    nativeForkedFrom: () => undefined,
+    isNotice: () => false,
+    // The header's `version` is its file format. The extension reports Pi's own version.
+    nativeVersion: () => undefined,
+    nativePrompt: entry => entry?.type === 'message' && entry.message?.role === 'user'
+        ? contentText(entry.message.content)?.trim() || undefined : undefined,
+    // sessions/<folder>/<time>_<session>.jsonl
+    sessionFiles: home => jsonlFiles(path.join(home, 'sessions'), 1),
+    // Only the header names the session and its folder.
+    cloneLine: (entry, { sessionId, move }) => entry?.type === 'session'
+        ? { ...entry, id: sessionId, ...(typeof entry.cwd === 'string' ? { cwd: move(entry.cwd) } : {}) } : entry,
+    // sessions/--<the folder, \ / and : as ->--/<ISO time, : and . as ->_<session>.jsonl
+    sessionFile: (home, sessionId, cwd, now) => path.join(home, 'sessions', `--${cwd.replace(/[\\/:]/g, '-')}--`, `${now.toISOString().replace(/[:.]/g, '-')}_${sessionId}.jsonl`),
+    nativeEntry: entry => ({ id: entry?.id, parentId: entry?.parentId, timestamp: entry?.timestamp,
+        kind: String(entry?.type ?? 'unknown'), messages: entry?.message ? [entry.message] : [], usage: usage(entry) }),
+};
+//# sourceMappingURL=adapter.js.map