waku-memory 0.2.0 → 0.4.0

package/.codex-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "waku",
+  "version": "0.4.0",
+  "description": "Waku Memory: durable memory for your Codex sessions. memory.recall brings what is known about a project into a session; memory.remember keeps what matters; the plugin's hooks open each session with a brief and send each turn to be remembered.",
+  "skills": "./skills/",
+  "hooks": "./hooks/hooks.json",
+  "interface": {
+    "displayName": "Waku Memory",
+    "shortDescription": "Memory that follows you across sessions",
+    "developerName": "Waku",
+    "category": "Developer Tools",
+    "capabilities": ["Read", "Write"],
+    "websiteURL": "https://www.waku.one/"
+  }
+}

package/.mcp.json

@@ -0,0 +1,9 @@
+{
+  "mcpServers": {
+    "waku": {
+      "type": "http",
+      "url": "https://api.waku.one/mcp",
+      "default_tools_approval_mode": "approve"
+    }
+  }
+}

package/README.md

@@ -0,0 +1,55 @@
+# waku-memory
+
+This package is the shim that connects an agent harness to Waku Memory. It
+points Claude Code's or Codex's MCP config at Waku's server, and it can turn
+on capture: hooks that send each turn of a session to the server, so the
+agent remembers a project across sessions without anyone typing the same
+conventions twice.
+
+## Commands
+
+- `npx waku-memory setup [--name <name>] [--url <url>]` adds the Waku MCP
+  server to Claude Code's config.
+- `npx waku-memory capture enable [flags]` turns on automatic capture: it
+  shows a disclosure, asks you to accept it, then installs hooks for every
+  harness this machine has.
+- `npx waku-memory login [--url <ingest-base>]` signs in through the
+  browser and mints an API key, without you ever seeing it.
+- `npx waku-memory capture disable` removes exactly the hook entries
+  `capture enable` added. Your saved key stays where it is.
+- `npx waku-memory capture status` prints whether capture is installed for
+  Claude Code and for Codex, and whether a key is saved. It only reads.
+
+`capture enable` takes these flags:
+
+- `--login` signs in through the browser without asking first.
+- `--key <key>` uses this key without asking first.
+- `--url <ingest-base>` points capture at a server other than the default.
+- `--since <N>d` limits the history scan to the last N days.
+- `--all` scans full history instead of `--since`.
+- `--no-bootstrap` skips the history scan and its question entirely.
+
+## Codex
+
+Codex can run Waku's hooks and MCP server through two routes.
+
+**The plugin.** Install Waku from a Codex plugin marketplace. The plugin
+needs no Node on your machine; it carries its own hooks and its own MCP
+server, and Codex signs you in with its own OAuth flow when you install it.
+Codex still runs a new hook only after you trust it: open `/hooks` in Codex
+and trust Waku's entries once.
+
+**The CLI.** `npx waku-memory capture enable` on a machine with Codex
+installed writes the `[mcp_servers.waku]` table into
+`~/.codex/config.toml` and three entries (`SessionStart`, `Stop`,
+`SessionEnd`) into `~/.codex/hooks.json`. This route runs the compiled
+shim directly, so it needs Node 20 or newer. Codex asks the same trust
+step: open `/hooks` and trust Waku's three entries once.
+
+When both routes are present on the same machine, the plugin wins:
+`capture enable` leaves both Codex files untouched and says so, since the
+plugin already carries the hooks and the MCP server.
+
+`login` works the same way on Codex as it does on Claude Code: it signs you
+in and stores the key at `~/.waku-memory/config.json`, without touching
+either harness's config.

package/dist/bootstrap.js

@@ -2,18 +2,24 @@
 // Code's own memory files and transcripts, sizing what each transcript
 // would send, rendering the one numbered list, parsing the one answer
 // (task 12), and sending whatever the answer did not exclude to
-// POST /imports and POST /ingest/session (task 13). capture.ts's enable()
-// is the caller: it runs the scan, asks the one question, and calls
-// runBootstrap below with the answer (task 13); task 14 adds the
-// --since/--all/--no-bootstrap flags that change what enable() asks for.
+// POST /imports and POST /ingest/session (task 13). Spec 012 §8 (task 11)
+// extends the scan to Codex's own rollouts -- scanCodex and scanAll, below
+// scanClaudeCode -- reusing the same per-session listing/sizing rule
+// (scanTranscript) with only the formatter and the cwd finder differing.
+// capture.ts's enable() is the caller: it runs the scan, asks the one
+// question, and calls runBootstrap below with the answer (task 13); task 14
+// adds the --since/--all/--no-bootstrap flags that change what enable()
+// asks for.
 //
 // Zero dependencies, per the brief: node:fs and node:path, plus the sibling
