spexcode 0.7.0-next.0 → 0.7.0-next.1

package/node_modules/@spexcode/session-application/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-application",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Adopter-owned composition of session protocol and topology transactions.",
@@ -16,10 +16,10 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-events": "0.7.0-next.0",
-    "@spexcode/session-protocol": "0.7.0-next.0",
-    "@spexcode/session-runtime": "0.7.0-next.0",
-    "@spexcode/session-topology": "0.7.0-next.0"
+    "@spexcode/session-events": "0.7.0-next.1",
+    "@spexcode/session-protocol": "0.7.0-next.1",
+    "@spexcode/session-runtime": "0.7.0-next.1",
+    "@spexcode/session-topology": "0.7.0-next.1"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/session-events/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-events",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Append-only session facts and deterministic ordered replay inputs.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.0" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.1" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/session-protocol/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-protocol",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "description": "A durable SQLite session message protocol.",
   "files": [

package/node_modules/@spexcode/session-runtime/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-runtime",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "Adopter-owned bindings between protocol addresses and native runtime identities.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.0" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.1" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/session-selflaunch/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-selflaunch",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A fail-closed self-launch adopter for the SpexCode session protocol.",
@@ -24,8 +24,8 @@
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-protocol": "0.7.0-next.0",
-    "@spexcode/session-runtime": "0.7.0-next.0"
+    "@spexcode/session-protocol": "0.7.0-next.1",
+    "@spexcode/session-runtime": "0.7.0-next.1"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/session-topology/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/session-topology",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "publishConfig": { "access": "public" },
   "type": "module",
   "description": "A neutral SQLite relation model for session addresses.",
@@ -15,7 +15,7 @@
     "prepublishOnly": "node ../../scripts/release-publish.mjs --from-package-publish",
     "test": "npm run build && tsx --import ../../scripts/test-home.mjs --test src/*.test.ts"
   },
