waku-memory 0.2.0 → 0.3.0

package/dist/codex-config.js

@@ -0,0 +1,321 @@
+// The Codex config writers (spec 012 §4.2, §4.3, §4.6): everything `capture
+// enable` needs to touch on a Codex machine, as pure functions over strings
+// and objects. Task 10 wires the real paths (~/.codex/config.toml, ~/.codex/
+// hooks.json, ~/.agents/plugins/marketplace.json) and does the atomic
+// writes; this file only decides *what* the new content should be.
+//
+// The TOML table is added with a line scan, not a TOML library: this shim
+// ships zero runtime dependencies (package.json), and `codex mcp add` was
+// measured (harnesses.ts's own comment on Codex) to be a guess from OpenAI's
+// docs rather than a verified integration -- pulling in a parser to
+// reserialise a file we cannot fully round-trip is a worse bet than reading
+// and writing back exactly the lines we understand, byte for byte, and
+// leaving everything else on the page untouched.
+//
+// The hooks.json merge mirrors capture.ts's mergeHookSettings/removeHookSettings
+// for Claude Code's settings.json -- same replace-ours-keep-foreign
+// semantics, same non-string guard on entries we did not write ourselves.
+import { existsSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { PROFILES } from "./harnesses.js";
+// ---------------------------------------------------------------------------
+// The [mcp_servers.waku] TOML table
+// ---------------------------------------------------------------------------
+export const CODEX_TOML_TABLE = '[mcp_servers.waku]';
+// Matches the table header on its own line, allowing leading/trailing
+// whitespace the way a hand-edited file might have -- but not a header that
+// merely appears inside a comment or a longer table name.
+const TABLE_HEADER_RE = /^\s*\[mcp_servers\.waku\]\s*$/;
+// Any other table header -- marks the end of ours.
+const NEXT_HEADER_RE = /^\s*\[/;
+const URL_LINE_RE = /^\s*url\s*=\s*(.+?)\s*$/;
+const DEFAULT_APPROVAL_LINE = 'default_tools_approval_mode = "approve"';
+// Both `"..."` and `'...'` count as quoting (ruling): TOML allows either,
+// and a value someone typed by hand is exactly the case this comparison
+// exists for.
+function unquoteTomlValue(raw) {
+    const trimmed = raw.trim();
+    if (trimmed.length >= 2) {
+        const first = trimmed[0];
+        const last = trimmed[trimmed.length - 1];
+        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+            return trimmed.slice(1, -1);
+        }
+    }
+    return trimmed;
+}
+// Detect the file's line ending so the writer preserves it: Windows Codex
+// machines use CRLF; Unix-like machines use LF. This ensures that writing to
+// an existing file keeps every other byte as found -- a CRLF file stays
+// uniformly CRLF, an LF file stays LF.
+//
+// Splitting on "\n" leaves a trailing "" element whenever the text ends with
+// a newline -- an artifact of split, not a real blank line at the end of the
+// file. Stripped here once so every line-scanning function below can treat
+// `lines[i]` as an actual line without special-casing the last index; the
+// trailing newline itself is tracked separately and restored on the way out.
+// Any trailing \r on each line (left by CRLF->LF split) is also stripped,
+// since regex `.trim()` and `\s` in the table header will match and tolerate
+// it but our own appended lines should never have it.
+function splitLines(text) {
+    const lineEnding = text.includes('\r\n') ? '\r\n' : '\n';
+    const hadTrailingNewline = text.endsWith('\n');
+    const body = hadTrailingNewline ? text.slice(0, -1) : text;
+    const lines = body.split('\n').map((line) => (lineEnding === '\r\n' && line.endsWith('\r') ? line.slice(0, -1) : line));
+    return { lines, hadTrailingNewline, lineEnding };
+}
+function joinLines(lines, hadTrailingNewline, lineEnding = '\n') {
+    return lines.join(lineEnding) + (hadTrailingNewline ? lineEnding : '');
+}
+// Finds our table's header line and the index where it ends -- either the
+// next `[...]` header or the end of the file.
+function findWakuTable(lines) {
+    const headerIdx = lines.findIndex((l) => TABLE_HEADER_RE.test(l));
+    if (headerIdx === -1)
+        return undefined;
+    let endIdx = lines.length;
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        if (NEXT_HEADER_RE.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    return { headerIdx, endIdx };
+}
+// The first `url = ...` line inside [headerIdx, endIdx) -- the table body.
+function findUrlLine(lines, headerIdx, endIdx) {
+    for (let i = headerIdx + 1; i < endIdx; i++) {
+        const m = URL_LINE_RE.exec(lines[i]);
+        if (m)
+            return { index: i, value: unquoteTomlValue(m[1]) };
+    }
+    return undefined;
+}
+function codexTomlBlock(url, lineEnding = '\n') {
+    return `${lineEnding}${CODEX_TOML_TABLE}${lineEnding}url = "${url}"${lineEnding}${DEFAULT_APPROVAL_LINE}${lineEnding}`;
+}
+// Appends `\n[mcp_servers.waku]\nurl = "<url>"\ndefault_tools_approval_mode =
+// "approve"\n`, preceded by one blank line, when no such table exists yet.
+// Refuses -- leaves `existing` byte-for-byte untouched -- when a table is
+// already there with a different (or unreadable) url: someone configured
+// this by hand, and silently replacing it would undo a deliberate choice
+// with no trace (same reasoning as harnesses.ts's mergeMcpConfig refusal for
+// Claude Code's config). Unchanged, also untouched, when the table already
+// carries exactly our url.
+export function mergeCodexToml(existing, url) {
+    const { lines, lineEnding } = splitLines(existing);
+    const table = findWakuTable(lines);
+    if (table) {
+        const found = findUrlLine(lines, table.headerIdx, table.endIdx);
+        if (found && found.value === url)
+            return { text: existing, result: 'unchanged' };
+        return { text: existing, result: 'refused' };
+    }
+    const hasTrailingNewline = existing.endsWith('\n');
+    const base = hasTrailingNewline ? existing : existing + lineEnding;
+    return { text: base + codexTomlBlock(url, lineEnding), result: 'wrote' };
+}
+// The exact inverse of the "wrote" branch above: removes the header, the
+// `url` line and the `default_tools_approval_mode` line, and the one blank
+// line that preceded the header if it is there -- and only when the table's
+// url equals ours AND the table holds nothing else. A table a person added
+// a line to (even a comment) is left alone entirely: "nothing" is the safe
+// answer whenever removal cannot be proven to touch only what we wrote. The
+// two lines must also be in the order codexTomlBlock wrote them (url, then
+// the approval mode) -- `body[0]`/`body[1]` are checked positionally, not
+// searched for, so a file where someone reordered them fails the same way
+// an added line would and is left untouched.
+//
+// R22 (final review, spec 012): a `[mcp_servers.waku.<sub>]` header
+// immediately after our two lines is a TOML sub-table of ours, not an
+// unrelated table -- findWakuTable's endIdx (shared with mergeCodexToml)
+// stops at it the same as at any other header, so the body-length check
+// above would otherwise see exactly our two lines and remove them, leaving
+// the sub-table behind. TOML then implicitly recreates mcp_servers.waku,
+// empty and with no url, the moment that sub-table is parsed -- so this is
+// refused before the body is even read.
+export function removeCodexToml(existing, url) {
+    const { lines, hadTrailingNewline, lineEnding } = splitLines(existing);
+    const table = findWakuTable(lines);
+    if (!table)
+        return { text: existing, result: 'nothing' };
+    const { headerIdx, endIdx } = table;
+    if (endIdx < lines.length && /^\s*\[mcp_servers\.waku\./.test(lines[endIdx])) {
+        return { text: existing, result: 'nothing' };
+    }
+    const body = lines.slice(headerIdx + 1, endIdx);
+    const urlLine = body.length > 0 ? URL_LINE_RE.exec(body[0]) : null;
+    const urlMatches = urlLine !== null && unquoteTomlValue(urlLine[1]) === url;
+    const defaultLineMatches = body.length > 1 && body[1].trim() === DEFAULT_APPROVAL_LINE;
+    if (body.length !== 2 || !urlMatches || !defaultLineMatches) {
+        return { text: existing, result: 'nothing' };
+    }
+    const hasBlankBefore = headerIdx > 0 && lines[headerIdx - 1] === '';
+    const removeStart = hasBlankBefore ? headerIdx - 1 : headerIdx;
+    const newLines = [...lines.slice(0, removeStart), ...lines.slice(endIdx)];
+    return { text: joinLines(newLines, hadTrailingNewline, lineEnding), result: 'removed' };
+}
+// The marker that names an entry as ours: it can only appear in a command
+// this shim generated, never in something a person or another tool wrote by
+// hand (the leading space rules out an unrelated command that merely ends
+// in a word containing "hook").
+const OWN_CODEX_MARKER = ' hook --harness codex';
+function codexHookCommand(indexPath) {
+    const posix = indexPath.replace(/\\/g, '/');
+    const windows = indexPath.replace(/\//g, '\\');
+    return {
+        command: `node "${posix}" hook --harness codex`,
+        command_windows: `node "${windows}" hook --harness codex`,
+    };
+}
+// The three events capture.ts's Claude Code profile installs, reshaped for
+// Codex: same three-event split (SessionStart brief, Stop flush, SessionEnd
+// flush-on-exit), different timing and output contract per PROFILES.codex
+// (harnesses.ts) and spec 012 §4. `statusMessage` is Codex's own field for
+// what SessionStart shows while the hook runs; Codex has no matching notion
+// for Stop or SessionEnd, so it is left off there. The matcher omits "fork"
+// -- unlike Claude Code's SESSION_START_MATCHER, Codex has no fork event to
+// name (controller ruling).
+export function codexHookEntries(indexPath) {
+    const { command, command_windows } = codexHookCommand(indexPath);
+    const base = { type: 'command', command, command_windows };
+    // Built as named variables, not inline literals, before landing in a
+    // `hooks: HookCommandEntry[]` position -- CodexHookEntry's extra fields
+    // (statusMessage, command_windows, timeout, a boolean async) are fine on a
+    // value structurally, but TypeScript's excess-property check would reject
+    // an *inline* object literal with fields HookCommandEntry does not name.
+    const sessionStartHook = { ...base, timeout: 5, statusMessage: 'Waku memory' };
+    const stopHook = { ...base, async: true, timeout: 600 };
+    const sessionEndHook = { ...base, timeout: PROFILES.codex.sessionEndHookTimeoutS };
+    return {
+        SessionStart: [{ matcher: 'startup|resume|clear|compact', hooks: [sessionStartHook] }],
+        Stop: [{ hooks: [stopHook] }],
+        SessionEnd: [{ hooks: [sessionEndHook] }],
+    };
+}
+// Ours in either field. `entry` is `unknown`, the same way isOwnEntry in
+// capture.ts treats settings.json contents as untrusted: hooks.json is only
+// validated as a top-level object, so anything nested under `hooks` could be
+// whatever another tool wrote there. Never throws -- a malformed entry
+// (a non-string `command`) is simply not ours.
+export function isOwnCodexEntry(entry) {
+    if (typeof entry !== 'object' || entry === null)
+        return false;
+    const e = entry;
+    const inCommand = typeof e.command === 'string' && e.command.includes(OWN_CODEX_MARKER);
+    const inCommandWindows = typeof e.command_windows === 'string' && e.command_windows.includes(OWN_CODEX_MARKER);
+    return inCommand || inCommandWindows;
+}
+// A group is "ours" only if every hook inside it is ours -- see capture.ts's
+// isOwnGroup for why "every" (not "some") is what makes the remove side
+// exact.
+function isOwnCodexGroup(group) {
+    return group.hooks.length > 0 && group.hooks.every(isOwnCodexEntry);
+}
+// Replaces any group of ours on each event with a freshly built one, keeps
+// every foreign group untouched -- the same replace-not-skip semantics as
+// capture.ts's mergeHookSettings, so re-running `capture enable` after an
+// upgrade always lands the current entry rather than leaving a stale one
+// beside it.
+export function mergeCodexHooks(existing, indexPath) {
+    const hooks = { ...(existing.hooks ?? {}) };
+    for (const [event, groups] of Object.entries(codexHookEntries(indexPath))) {
+        hooks[event] = [...(hooks[event] ?? []).filter((g) => !isOwnCodexGroup(g)), ...groups];
+    }
+    return { ...existing, hooks };
+}
+// The exact inverse: drops every group that is entirely ours, and drops an
+// event key altogether once nothing is left under it.
+export function removeCodexHooks(existing) {
+    if (!existing.hooks)
+        return existing;
+    const hooks = {};
+    for (const [event, groups] of Object.entries(existing.hooks)) {
+        const kept = groups.filter((g) => !isOwnCodexGroup(g));
+        if (kept.length > 0)
+            hooks[event] = kept;
+    }
+    if (Object.keys(hooks).length === 0) {
+        const { hooks: _drop, ...rest } = existing;
+        return rest;
+    }
+    return { ...existing, hooks };
+}
+export const WAKU_MARKETPLACE_ENTRY = {
+    name: 'waku',
+    source: { source: 'npm', package: 'waku-memory' },
+    policy: { installation: 'AVAILABLE', authentication: 'ON_INSTALL' },
+    category: 'Developer Tools',
+};
+// Writes our entry once. `existing` undefined (no marketplace.json yet)
+// yields a fresh personal marketplace holding just ours; an existing file
+// keeps its own name/interface/other keys and other plugins, with ours
+// appended -- matched by `plugins[].name === 'waku'`, so a second run is a
+// no-op rather than a duplicate entry.
+export function mergeMarketplaceEntry(existing) {
+    if (existing?.plugins?.some((p) => p.name === 'waku')) {
+        return { data: existing, result: 'unchanged' };
+    }
+    const base = existing ?? { name: 'personal', interface: { displayName: 'Personal' } };
+    return { data: { ...base, plugins: [...(base.plugins ?? []), WAKU_MARKETPLACE_ENTRY] }, result: 'wrote' };
+}
+// ---------------------------------------------------------------------------
+// Plugin detection
+// ---------------------------------------------------------------------------
+// Matches `[plugins."waku@<marketplace>"]` -- the table config.toml carries
+// once the plugin is actually installed (as opposed to merely listed in a
+// marketplace file, which only makes it available). Ruling R21: both quoting
+// styles TOML allows for the key count, the same reasoning as
+// unquoteTomlValue above -- a table someone hand-edited is exactly the case
+// this needs to tolerate.
+const PLUGIN_TABLE_HEADER_RE = /^\s*\[plugins\.(?:"waku@[^"]*"|'waku@[^']*')\]\s*$/;
+const ENABLED_FALSE_RE = /^\s*enabled\s*=\s*false\b/;
+// R21 (final review, spec 012): the config.toml table is authoritative when
+// present -- returns true/false for "the table says so", or undefined when
+// there is no such table at all (the cache probe's cue to run). A table
+// with no `enabled` line at all means present (Codex's own default); one
+// that sets `enabled = false` means absent, full stop, regardless of what
+// the plugin cache still has lying around. Scans only up to the next table
+// header, the same boundary findWakuTable uses above for
+// [mcp_servers.waku].
+function wakuPluginTableStatus(configToml) {
+    const { lines } = splitLines(configToml);
+    const headerIdx = lines.findIndex((l) => PLUGIN_TABLE_HEADER_RE.test(l));
+    if (headerIdx === -1)
+        return undefined;
+    let endIdx = lines.length;
+    for (let i = headerIdx + 1; i < lines.length; i++) {
+        if (NEXT_HEADER_RE.test(lines[i])) {
+            endIdx = i;
+            break;
+        }
+    }
+    const disabled = lines.slice(headerIdx + 1, endIdx).some((l) => ENABLED_FALSE_RE.test(l));
+    return !disabled;
+}
+// Detects whether the Waku plugin is already installed, by either route
+// Codex uses: the config.toml table (source of truth once Codex has loaded
+// it -- ruling R21, wakuPluginTableStatus above), or a `waku` directory
+// under some marketplace's entry in Codex's plugin cache (on this machine,
+// `~/.codex/plugins/cache/<marketplace>/<plugin>` -- present even before
+// config.toml is regenerated). The cache probe runs only when no table
+// exists at all: a lingering cache directory from an uninstalled plugin, or
+// one from before a table with `enabled = false` was added, must not
+// override what the table now says. `io` defaults to node:fs's real
+// existsSync/readdirSync; tests inject a stand-in so this stays a pure
+// function over its inputs otherwise. Any error reading the cache directory
+// (ENOENT when it does not exist yet, or anything else) means "not present
+// by that route".
+export function codexPluginPresent(configToml, pluginsCacheDir, io = { existsSync, readdirSync }) {
+    const tableStatus = wakuPluginTableStatus(configToml);
+    if (tableStatus !== undefined)
+        return tableStatus;
+    let marketplaces;
+    try {
+        marketplaces = io.readdirSync(pluginsCacheDir);
+    }
+    catch {
+        return false;
+    }
+    return marketplaces.some((m) => io.existsSync(join(pluginsCacheDir, m, 'waku')));
+}

package/dist/dialogue-codex.js

@@ -0,0 +1,63 @@
+// The codex-dialogue-v1 rule (spec 012 §5): the same three kinds of entry
+// as cc-dialogue-v1, read out of Codex's rollout records.
+import { formatDelta } from "./dialogue.js";
+export const CODEX_CONTENT_FORMAT = 'codex-dialogue-v1';
+export const CODEX_HARNESS_TAGS = ['<environment_context>', '<recommended_plugins>'];
+const LEADING_BLANKS = /^[ \t\r\n\f\v]+/;
+const TOOL_MENTION = /tools\.([A-Za-z0-9_]+)\(/g;
+function isHarnessTag(text) {
+    const t = text.replace(LEADING_BLANKS, '');
+    return CODEX_HARNESS_TAGS.some((tag) => t.startsWith(tag));
+}
+function texts(content, partType) {
+    if (!Array.isArray(content))
+        return [];
+    const out = [];
+    for (const c of content) {
+        if (c && typeof c === 'object' && c.type === partType) {
+            const t = c.text;
+            if (typeof t === 'string' && t.length > 0)
+                out.push(t);
+        }
+    }
+    return out;
+}
+export function formatCodexLine(line) {
+    let record;
+    try {
+        record = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (!record || typeof record !== 'object')
+        return [];
+    const r = record;
+    if (r.type !== 'response_item' || !r.payload || typeof r.payload !== 'object')
+        return [];
+    const p = r.payload;
+    if (p.type === 'message') {
+        if (p.role === 'user')
+            return texts(p.content, 'input_text').filter((t) => !isHarnessTag(t)).map((text) => ({ role: 'user', text }));
+        if (p.role === 'assistant')
+            return texts(p.content, 'output_text').map((text) => ({ role: 'assistant', text }));
+        return [];
+    }
+    if (p.type === 'function_call')
+        return typeof p.name === 'string' ? [{ role: 'tool', text: p.name }] : [];
+    if (p.type === 'custom_tool_call') {
+        const names = [];
+        if (typeof p.input === 'string') {
+            for (const m of p.input.matchAll(TOOL_MENTION))
+                if (!names.includes(m[1]))
+                    names.push(m[1]);
+        }
+        if (names.length === 0)
+            names.push(typeof p.name === 'string' ? p.name : 'exec');
+        return names.map((text) => ({ role: 'tool', text }));
+    }
+    return [];
+}
+export function formatCodexDelta(buf, maxPieceBytes) {
+    return formatDelta(buf, maxPieceBytes, formatCodexLine);
+}

package/dist/dialogue.js

@@ -101,7 +101,7 @@ export function formatRecord(line) {
 // newline yet) is left for the next event. `end` is the offset past the
 // last newline consumed, whether or not anything survived -- the
 // caller's watermark moves to it either way.
-export function formatDelta(buf, maxPieceBytes = MAX_PIECE_BYTES) {
+export function formatDelta(buf, maxPieceBytes = MAX_PIECE_BYTES, lineFormatter = formatLine) {
     const pieces = [];
     let entries = [];
     let entriesBytes = 0;
@@ -120,7 +120,7 @@ export function formatDelta(buf, maxPieceBytes = MAX_PIECE_BYTES) {
         if (nl === -1)
             break;
         const lineEnd = nl + 1;
-        const lineEntries = formatLine(buf.subarray(lineStart, nl).toString('utf8'));
+        const lineEntries = lineFormatter(buf.subarray(lineStart, nl).toString('utf8'));
         lineStart = lineEnd;
         end = lineEnd;
         if (lineEntries.length === 0) {

package/dist/harnesses.js

@@ -2,9 +2,17 @@
 // destroying what is there. One file per harness would be tidier and is not
 // worth it yet: the shapes are nearly identical, and the differences are
 // worth seeing side by side while there are only two.
+//
+// This file also carries the *hook* side of "one harness, one profile"
+// (spec 012 §4): everything hook.ts needs to know about the harness it is
+// running under -- content format, delta formatter, timing budgets, and how
+// the brief is printed -- lives on one HarnessProfile per HarnessId, so
+// hook.ts itself never asks "which harness is this?" by string compare.
 import { existsSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
+import { CONTENT_FORMAT, formatDelta } from "./dialogue.js";
+import { CODEX_CONTENT_FORMAT, formatCodexDelta } from "./dialogue-codex.js";
 export function mergeMcpConfig(existing, name, url) {
     const servers = existing.mcpServers ?? {};
     const current = servers[name];
@@ -27,26 +35,53 @@ export function getHarnesses() {
 export function harnessConfigExists(harness) {
     return existsSync(harness.configPath);
 }
-// Printed only when ~/.codex/config.toml actually exists. Before 2026-08-26
-// this went to everyone on every run, including the Claude-Code-only user
-// who has no Codex and no use for a TOML block -- noise that made the
-// output worse the more harnesses we knew about, which is the wrong
-// direction for that to scale.
-export function codexNote(name, url) {
-    return (`Codex: found here, but not configured automatically -- this shim's\n` +
-        `knowledge of Codex's format comes from OpenAI's docs\n` +
-        `(learn.chatgpt.com/docs/extend/mcp), never from a real install, and\n` +
-        `writing a guessed shape into a config that is really there is worse\n` +
-        `than leaving it alone. Add this yourself, then run\n` +
-        `"codex mcp login ${name}" (Codex does not sign in on first use the way\n` +
-        `Claude Code does):\n` +
-        `    [mcp_servers.${name}]\n` +
-        `    url = "${url}"\n` +
-        `Codex also has a "codex mcp" subcommand (add/list/login), which would\n` +
-        `be the better route -- but its documented CLI syntax covers stdio\n` +
-        `servers only (checked 2026-08-26), so the TOML above is the part that\n` +
-        `can be stated exactly.`);
-}
-export function getManualHarnesses() {
-    return [{ name: 'Codex', configPath: join(homedir(), '.codex', 'config.toml'), note: codexNote }];
+// The SessionEnd flush has to finish inside the hook entry capture.ts
+// installs for it, or Claude Code kills the process mid-request with no
+// chance to log why. That entry's `timeout` (seconds) is
+// SESSION_END_HOOK_TIMEOUT_S, defined here (not in hook.ts) so capture.ts's
+// import of it and hook.ts's own use of the Claude Code profile cannot drift
+// apart again: until 2026-09-04 the network budget below was 800 ms, derived
+// from Claude Code's 1.5 s *default* SessionEnd budget, while the installed
+// entry had already raised that budget to 10 s -- and 800 ms is one cold
+// round trip to api.waku.one from Yang's machine (three real POST
+// /ingest/session calls measured 822, 644 and 1174 ms), so two of every
+// three flushes were aborted by our own timer. That is the last turn of
+// every session, and all of a single-turn one.
+//
+// The network budget is the process budget minus what happens before the
+// request: `npx -y waku-memory hook` took 2.8 s to reach this code cold
+// (2026-09-04), and Node startup, stdin and the transcript read are a few
+// hundred milliseconds more. 5 s leaves about 2 s of the 10 s for a slower
+// machine. hook.test.mjs pins both bounds. Stop is not bounded this way
+// (600 s budget, and runs "async": true), so its path through postDelta does
+// not use this.
+//
+// Defined here rather than in hook.ts to avoid an import cycle: hook.ts
+// needs profileFor() from this file, and capture.ts needs these two
+// constants -- re-exported from hook.ts, unchanged, so capture.ts's existing
+// import keeps working.
+export const SESSION_END_HOOK_TIMEOUT_S = 10;
+export const SESSION_END_TIMEOUT_MS = 5000;
+export const PROFILES = {
+    claude_code: {
+        id: 'claude_code',
+        contentFormat: CONTENT_FORMAT,
+        formatDelta,
+        sessionEndTimeoutMs: SESSION_END_TIMEOUT_MS,
+        sessionEndHookTimeoutS: SESSION_END_HOOK_TIMEOUT_S,
+        briefOutput: (t) => t,
+        silentWithoutCredential: false,
+    },
+    codex: {
+        id: 'codex',
+        contentFormat: CODEX_CONTENT_FORMAT,
+        formatDelta: formatCodexDelta,
+        sessionEndTimeoutMs: 2000,
+        sessionEndHookTimeoutS: 3,
+        briefOutput: (t) => JSON.stringify({ hookSpecificOutput: { hookEventName: 'SessionStart', additionalContext: t } }),
+        silentWithoutCredential: true,
+    },
+};
+export function profileFor(id) {
+    return PROFILES[id];
 }