-// dialogue.ts (the cc-dialogue-v1 formatter and CONTENT_FORMAT, spec 011
-// §1/§3), hook.ts (readWatermark/writeWatermark/droppedMarkerPath -- the
-// same rules the live hook uses to read and advance its own bookkeeping
-// files, not reimplemented here) and project.ts (resolveProject, spec 011
-// §7). hook.ts's own postJson is private, so the sending half below writes
-// its own small `post` rather than importing it.
+// dialogue.ts (the Piece type, spec 011 §1/§3), harnesses.ts (PROFILES --
+// each harness's own content_format and delta formatter, task 8, so this
+// file never hardcodes either), hook.ts
+// (readWatermark/writeWatermark/droppedMarkerPath -- the same rules the
+// live hook uses to read and advance its own bookkeeping files, not
+// reimplemented here) and project.ts (resolveProject, spec 011 §7). hook.ts's
+// own postJson is private, so the sending half below writes its own small
+// `post` rather than importing it.
 //
 // Every function below takes plain values (a directory, a Buffer, a Scan)
 // so bootstrap.test.mjs can build a throwaway ~/.claude -- or, for the
@@ -22,8 +28,8 @@
 // network.
 import { existsSync, readFileSync, readdirSync, statSync, openSync, readSync, closeSync, unlinkSync, mkdirSync, writeFileSync, appendFileSync, } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
-import { CONTENT_FORMAT, formatDelta } from "./dialogue.js";
 import { droppedMarkerPath, readWatermark, writeWatermark } from "./hook.js";
+import { PROFILES } from "./harnesses.js";
 import { resolveProject } from "./project.js";
 export const DEFAULT_WINDOW_DAYS = 180;
 export const LIVE_WINDOW_MS = 10 * 60 * 1000;