-  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.0" },
+  "dependencies": { "@spexcode/session-protocol": "0.7.0-next.1" },
   "devDependencies": {
     "@types/node": "^20.16.0",
     "tsx": "^4.19.2",

package/node_modules/@spexcode/spec-cli/dist/sessions.js

@@ -2988,7 +2988,7 @@ async function prepareSession(prompt, parent, launcher, name, context) {
                 try {
                     gitMutationStarted = true;
                     traceSessionCreate(id, requestDigest, phase, 'start', 'worktree-add');
-                    const added = await withGitAbortSignal(signal, () => gitTry(['-C', root, 'worktree', 'add', '-b', branch, path, startPoint], { extraEnv: DEFER_FOOTPRINT_REFRESH }));
+                    const added = await withGitAbortSignal(signal, () => gitTry(['-C', root, 'worktree', 'add', '--no-track', '-b', branch, path, startPoint], { extraEnv: DEFER_FOOTPRINT_REFRESH }));
                     traceSessionCreate(id, requestDigest, phase, 'finish', 'worktree-add');
                     if (added.ok)
                         Object.assign(owned, { path: true, worktree: true, branch: true });

package/node_modules/@spexcode/spec-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-cli",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "description": "SpexCode CLI + server. The root spexcode package delegates to this compiled package; dashboard assets live in @spexcode/spec-dashboard.",
   "bin": {
@@ -35,12 +35,12 @@
     "test": "tsx --import ../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/session-application": "0.7.0-next.0",
-    "@spexcode/session-selflaunch": "0.7.0-next.0",
-    "@spexcode/spec-core": "0.7.0-next.0",
-    "@spexcode/spec-eval": "0.7.0-next.0",
-    "@spexcode/spec-forge": "0.7.0-next.0",
-    "@spexcode/transcript": "0.7.0-next.0",
+    "@spexcode/session-application": "0.7.0-next.1",
+    "@spexcode/session-selflaunch": "0.7.0-next.1",
+    "@spexcode/spec-core": "0.7.0-next.1",
+    "@spexcode/spec-eval": "0.7.0-next.1",
+    "@spexcode/spec-forge": "0.7.0-next.1",
+    "@spexcode/transcript": "0.7.0-next.1",
     "smol-toml": "^1.8.0"
   },
   "devDependencies": {

package/node_modules/@spexcode/spec-core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-core",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "description": "SpexCode's dependency-minimal spec graph core.",
   "files": [

package/node_modules/@spexcode/spec-eval/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-eval",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -26,7 +26,7 @@
     "test": "tsx --import ../scripts/test-home.mjs --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/spec-core": "0.7.0-next.0"
+    "@spexcode/spec-core": "0.7.0-next.1"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/spec-forge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/spec-forge",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "exports": {
     ".": "./dist/index.js",
@@ -22,7 +22,7 @@
     "test": "tsx --test src/*.test.ts"
   },
   "dependencies": {
-    "@spexcode/spec-core": "0.7.0-next.0"
+    "@spexcode/spec-core": "0.7.0-next.1"
   },
   "devDependencies": {
     "@types/node": "^20.16.0",

package/node_modules/@spexcode/transcript/dist/frames.d.ts

@@ -1,4 +1,6 @@
 import { type TranscriptRead, type TranscriptReader, type TranscriptTool, type TranscriptTurn } from './turns.js';
+export { TranscriptReadError } from './turns.js';
+export type { TranscriptRange, TranscriptRead, TranscriptReader, TranscriptTail, TranscriptTool, TranscriptTurn } from './turns.js';
 export type StreamTool = Readonly<Omit<TranscriptTool, 'output'> & {
     output?: null;
 }>;

package/node_modules/@spexcode/transcript/dist/frames.js

@@ -1,4 +1,6 @@
 import { TranscriptReadError } from './turns.js';
+// the browser-safe entry is complete on its own: the normalized shape travels with the frames that carry it
+export { TranscriptReadError } from './turns.js';
 export const isErrorFrame = (frame) => 'error' in frame;
 // The revision an absent source reports: the thread has not started writing. Not an error.
 export const ABSENT_REVISION = 'absent';

package/node_modules/@spexcode/transcript/dist/parsers.d.ts

@@ -28,6 +28,9 @@ export type Parse = (value: unknown) => ParsedEvent | null;
 export declare function claudeEvent(value: unknown): ParsedEvent | null;
 export declare function codexEvent(value: unknown): ParsedEvent | null;
 export declare function piEvent(value: unknown): ParsedEvent | null;
+export declare function geminiEvent(value: unknown): ParsedEvent | null;
+export declare function openclawEvent(value: unknown): ParsedEvent | null;
+export declare function hermesEvents(value: unknown): ParsedEvent[];
 export declare function opencodeEvents(value: unknown): ParsedEvent[];
 export declare class IntervalCollector {
     readonly turns: MutableTurn[];

package/node_modules/@spexcode/transcript/dist/parsers.js

@@ -51,7 +51,7 @@ const compact = (value) => {
     }
 };
 const lineCount = (value) => value ? value.split(/\r?\n/).length : 0;
-// --- the four native shapes --------------------------------------------------------------------------------
+// --- the seven native shapes -------------------------------------------------------------------------------
 export function claudeEvent(value) {
     const entry = object(value);
     const message = object(entry?.message);
@@ -154,6 +154,116 @@ export function piEvent(value) {
     }
     return null;
 }
+export function geminiEvent(value) {
+    const entry = object(value);
+    const message = (entry?.type === 'user' || entry?.type === 'gemini')
+        ? entry
+        : object(items(entry?.messages)[0]) ?? object(items(object(entry?.$set)?.messages)[0]);
+    if (!entry || !message)
+        return null;
+    const eventAt = at(message) ?? at(entry);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    const content = message.content;
+    const blocks = items(content);
+    const outputs = blocks.flatMap((blockValue) => {
+        const block = object(blockValue);
+        const response = object(block?.functionResponse);
+        const id = string(response?.id);
+        return id ? [{ id, text: compact(response?.response ?? '') }] : [];
+    });
+    if (outputs.length)
+        return { at: eventAt, turn: null, toolOutputs: outputs };
+    if (message.type === 'user') {
+        const text = typeof content === 'string' ? string(content) : blocks.map((block) => string(object(block)?.text)).filter(Boolean).join('\n') || null;
+        return text ? { at: eventAt, turn: { id: idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    if (message.type === 'gemini') {
+        const turn = { id: idOf(message), at: eventAt, role: 'assistant', tools: [] };
+        if (typeof content === 'string')
+            turn.text = string(content) ?? undefined;
+        for (const callValue of items(message.toolCalls)) {
+            const call = object(callValue);
+            const id = string(call?.id) ?? `tool-${turn.tools.length}`;
+            turn.tools.push({ id, name: string(call?.name) ?? 'tool', input: call?.args === undefined ? undefined : compact(call.args), outputLines: 0, outputBytes: 0 });
+        }
+        if (!turn.text && !turn.tools.length)
+            return null;
+        return { at: eventAt, turn };
+    }
+    return null;
+}
+export function openclawEvent(value) {
+    const entry = object(value);
+    const message = object(entry?.message);
+    if (!entry || entry.type !== 'message' || !message)
+        return null;
+    const eventAt = at(message) ?? at(entry);
+    if (eventAt === null)
+        return { at: null, turn: null };
+    if (message.role === 'user') {
+        const text = blockText(message.content);
+        return text ? { at: eventAt, turn: { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'user', text, tools: [] } } : null;
+    }
+    if (message.role === 'toolResult') {
+        const id = string(message.toolCallId);
+        return id ? { at: eventAt, turn: null, toolOutputs: [{ id, text: blockText(message.content) ?? compact(message.content ?? '') }] } : null;
+    }
+    if (message.role === 'assistant') {
+        const turn = { id: idOf(entry) ?? idOf(message), at: eventAt, role: 'assistant', tools: [] };
+        for (const blockValue of items(message.content)) {
+            const block = object(blockValue);
+            if (block?.type === 'text')
+                turn.text = [turn.text, string(block.text)].filter(Boolean).join('\n') || undefined;
+            if (block?.type === 'toolCall') {
+                const id = string(block.id) ?? `tool-${turn.tools.length}`;
+                turn.tools.push({ id, name: string(block.name) ?? 'tool', input: block.arguments === undefined ? undefined : compact(block.arguments), outputLines: 0, outputBytes: 0 });
+            }
+        }
+        return turn.text || turn.tools.length ? { at: eventAt, turn } : null;
+    }
+    return null;
+}
+export function hermesEvents(value) {
+    const root = object(value);
+    const events = [];
+    for (const messageValue of items(root?.messages)) {
+        const message = object(messageValue);
+        if (!message)
+            continue;
+        const eventAt = at(message);
+        if (eventAt === null) {
+            events.push({ at: null, turn: null });
+            continue;
+        }
+        const role = message.role;
+        if (role === 'user') {
+            const text = string(message.content);
+            if (text)
+                events.push({ at: eventAt, turn: { id: idOf(message), at: eventAt, role: 'user', text, tools: [] } });
+        }
+        else if (role === 'assistant') {
+            const turn = { id: idOf(message), at: eventAt, role: 'assistant', tools: [] };
+            const text = string(message.content);
+            if (text)
+                turn.text = text;
+            for (const callValue of items(message.tool_calls)) {
+                const call = object(callValue);
+                const fn = object(call?.function);
+                const id = string(call?.id) ?? `tool-${turn.tools.length}`;
+                turn.tools.push({ id, name: string(fn?.name) ?? 'tool', input: fn?.arguments === undefined ? undefined : compact(fn.arguments), outputLines: 0, outputBytes: 0 });
+            }
+            if (turn.text || turn.tools.length)
+                events.push({ at: eventAt, turn });
+        }
+        else if (role === 'tool') {
+            const id = string(message.tool_call_id);
+            if (id)
+                events.push({ at: eventAt, turn: null, toolOutputs: [{ id, text: compact(message.content ?? '') }] });
+        }
+    }
+    return events;
+}
 // OpenCode's export is one JSON document, not a line stream: every message arrives with its parts, and a tool
 // part already carries its own result — so its turn is complete on arrival, and a part still running simply has
 // no output yet.

package/node_modules/@spexcode/transcript/dist/readers.d.ts

@@ -2,9 +2,15 @@ import { type TranscriptReader } from './turns.js';
 export declare function claudeTranscriptPath(threadId: string, root?: string): string | null;
 export declare function codexRolloutPath(threadId: string, root?: string): string | null;
 export declare function piSessionPath(threadId: string, root?: string): string | null;
+export declare function geminiTranscriptPath(threadId: string, root?: string): string | null;
+export declare function openclawTranscriptPath(threadId: string, root?: string): string | null;
 export declare const claudeTranscript: TranscriptReader;
 export declare const codexTranscript: TranscriptReader;
 export declare const piTranscript: TranscriptReader;
+export declare const geminiTranscript: TranscriptReader;
+export declare const openclawTranscript: TranscriptReader;
 export declare function opencodeTranscriptReader(root?: string, load?: (threadId: string) => string): TranscriptReader;
 export declare const opencodeTranscript: TranscriptReader;
+export declare function hermesTranscriptReader(root?: string, load?: (threadId: string) => string): TranscriptReader;
+export declare const hermesTranscript: TranscriptReader;
 export declare function unsupportedTranscript(harness: string): TranscriptReader;

package/node_modules/@spexcode/transcript/dist/readers.js

@@ -3,7 +3,7 @@ import { closeSync, openSync, readFileSync, readSync, readdirSync, statSync } fr
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 import { TranscriptReadError } from './turns.js';
-import { IntervalCollector, claudeEvent, codexEvent, opencodeEvents, piEvent } from './parsers.js';
+import { IntervalCollector, claudeEvent, codexEvent, geminiEvent, hermesEvents, openclawEvent, opencodeEvents, piEvent } from './parsers.js';
 // THE NATIVE-THREAD READERS. Each harness keeps its conversation somewhere private — Claude's project JSONL,
 // Codex's rollout, pi's session JSONL, OpenCode's store behind `opencode export` — and this module is the only
 // place that knows where. It answers exactly one question for every harness: "what happened in this thread
@@ -72,6 +72,36 @@ export function piSessionPath(threadId, root = piSessionsRoot()) {
         }
     return null;
 }
+const findJsonl = (root, threadId, maxDepth = 5) => {
+    const walk = (dir, depth) => {
+        if (depth > maxDepth)
+            return null;
+        for (const name of children(dir)) {
+            const path = join(dir, name);
+            try {
+                if (statSync(path).isFile() && name.endsWith('.jsonl')) {
+                    if (name.includes(threadId))
+                        return path;
+                    const header = JSON.parse(readFileSync(path, 'utf8').split('\n', 1)[0]);
+                    if (header.sessionId === threadId || header.id === threadId)
+                        return path;
+                }
+                else if (statSync(path).isDirectory()) {
+                    const found = walk(path, depth + 1);
+                    if (found)
+                        return found;
+                }
+            }
+            catch { /* skip entries that disappear or are not JSON */ }
+        }
+        return null;
+    };
+    return walk(root, 0);
+};
+const geminiRoot = () => process.env.GEMINI_HOME || process.env.GEMINI_CONFIG_DIR || join(homedir(), '.gemini');
+export function geminiTranscriptPath(threadId, root = geminiRoot()) { return findJsonl(root, threadId); }
+const openclawRoot = () => process.env.OPENCLAW_STATE_DIR || join(homedir(), '.openclaw', 'state');
+export function openclawTranscriptPath(threadId, root = openclawRoot()) { return findJsonl(root, threadId); }
 const opencodeStoreRoot = () => process.env.SPEXCODE_OPENCODE_DATA_DIR
     || join(process.env.XDG_DATA_HOME || join(homedir(), '.local', 'share'), 'opencode');
 function opencodeStoreRevision(root) {
@@ -243,6 +273,8 @@ function lineFileReader(harness, locate, parse) {
 export const claudeTranscript = lineFileReader('claude', (threadId) => claudeTranscriptPath(threadId), claudeEvent);
 export const codexTranscript = lineFileReader('codex', (threadId) => codexRolloutPath(threadId), codexEvent);
 export const piTranscript = lineFileReader('pi', (threadId) => piSessionPath(threadId), piEvent);
+export const geminiTranscript = lineFileReader('gemini', (threadId) => geminiTranscriptPath(threadId), geminiEvent);
+export const openclawTranscript = lineFileReader('openclaw', (threadId) => openclawTranscriptPath(threadId), openclawEvent);
 // OpenCode has no per-thread file: the store's revision is the change token, and one export per
 // revision is parsed and kept, so repeated interval reads of a quiet thread cost nothing new.
 const opencodeExports = new Map();
@@ -286,6 +318,53 @@ export function opencodeTranscriptReader(root = opencodeStoreRoot(), load = open
     };
 }
 export const opencodeTranscript = opencodeTranscriptReader();
+const hermesRoot = () => process.env.HERMES_HOME || join(homedir(), '.hermes', 'profiles', 'default');
+function hermesRevision(root) {
+    try {
+        const stat = statSync(join(root, 'state.db'));
+        return `${stat.size}:${Math.floor(stat.mtimeMs)}`;
+    }
+    catch {
+        return null;
+    }
+}
+function hermesExport(threadId) {
+    return execFileSync(process.env.SPEXCODE_HERMES_CMD || 'hermes', ['sessions', 'export', '--format', 'jsonl', '--session-id', threadId, '--yes'], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });
+}
+const hermesExports = new Map();
+export function hermesTranscriptReader(root = hermesRoot(), load = hermesExport) {
+    const read = async (threadId, range) => {
+        const revision = hermesRevision(root);
+        if (!revision)
+            throw new TranscriptReadError('missing', `hermes transcript for ${threadId} is unavailable: state.db was not found`);
+        const key = `${root}:${threadId}`;
+        let cached = hermesExports.get(key);
+        if (!cached || cached.revision !== revision) {
+            let exported;
+            try {
+                exported = load(threadId);
+            }
+            catch (error) {
+                throw new TranscriptReadError('unreadable', `hermes transcript could not be exported: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            let value;
+            try {
+                value = JSON.parse(exported);
+            }
+            catch (error) {
+                throw new TranscriptReadError('invalid', `hermes transcript cannot be parsed: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            cached = { revision, events: hermesEvents(value) };
+            hermesExports.set(key, cached);
+        }
+        const collector = new IntervalCollector(range);
+        for (const event of cached.events)
+            collector.add(event);
+        return collector.finish(revision, 'hermes');
+    };
+    return { revision: () => hermesRevision(root), read, tail: (threadId, from) => ({ advance: (to) => read(threadId, { from, to }), close: () => { } }) };
+}
+export const hermesTranscript = hermesTranscriptReader();
 export function unsupportedTranscript(harness) {
     const refuse = async () => { throw new TranscriptReadError('unsupported', `${harness} does not support transcript access`); };
     return {

package/node_modules/@spexcode/transcript/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@spexcode/transcript",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "description": "Normalized agent transcripts: one parser per harness, a bounded interval reader over a native thread file or an in-memory event stream, and the full/delta frame protocol every transport and renderer share.",
   "files": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spexcode",
-  "version": "0.7.0-next.0",
+  "version": "0.7.0-next.1",
   "type": "module",
   "description": "SpexCode — a spec-driven, self-developing dev tool. The `spex` CLI + spec server reads the .spec tree and its git history, and serves the dashboard.",
   "license": "MIT",
@@ -44,7 +44,7 @@
     "prepack": "node scripts/sync-init-plugins.mjs --check && node scripts/prepack.mjs"
   },
   "dependencies": {
-    "@spexcode/spec-cli": "0.7.0-next.0"
+    "@spexcode/spec-cli": "0.7.0-next.1"
   },
   "publishConfig": {
     "access": "public"