@@ -148,25 +154,57 @@ function determineListing(watermarkPath, markerPath, fileSize, all) {
 function sumPieceBytes(pieces) {
     return pieces.reduce((sum, p) => sum + Buffer.byteLength(p.text, 'utf8'), 0);
 }
-// formatDelta(buf.subarray(from)) plus formatDelta(buf.subarray(start, end))
-// per span (spec 011 §8) -- the same formatter the live hook posts with, so
-// the size shown is the size that would actually be sent. Offsets are
-// clamped defensively: a hand-edited or stale watermark/marker must size to
-// *something* rather than throw out of a pure scan.
-function sizeSession(buf, from, spans) {
+// formatDeltaFn(buf.subarray(from)) plus formatDeltaFn(buf.subarray(start,
+// end)) per span (spec 011 §8) -- the same formatter the live hook posts
+// with, so the size shown is the size that would actually be sent. Offsets
+// are clamped defensively: a hand-edited or stale watermark/marker must
+// size to *something* rather than throw out of a pure scan.
+function sizeSession(buf, from, spans, formatDeltaFn) {
     const clampedFrom = Math.min(Math.max(from, 0), buf.length);
-    const tail = formatDelta(buf.subarray(clampedFrom));
+    const tail = formatDeltaFn(buf.subarray(clampedFrom));
     let dialogueBytes = sumPieceBytes(tail.pieces);
     let pieces = tail.pieces.length;
     for (const span of spans) {
         const start = Math.min(Math.max(span.start, 0), buf.length);
         const end = Math.min(Math.max(span.end, start), buf.length);
-        const result = formatDelta(buf.subarray(start, end));
+        const result = formatDeltaFn(buf.subarray(start, end));
         dialogueBytes += sumPieceBytes(result.pieces);
         pieces += result.pieces.length;
     }
     return { dialogueBytes, pieces };
 }
+function scanTranscript(path, mtimeMs, size, sessionId, stateDir, opts, formatDeltaFn, findCwdFn) {
+    if (mtimeMs < opts.sinceMs)
+        return null; // outside the window, --all included: --all is about watermarks, not the window
+    if (opts.nowMs - mtimeMs < opts.liveWindowMs)
+        return null; // its own Stop hook (or, for Codex, nothing yet -- still, the file may still be growing) is still capturing it
+    const watermarkPath = join(stateDir, sessionId);
+    const markerPath = droppedMarkerPath(watermarkPath);
+    const listing = determineListing(watermarkPath, markerPath, size, opts.all);
+    if (!listing.listed) {
+        // Captured whole already, no holes: no SessionEntry, but the caller may
+        // still want this transcript's cwd (Claude Code's slug-name fallback,
+        // scanClaudeCode below) -- so this is resolved regardless of listing.
+        let cwd = null;
+        try {
+            cwd = findCwdFn(readHead(path));
+        }
+        catch {
+            // Unreadable: leave the name unresolved, same as "no cwd".
+        }
+        return { listed: false, cwd };
+    }
+    let buf;
+    try {
+        buf = readFileSync(path);
+    }
+    catch {
+        return null; // disappeared between stat and read
+    }
+    const cwd = findCwdFn(buf);
+    const { dialogueBytes, pieces } = sizeSession(buf, listing.from, listing.spans, formatDeltaFn);
+    return { listed: true, cwd, from: listing.from, spans: listing.spans, dialogueBytes, pieces };
+}
 // ---- grouping ---------------------------------------------------------------
 // The map key sessions and memory files are grouped under: the resolved
 // project name when there is one (so two slugs -- a checkout and its
@@ -231,61 +269,41 @@ export function scanClaudeCode(claudeDir, stateDir, opts) {
                 continue; // disappeared between readdir and stat; nothing to report
             }
             const mtimeMs = stat.mtimeMs;
-            if (mtimeMs < opts.sinceMs)
-                continue; // outside the window, --all included: --all is about watermarks, not the window
-            if (opts.nowMs - mtimeMs < opts.liveWindowMs)
-                continue; // its own Stop hook is still capturing it
             const sessionId = file.slice(0, -'.jsonl'.length);
-            const watermarkPath = join(stateDir, sessionId);
-            const markerPath = droppedMarkerPath(watermarkPath);
-            const listing = determineListing(watermarkPath, markerPath, stat.size, opts.all);
-            if (!listing.listed) {
+            const scanned = scanTranscript(path, mtimeMs, stat.size, sessionId, stateDir, opts, PROFILES.claude_code.formatDelta, findCwd);
+            if (scanned === null)
+                continue; // outside the window, or still live
+            if (!scanned.listed) {
                 // Captured whole already, no holes: no SessionEntry (unchanged),
                 // but this transcript's cwd still counts toward the slug's
                 // resolved name so its memory files keep the project name instead
                 // of falling back to the slug (see slugProjectName above).
-                if (slugProjectName === null) {
-                    try {
-                        const cwd = findCwd(readHead(path));
-                        if (cwd !== null)
-                            slugProjectName = resolveProject(cwd);
-                    }
-                    catch {
-                        // Unreadable: leave the name unresolved, same as "no cwd".
-                    }
-                }
+                if (slugProjectName === null && scanned.cwd !== null)
+                    slugProjectName = resolveProject(scanned.cwd);
                 continue;
             }
-            let buf;
-            try {
-                buf = readFileSync(path);
-            }
-            catch {
-                continue;
-            }
-            const cwd = findCwd(buf);
-            const project = cwd !== null ? resolveProject(cwd) : null;
+            const project = scanned.cwd !== null ? resolveProject(scanned.cwd) : null;
             if (slugProjectName === null && project !== null)
                 slugProjectName = project;
-            const { dialogueBytes, pieces } = sizeSession(buf, listing.from, listing.spans);
             const session = {
                 sessionId,
                 path,
                 project,
-                from: listing.from,
-                spans: listing.spans,
-                dialogueBytes,
-                pieces,
+                from: scanned.from,
+                spans: scanned.spans,
+                dialogueBytes: scanned.dialogueBytes,
+                pieces: scanned.pieces,
                 mtimeMs,
+                harness: 'claude_code',
             };
             const key = groupKey(project, slug);
             let entry = entries.get(key);
             if (!entry) {
-                entry = { name: project, slug, sessions: [], memoryFiles: [], dialogueBytes: 0 };
+                entry = { name: project, slug, sessions: [], memoryFiles: [], dialogueBytes: 0, harness: 'claude_code' };
                 entries.set(key, entry);
             }
             entry.sessions.push(session);
-            entry.dialogueBytes += dialogueBytes;
+            entry.dialogueBytes += scanned.dialogueBytes;
             if (!slugGroup.has(slug))
                 slugGroup.set(slug, key);
         }
@@ -301,14 +319,164 @@ export function scanClaudeCode(claudeDir, stateDir, opts) {
             const key = slugGroup.get(slug) ?? groupKey(slugProjectName, slug);
             let entry = entries.get(key);
             if (!entry) {
-                entry = { name: slugProjectName, slug, sessions: [], memoryFiles: [], dialogueBytes: 0 };
+                entry = { name: slugProjectName, slug, sessions: [], memoryFiles: [], dialogueBytes: 0, harness: 'claude_code' };
                 entries.set(key, entry);
             }
             entry.memoryFiles.push(...memoryFiles);
         }
     }
     const projects = [...entries.values()].sort(compareProjectEntries);
-    return { projects, userClaudeMd: readUserClaudeMd(claudeDir) };
+    return { projects, userClaudeMd: readUserClaudeMd(claudeDir), harnesses: ['claude_code'] };
+}
+// ---- Codex's rollout file name ----------------------------------------------
+//
+// rollout-<19-char timestamp>-<id>.jsonl, e.g.
+// rollout-2026-09-07T10-37-45-a1b2c3d4-....jsonl -- the session id is
+// everything after the timestamp and its trailing dash (spec 012 §8). A
+// name that does not fit this shape is not a rollout this shim understands
+// and is skipped, never guessed at.
+const ROLLOUT_FILE_RE = /^rollout-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-(.+)\.jsonl$/;
+function parseCodexSessionId(fileName) {
+    const m = ROLLOUT_FILE_RE.exec(fileName);
+    return m ? m[1] : null;
+}
+// Every rollout-*.jsonl under <codexDir>/sessions, at any depth -- Codex
+// nests them by date (sessions/2026/09/07/rollout-...) on a real machine.
+// Same do-nothing-on-error rule as listSubdirs/listFiles above: a missing
+// or unreadable directory is "nothing here", never a throw.
+function safeReaddirWithTypes(dir) {
+    try {
+        return readdirSync(dir, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+}
+function listRolloutFiles(sessionsDir) {
+    const out = [];
+    const walk = (dir) => {
+        for (const d of safeReaddirWithTypes(dir)) {
+            const full = join(dir, d.name);
+            if (d.isDirectory())
+                walk(full);
+            else if (d.isFile() && d.name.startsWith('rollout-') && d.name.endsWith('.jsonl'))
+                out.push(full);
+        }
+    };
+    walk(sessionsDir);
+    return out.sort();
+}
+// ---- reading a rollout's cwd from its session_meta record ------------------
+//
+// Codex's own record shape (spec 012 §5): cwd sits under `payload.cwd` of
+// the first `session_meta` record, not at the top level the way Claude
+// Code's own `cwd` field does (findCwd above) -- a different finder, same
+// line-by-line-JSON.parse shape.
+function findCodexCwd(buf) {
+    let start = 0;
+    for (;;) {
+        const nl = buf.indexOf(0x0a, start);
+        const line = nl === -1 ? buf.subarray(start) : buf.subarray(start, nl);
+        if (line.length > 0) {
+            try {
+                const rec = JSON.parse(line.toString('utf8'));
+                if (rec !== null && typeof rec === 'object') {
+                    const r = rec;
+                    if (r.type === 'session_meta' && r.payload !== null && typeof r.payload === 'object') {
+                        const cwd = r.payload.cwd;
+                        if (typeof cwd === 'string')
+                            return cwd;
+                    }
+                }
+            }
+            catch {
+                // Not JSON (or not an object): not this record's job to carry cwd.
+            }
+        }
+        if (nl === -1)
+            return null;
+        start = nl + 1;
+    }
+}
+// ---- the Codex scan (task 11, spec 012 §8) ----------------------------------
+//
+// Codex has no memory files, so unlike scanClaudeCode there is no
+// slug-directory grouping and no need to preserve a resolved name for a
+// memory attachment that never exists here: an entry with no listed session
+// simply never appears. A rollout whose cwd cannot be resolved at all is
+// grouped under its own session id -- scanClaudeCode's "no cwd -> its own
+// bucket" rule (spec 011 §8), with the session id standing in for the slug
+// a Codex rollout has no directory of its own to be grouped by.
+export function scanCodex(codexDir, stateDir, opts) {
+    const sessionsDir = join(codexDir, 'sessions');
+    const entries = new Map();
+    for (const path of listRolloutFiles(sessionsDir)) {
+        const file = basename(path);
+        const sessionId = parseCodexSessionId(file);
+        if (sessionId === null) {
+            console.error(`capture enable: skipping ${path} -- file name does not match rollout-<timestamp>-<id>.jsonl`);
+            continue;
+        }
+        let stat;
+        try {
+            stat = statSync(path);
+        }
+        catch {
+            continue; // disappeared between the walk and stat; nothing to report
+        }
+        const scanned = scanTranscript(path, stat.mtimeMs, stat.size, sessionId, stateDir, opts, PROFILES.codex.formatDelta, findCodexCwd);
+        if (scanned === null || !scanned.listed)
+            continue; // outside the window, still live, or already fully captured
+        const project = scanned.cwd !== null ? resolveProject(scanned.cwd) : null;
+        const key = project !== null ? `name:${project}` : `session:${sessionId}`;
+        const session = {
+            sessionId,
+            path,
+            project,
+            from: scanned.from,
+            spans: scanned.spans,
+            dialogueBytes: scanned.dialogueBytes,
+            pieces: scanned.pieces,
+            mtimeMs: stat.mtimeMs,
+            harness: 'codex',
+        };
+        let entry = entries.get(key);
+        if (!entry) {
+            entry = {
+                name: project,
+                slug: `codex:${project ?? sessionId}`,
+                sessions: [],
+                memoryFiles: [],
+                dialogueBytes: 0,
+                harness: 'codex',
+            };
+            entries.set(key, entry);
+        }
+        entry.sessions.push(session);
+        entry.dialogueBytes += scanned.dialogueBytes;
+    }
+    return [...entries.values()].sort(compareProjectEntries);
+}
+// ---- both harnesses, one scan (task 11, spec 012 §8) ------------------------
+//
+// `null` means "this harness is not on this machine" -- capture.ts's
+// enable() passes deps.claudeDir only when it exists, and
+// dirname(deps.codexConfigPath) only when ~/.codex/config.toml exists.
+// Concatenated and re-sorted together (not Claude Code's list with Codex's
+// appended): compareProjectEntries is the exact ordering scanClaudeCode
+// already used, so a Codex project with more dialogue than every Claude
+// Code project still sorts above them. userClaudeMd is Claude Code's alone
+// -- Codex has no equivalent (spec 012 §8).
+export function scanAll(claudeDir, codexDir, stateDir, opts) {
+    const harnesses = [];
+    if (claudeDir !== null)
+        harnesses.push('claude_code');
+    if (codexDir !== null)
+        harnesses.push('codex');
+    const claudeCode = claudeDir !== null ? scanClaudeCode(claudeDir, stateDir, opts) : { projects: [], userClaudeMd: null, harnesses: [] };
+    const codexProjects = codexDir !== null ? scanCodex(codexDir, stateDir, opts) : [];
+    const projects = [...claudeCode.projects, ...codexProjects].sort(compareProjectEntries);
+    return { projects, userClaudeMd: claudeCode.userClaudeMd, harnesses };
 }
 // ---- rendering the one list (spec 011 §8) ----------------------------------
 function formatSize(bytes) {
@@ -319,8 +487,13 @@ function formatSize(bytes) {
 function plural(n, word) {
     return `${n} ${word}${n === 1 ? '' : 's'}`;
 }
+// task 11: labels a Codex project "(Codex)" from the entry's own `harness`
+// field -- never by string-matching the `codex:` slug prefix, so a future
+// third harness only has to set its own `harness` correctly to get its own
+// label here (see renderBootstrapList's own comment, spec 012 §8).
 function displayLabel(entry) {
-    return entry.name ?? entry.slug;
+    const label = entry.name ?? entry.slug;
+    return entry.harness === 'codex' ? `${label} (Codex)` : label;
 }
 // The label for an entry with no listed sessions: its resolved name alone
 // when it has one -- every in-window session is already fully captured,
@@ -339,10 +512,21 @@ function renderSessionRow(entry, label) {
 function renderNoSessionsRow(entry, label) {
     return `${label}   ${plural(entry.memoryFiles.length, 'memory file')}`;
 }
+// Build a display name for the harnesses the scan covered. An empty list
+// means neither harness was configured on this machine: renders as
+// "Nothing to import on this machine." (no harness phrase).
+function harnessPhrase(harnesses) {
+    if (harnesses.length === 0)
+        return '';
+    if (harnesses.length === 1)
+        return harnesses[0] === 'claude_code' ? 'Claude Code' : 'Codex';
+    return 'Claude Code and Codex';
+}
 export function renderBootstrapList(scan, windowDays) {
-    const { projects, userClaudeMd } = scan;
+    const { projects, userClaudeMd, harnesses } = scan;
+    const phrase = harnessPhrase(harnesses);
     if (projects.length === 0 && userClaudeMd === null) {
-        return 'Nothing from Claude Code to import on this machine.';
+        return phrase === '' ? 'Nothing to import on this machine.' : `Nothing from ${phrase} to import on this machine.`;
     }
     const numbered = projects.map((entry, i) => ({ entry, n: i + 1 }));
     const withSessions = numbered.filter((r) => r.entry.sessions.length > 0);
@@ -359,7 +543,7 @@ export function renderBootstrapList(scan, windowDays) {
     const numWidth = String(projects.length).length + 2;
     const lines = [];
     const windowPhrase = windowDays === null ? 'all transcripts' : `last ${windowDays} days`;
-    lines.push(`Found memory and history from Claude Code on this machine (${windowPhrase}):`);
+    lines.push(`Found memory and history from ${phrase} on this machine (${windowPhrase}):`);
     for (const { entry, n } of numbered) {
         const prefix = String(n).padStart(numWidth) + '. ';
         lines.push(entry.sessions.length > 0
@@ -405,7 +589,6 @@ export function parseBootstrapAnswer(answer, count) {
     const unique = [...new Set(numbers)].sort((a, b) => a - b);
     return { kind: 'exclude', numbers: unique };
 }
-const HARNESS = 'claude_code'; // hook.ts's own HARNESS is private; duplicated rather than exported for one constant
 // ImportRequest's bound (spec 011 §8): a project's memory files are sent in
 // requests of at most this many files each, since `project` is one value
 // per request and files from two different projects can never share one.
@@ -538,13 +721,18 @@ async function sendMemoryFiles(projects, userClaudeMd, deps) {
     }
     return { sent, failed };
 }
+// task 11 (spec 012 §8): harness and content_format both come off the
+// session's own `harness` field via PROFILES (harnesses.ts, task 8) -- the
+// profile is the only place that knows the harness, so a session never
+// carries anything but its own harness's wire shape regardless of which
+// scanner (scanClaudeCode or scanCodex) produced it.
 function sessionBody(session, content) {
     return {
-        harness: HARNESS,
+        harness: session.harness,
         session_id: session.sessionId,
         source: 'backfill',
         content,
-        content_format: CONTENT_FORMAT,
+        content_format: PROFILES[session.harness].contentFormat,
         ...(session.project !== null ? { project: session.project } : {}),
     };
 }
@@ -621,9 +809,13 @@ async function sendSession(session, deps) {
     // trailing newline yet) -- see the function comment for how it is built
     // and why it replaces rather than amends whatever the marker held before.
     const holeLines = [];
+    // task 11: this session's own harness picks the formatter -- never
+    // dialogue.ts's formatDelta unconditionally, so a Codex session's pieces
+    // are cut with formatCodexDelta instead.
+    const formatDeltaFn = PROFILES[session.harness].formatDelta;
     // ---- the tail: from `from` (or 0 under --all) to the end of the file ----
     const from = deps.all ? 0 : Math.min(Math.max(session.from, 0), buf.length);
-    const tail = formatDelta(buf.subarray(from));
+    const tail = formatDeltaFn(buf.subarray(from));
     let previousEnd = from;
     for (const piece of tail.pieces) {
         let res;
@@ -678,7 +870,7 @@ async function sendSession(session, deps) {
         for (const span of session.spans) {
             const start = Math.min(Math.max(span.start, 0), buf.length);
             const end = Math.min(Math.max(span.end, start), buf.length);
-            const spanDelta = formatDelta(buf.subarray(start, end));
+            const spanDelta = formatDeltaFn(buf.subarray(start, end));
             let spanOk = true;
             for (const piece of spanDelta.pieces) {
                 let res;