gipity 1.0.429 → 1.1.2

package/README.md

@@ -2,13 +2,13 @@
 
 The full-stack platform tuned for AI agents.
 
-[Gipity](https://gipity.ai) is the platform: hosting, databases, file storage, deployment, workflows, code execution, and monitoring. Agent-tuned from idea to deploy. Use standalone, or pair with Claude Code to give your local agent cloud superpowers. Any model, any infra, always your code.
+[Gipity](https://gipity.ai) is the platform: hosting, databases, file storage, deployment, workflows, code execution, and monitoring. Agent-tuned from idea to deploy. Use standalone, or pair with your coding agent - Claude Code, Codex, or Grok - to give it cloud superpowers. Any model, any infra, always your code.
 
-This CLI connects [Claude Code](https://claude.ai/claude-code) to Gipity's cloud platform - databases, deployment, browser testing, image gen, and 50+ other capabilities your local agent doesn't have. It also syncs files so Claude Code and the Gipity web agent share the same project.
+This CLI connects your coding agent - [Claude Code](https://claude.ai/claude-code), Codex, or Grok - to Gipity's cloud platform: databases, deployment, browser testing, image gen, and 50+ other capabilities your local agent doesn't have. It also syncs files so your local agent and the Gipity web agent share the same project.
 
 ## Getting Started
 
-One line installs everything. It sets up Node 18+ (if you don't already have it) and the Gipity CLI, with no sudo required:
+**Step 1 - install.** One line installs everything. It sets up Node 18+ (if you don't already have it) and the Gipity CLI, with no sudo required:
 
 ```bash
 # macOS / Linux / WSL
@@ -18,13 +18,42 @@ curl -fsSL https://gipity.ai/install.sh | bash
 irm https://gipity.ai/install.ps1 | iex
 ```
 
-Then launch your coding agent wired into Gipity:
+**Step 2 - pick your path.** There are three, and they mix freely:
+
+| You want to... | Run |
+|----------------|-----|
+| Start building right now, from anywhere | `gipity build` |
+| Use your own workflow in your own directory | `gipity init`, then `claude` / `codex` / `grok` |
+| Drive this computer from gipity.ai (phone, browser) | `gipity connect` |
+
+### `gipity build` - start from anywhere
+
+One command does everything: logs you in (6-digit email code), lets you pick or create a project, lets you pick your coding agent (Claude Code, Codex, or Grok - it installs the agent if needed), and launches it with the whole Gipity stack wired up.
 
 ```bash
-gipity claude
+gipity build
 ```
 
-`gipity claude` walks you through login, project setup, and launches Claude Code. Using Codex, Gemini, or Cursor instead? Run `gipity init`.
+### `gipity init` - bring your own workflow
+
+Prefer launching your agent yourself? From any project directory:
+
+```bash
+gipity init
+claude        # or codex, or grok - whatever you use
+```
+
+`init` links the directory to a Gipity project, writes CLAUDE.md/AGENTS.md primers so your agent understands Gipity, and installs the Gipity skills + file-sync hooks into the agent CLIs found on your machine (Claude Code, Codex, Grok; Cursor and Gemini get primer files too).
+
+### `gipity connect` - drive it from the web
+
+Want to start chats from gipity.ai (including your phone) and have them run the coding agent on this computer? Connect it once:
+
+```bash
+gipity connect
+```
+
+It logs you in, pairs the machine, starts the Gipity relay in the background, and installs the login service so it survives reboots - then stops, without launching anything. From then on, open gipity.ai and start a chat to drive your agent here. Manage it with `gipity relay status` / `pause` / `resume` / `revoke`.
 
 ### Prefer npm
 
@@ -47,15 +76,7 @@ gipity update   # force an immediate update now
 
 To opt out: `export DISABLE_AUTOUPDATER=1` (matches Claude Code), or set `{ "autoUpdates": false }` in `~/.gipity/settings.json`. CI environments are auto-detected and skipped.
 
-## Quick Start
-
-One command. It walks you through login, project setup, and drops you into Claude Code.
-
-```bash
-gipity claude --dangerously-skip-permissions
-```
-
-That's it. You'll see:
+## What `gipity build` looks like
 
 ```
   Welcome to Gipity
@@ -72,16 +93,29 @@ That's it. You'll see:
     2. Create new project
 
   Choose (1-2): 2
-  Project name [project01]: cool-app
+  Project name [project-001]: cool-app
   Creating "cool-app"...
   Created.
 
-  Launching Claude Code...
+  Which coding agent?
+    1. Claude Code (Anthropic)
+    2. Codex (OpenAI)
+    3. Grok (xAI)
+
+  Launching Claude Code, powered by Gipity.
 ```
 
-If you're already logged in, it skips straight to project setup. If you already have a project in the current directory, it skips straight to launching Claude Code.
+If you're already logged in, it skips straight to the project picker. If you're already inside a Gipity project directory, it uses that project. Your last-used agent is the default next time.
+
+Projects live in `~/GipityProjects/{project-slug}/` - created automatically on first use. Any extra flags (like `--model opus`) pass straight through to the agent. Useful flags:
 
-Projects live in `~/GipityProjects/{project-slug}/` - created automatically on first use. Any extra flags (like `--dangerously-skip-permissions`, `--model opus`, etc.) get passed through to Claude.
+```bash
+gipity build --agent codex             # Skip the agent picker
+gipity build --new-project --name app  # Create a fresh project without the picker
+gipity build --project my-app          # Open a specific project
+gipity build --here                    # Use the current directory, not ~/GipityProjects/
+gipity build -p "add a contact form"   # Headless one-shot (no interactive session)
+```
 
 ### The manual way
 
@@ -92,26 +126,28 @@ gipity login --email you@example.com
 gipity login --code 123456
 cd my-project
 gipity init
-claude
+claude        # or codex, or grok
 ```
 
-## Claude Code Integration
+## Coding Agent Integration
+
+This is the good part. When you run `gipity init` (or `gipity build`) in a project, it wires two hooks into your agent (Claude Code, Codex, and Grok all get them):
 
-This is the good part. When you run `gipity init` in a project, it sets up two hooks in `.claude/settings.json`:
+**Auto-push** - Every time your agent writes or edits a file, it gets pushed to Gipity in the background. No extra steps.
 
-**Auto-push** - Every time Claude Code writes or edits a file, it gets pushed to Gipity in the background. No extra steps.
+**Auto-pull** - Before each turn, your agent pulls any changes that happened remotely (like if your Gipity agent built something via chat). It sees what changed and can pick up where things left off.
 
-**Auto-pull** - Before each turn, Claude Code pulls any changes that happened remotely (like if your Gipity agent built something via chat). Claude sees what changed and can pick up where things left off.
+That means your local agent and your Gipity agent share the same files, same project, same context. You get the best of both - hands-on coding locally, autonomous agent work on Gipity.
 
-That means Claude Code and your Gipity agent share the same files, same project, same context. You get the best of both - Claude Code for hands-on coding, Gipity for autonomous agent work.
+Sessions are also recorded to your Gipity project so you can watch them live at prompt.gipity.ai. Opt out per project with `gipity init --no-capture`.
 
 ### What gets set up
 
 ```
 .gipity.json          # Project config (which project, which agent)
 .gipity/              # Local sync state (gitignored)
-.claude/settings.json # Hooks for auto-push and auto-pull
-CLAUDE.md             # Gipity commands reference for Claude Code
+.claude/settings.json # Hooks for auto-push and auto-pull (per-agent equivalents for Codex/Grok)
+CLAUDE.md / AGENTS.md # Gipity commands reference for your agent
 ```
 
 ### Manual sync
@@ -128,9 +164,11 @@ gipity sync down     # Pull remote changes
 
 | Command | What it does |
 |---------|-------------|
-| `gipity claude` | Log in, pick a project, and launch Claude Code - all in one |
+| `gipity build` | Log in, pick a project, pick your coding agent, and launch it - all in one |
+| `gipity init` | Link this directory to a project and set up your coding agent |
+| `gipity connect` | Connect this computer to gipity.ai so the web CLI can drive it |
+| `gipity relay` | Manage the relay (status, pause, resume, revoke) |
 | `gipity login` | Authenticate with email + verification code |
-| `gipity init` | Set up a Gipity project and configure Claude Code |
 | `gipity status` | Show project, agent, and auth info |
 | `gipity sync` | Sync files between local and Gipity |
 | `gipity push <file>` | Push a single file |

package/dist/agents/claude-code.js

@@ -0,0 +1,48 @@
+import { ensureClaudeInstalled, CLAUDE_PACKAGE } from '../claude-setup.js';
+export const claudeCodeAdapter = {
+    key: 'claude',
+    source: 'claude_code',
+    displayName: 'Claude Code',
+    providerName: 'Anthropic',
+    binary: 'claude',
+    buildInteractiveArgs({ resume, model }) {
+        const args = [];
+        if (model)
+            args.push('--model', model);
+        if (resume)
+            args.push('--resume', resume);
+        return args;
+    },
+    buildHeadlessArgs({ message, resume, model, bypassApprovals, jsonStream }) {
+        const args = ['-p', message];
+        if (bypassApprovals)
+            args.push('--permission-mode', 'bypassPermissions');
+        if (model)
+            args.push('--model', model);
+        if (resume)
+            args.push('--resume', resume);
+        // `--verbose` is required by Claude Code when combining -p with
+        // --output-format stream-json; partial messages feed live typing.
+        if (jsonStream)
+            args.push('--output-format', 'stream-json', '--verbose', '--include-partial-messages');
+        return args;
+    },
+    sessionIdFromStreamEvent(event) {
+        // Claude's stream-json: the system/init event (and the result footer)
+        // carry `session_id`.
+        if (event && typeof event.session_id === 'string' && event.session_id)
+            return event.session_id;
+        return null;
+    },
+    hooksSupportedOnPlatform() {
+        return true;
+    },
+    // The daemon parses Claude's stream-json into ingest entries itself
+    // (hook capture stands down via GIPITY_CAPTURE=off on dispatches).
+    daemonStreamCapture: true,
+    ensureInstalled() {
+        return ensureClaudeInstalled().installed;
+    },
+    installHint: `npm install -g ${CLAUDE_PACKAGE}`,
+};
+//# sourceMappingURL=claude-code.js.map

package/dist/agents/codex.js

@@ -0,0 +1,45 @@
+export const codexAdapter = {
+    key: 'codex',
+    source: 'codex',
+    displayName: 'Codex',
+    providerName: 'OpenAI',
+    binary: 'codex',
+    buildInteractiveArgs({ resume, model }) {
+        const args = [];
+        if (model)
+            args.push('--model', model);
+        if (resume)
+            args.push('resume', resume);
+        return args;
+    },
+    buildHeadlessArgs({ message, resume, model, bypassApprovals, jsonStream }) {
+        // `codex exec resume <sid> "<msg>"` continues a session; plain
+        // `codex exec "<msg>"` starts fresh. Flags are shared by both forms.
+        const args = resume ? ['exec', 'resume', resume, message] : ['exec', message];
+        if (model)
+            args.push('--model', model);
+        if (bypassApprovals) {
+            args.push('-s', 'workspace-write', '-c', 'sandbox_workspace_write.network_access=true', '--dangerously-bypass-hook-trust', '--skip-git-repo-check');
+        }
+        if (jsonStream)
+            args.push('--json');
+        return args;
+    },
+    sessionIdFromStreamEvent(event) {
+        // `codex exec --json`: the thread.started event carries thread_id.
+        if (event?.type === 'thread.started' && typeof event.thread_id === 'string') {
+            return event.thread_id;
+        }
+        return null;
+    },
+    hooksSupportedOnPlatform(platform) {
+        return platform !== 'win32'; // Codex hooks are disabled on Windows
+    },
+    // No stream-json ingest mapper for Codex: relay dispatches keep hook
+    // capture ON (GIPITY_CONVERSATION_GUID binds it) and the transcript
+    // parser mirrors the session; the daemon tracks byte-level progress only.
+    daemonStreamCapture: false,
+    oneTimeSetupNote: 'Codex runs project hooks only after a one-time approval: run /hooks inside Codex and approve the Gipity entries, or session recording stays off.',
+    installHint: 'npm install -g @openai/codex',
+};
+//# sourceMappingURL=codex.js.map

package/dist/agents/grok.js

@@ -0,0 +1,50 @@
+export const grokAdapter = {
+    key: 'grok',
+    source: 'grok',
+    displayName: 'Grok',
+    providerName: 'xAI',
+    binary: 'grok',
+    buildInteractiveArgs({ resume, model }) {
+        const args = [];
+        if (model)
+            args.push('--model', model);
+        if (resume)
+            args.push('--resume', resume);
+        return args;
+    },
+    buildHeadlessArgs({ message, resume, model, bypassApprovals, jsonStream }) {
+        const args = ['-p', message];
+        if (model)
+            args.push('--model', model);
+        if (resume)
+            args.push('--resume', resume);
+        if (bypassApprovals)
+            args.push('--always-approve');
+        if (jsonStream)
+            args.push('--output-format', 'streaming-json');
+        return args;
+    },
+    sessionIdFromStreamEvent(event) {
+        // Grok's streaming-json is ACP-shaped: session/update notifications
+        // carry params.sessionId. Accept a top-level sessionId too, defensively.
+        const fromParams = event?.params?.sessionId;
+        if (typeof fromParams === 'string' && fromParams)
+            return fromParams;
+        if (typeof event?.sessionId === 'string' && event.sessionId)
+            return event.sessionId;
+        return null;
+    },
+    hooksSupportedOnPlatform() {
+        return true; // in the interactive TUI; headless runs use headlessCapture
+    },
+    daemonStreamCapture: false,
+    // Verified live (2026-07-13): grok -p fires NO plugin hooks - not even
+    // SessionStart/Stop - so headless capture is launcher-driven: pin the
+    // session id, then replay ~/.grok/sessions/<cwd>/<sid>/chat_history.jsonl
+    // through the capture runner after the run.
+    headlessCapture: {
+        sessionIdArgs: (sessionId) => ['--session-id', sessionId],
+    },
+    installHint: 'curl -fsSL https://grok.x.ai/install.sh | sh   (or see docs.x.ai/grok-build)',
+};
+//# sourceMappingURL=grok.js.map

package/dist/agents/index.js

@@ -0,0 +1,23 @@
+import { claudeCodeAdapter } from './claude-code.js';
+import { codexAdapter } from './codex.js';
+import { grokAdapter } from './grok.js';
+/** Picker/help order: Claude first (the default), then the others. */
+export const AGENT_ADAPTERS = [
+    claudeCodeAdapter,
+    codexAdapter,
+    grokAdapter,
+];
+export const AGENT_KEYS = AGENT_ADAPTERS.map(a => a.key);
+export function getAdapter(key) {
+    const found = AGENT_ADAPTERS.find(a => a.key === key);
+    if (!found)
+        throw new Error(`Unknown agent "${key}". Valid: ${AGENT_KEYS.join(', ')}`);
+    return found;
+}
+export function getAdapterBySource(source) {
+    const found = AGENT_ADAPTERS.find(a => a.source === source);
+    if (!found)
+        throw new Error(`No agent adapter for source "${source}"`);
+    return found;
+}
+//# sourceMappingURL=index.js.map

package/dist/agents/types.js

@@ -0,0 +1,18 @@
+/**
+ * RemoteAgentAdapter - the one abstraction between Gipity and a local coding
+ * agent's EXECUTION surface (argv shapes, flags, stream schema). Everything
+ * data-side is already agent-agnostic: conversations carry a `source`
+ * discriminator, capture has a per-source parser registry
+ * (cli/src/hooks/capture-runner.ts CAPTURE_SOURCES), and the DAL/routes are
+ * parameterized. The adapter covers what a `source` string alone can't:
+ *
+ *   - how to launch the agent binary (interactive and headless)
+ *   - how to resume a session, pick a model, bypass approvals
+ *   - how to spot the session id in the agent's output stream
+ *
+ * Two consumers: the `gipity build` launcher (interactive + `-p`) and the
+ * relay daemon (web-CLI dispatch). Adding an agent = one file here + one
+ * capture parser + one REMOTE_TYPES value; no scattered `if (source === …)`.
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/api.js

@@ -56,8 +56,8 @@ async function bearerToken() {
 /** True when a long-lived agent API token (GIPITY_TOKEN) is in play. Such a token
  *  is static — it can't be refreshed — so the 401 self-heal path must skip it and
  *  the "run: gipity login" hint must not be shown (that's the wrong recovery for
- *  env-token callers). */
-function usingEnvToken() {
+ *  env-token callers). Exported so `gipity status` can name the auth source. */
+export function usingEnvToken() {
     return !!process.env.GIPITY_TOKEN?.trim();
 }
 // A transient 401 on a session token means the access token the server just saw
@@ -83,9 +83,12 @@ async function shouldRetryAfter401(status, retried) {
 /** Append a re-login hint to a 401 message for session users. A 401 that
  *  survived the refresh-and-retry is an unrecoverable session (the refresh token
  *  is gone too); env-token callers authenticate differently, so don't misdirect
- *  them. */
+ *  them. Names the headless path too — an unattended agent has no mailbox for
+ *  the emailed login code, and dead-ending there stranded whole runs (cli#137). */
 function with401Hint(status, message) {
-    return status === 401 && !usingEnvToken() ? `${message} — run: gipity login` : message;
+    return status === 401 && !usingEnvToken()
+        ? `${message} — run: gipity login (headless/CI: set GIPITY_TOKEN instead — gipity skill read agent-deploy)`
+        : message;
 }
 async function getHeaders() {
     return {
@@ -195,6 +198,13 @@ export async function sendMessage(message) {
     if (res.data.conversationGuid !== config.conversationGuid) {
         saveConfig({ ...config, conversationGuid: res.data.conversationGuid });
     }
+    // The server's cost-consent gate stops the agentic loop on big-build
+    // requests and returns an explicit costWarning with empty content. Surface
+    // it - before this the CLI printed nothing and the command silently did
+    // nothing. Replying "y" (next sendMessage) consents and proceeds.
+    if (res.data.costWarning && !res.data.content) {
+        return res.data.costWarning.message;
+    }
     return res.data.content;
 }
 /** Download a file as raw bytes (no JSON parsing) */

package/dist/capture/sources/codex.js

@@ -0,0 +1,216 @@
+/**
+ * Codex rollout JSONL transcript → ingest entries.
+ *
+ * Codex writes one JSON object per line to
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<session_id>.jsonl
+ * and every hook payload carries `transcript_path` pointing at that file.
+ *
+ * IMPORTANT: the rollout format is NOT the `codex exec --json` stream schema
+ * (no `thread.started` / `item.*` events). Verified against real files
+ * (Codex CLI v0.144.1, 2026-07-13); each line is an envelope:
+ *
+ *   { timestamp: ISO, type: <envelope>, payload: {...} }
+ *
+ * Envelope types and how we map them:
+ *   - session_meta   → carries payload.session_id + cwd; read the session id,
+ *                      emit nothing (the runner's SessionStart handler posts
+ *                      the attach entry).
+ *   - response_item  → the conversation itself (OpenAI Responses API items):
+ *       payload.type 'message', role 'assistant' → assistant entry (has a
+ *         stable `id` (msg_…) and a `phase`: 'commentary' | 'final_answer' -
+ *         both are real assistant output, keep both).
+ *       payload.type 'message', role 'user' | 'developer' → SKIP. Codex
+ *         injects instructions and environment context as user/developer
+ *         messages; the clean prompt arrives as an event_msg user_message.
+ *       payload.type 'custom_tool_call' | 'function_call' → tool_use entry,
+ *         keyed by the stable `call_id`.
+ *       payload.type 'custom_tool_call_output' | 'function_call_output' →
+ *         tool_result entry paired by `call_id`.
+ *       payload.type 'reasoning' → SKIP (parity with the Claude parser).
+ *   - event_msg      → lifecycle/dup stream:
+ *       payload.type 'user_message' → prompt entry (the clean user text).
+ *       payload.type 'error' → system entry.
+ *       everything else ('agent_message' duplicates the assistant
+ *       response_item, 'token_count', 'task_started', 'task_complete') → SKIP.
+ *   - turn_context / world_state → SKIP.
+ *
+ * Dedup/watermark: rollout lines carry no per-line uuid, so we synthesize.
+ * Entries prefer STABLE payload ids (assistant `msg_…` id, tool `call_id`) so
+ * a resumed session whose new rollout file replays history still dedupes
+ * across files; id-less entries (prompts) fall back to a positional
+ * `<session_id>#<lineIndex>` uuid. The WATERMARK is always positional
+ * (`<session_id>#<lineIndex>`): if the file rotated or the session id
+ * changed, the caller replays from the top and the server's source_uuid
+ * unique index collapses anything already forwarded.
+ */
+/** Join Responses-API content blocks ({type:'output_text'|'input_text'|'text', text}) */
+function joinBlocks(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const b of content) {
+        if (b && typeof b.text === 'string')
+            parts.push(b.text);
+    }
+    return parts.join('\n');
+}
+function positional(sessionId, idx) {
+    return `${sessionId}#${idx}`;
+}
+/** Parse `afterUuid` back into a line index IF it belongs to this session's
+ *  positional scheme. Returns null for foreign/absent watermarks. */
+function watermarkIndex(afterUuid, sessionId) {
+    if (!afterUuid || !sessionId)
+        return null;
+    const prefix = `${sessionId}#`;
+    if (!afterUuid.startsWith(prefix))
+        return null;
+    const idx = parseInt(afterUuid.slice(prefix.length), 10);
+    return Number.isInteger(idx) && idx >= 0 ? idx : null;
+}
+function lineToEntries(parsed, sessionId, idx, toolNames) {
+    const ts = typeof parsed?.timestamp === 'string' ? parsed.timestamp : undefined;
+    const payload = parsed?.payload;
+    if (!payload || typeof payload !== 'object')
+        return [];
+    if (parsed.type === 'response_item') {
+        const ptype = payload.type;
+        if (ptype === 'message' && payload.role === 'assistant') {
+            const text = joinBlocks(payload.content);
+            const blocks = [{ type: 'text', text }];
+            return [{
+                    kind: 'assistant',
+                    text,
+                    blocks,
+                    source_uuid: typeof payload.id === 'string' && payload.id ? payload.id : positional(sessionId, idx),
+                    ...(ts ? { ts } : {}),
+                }];
+        }
+        if (ptype === 'custom_tool_call' || ptype === 'function_call') {
+            const callId = typeof payload.call_id === 'string' ? payload.call_id : positional(sessionId, idx);
+            const toolName = typeof payload.name === 'string' && payload.name ? payload.name : 'tool';
+            toolNames.set(callId, toolName);
+            // custom_tool_call carries `input` (string); function_call carries
+            // `arguments` (JSON string). Surface parsed JSON when it parses.
+            let toolInput = payload.input ?? payload.arguments ?? null;
+            if (typeof toolInput === 'string') {
+                try {
+                    toolInput = JSON.parse(toolInput);
+                }
+                catch { /* keep raw string */ }
+            }
+            return [{
+                    kind: 'tool_use',
+                    tool_use_id: callId,
+                    tool_name: toolName,
+                    tool_input: toolInput,
+                    source_uuid: callId,
+                    ...(ts ? { ts } : {}),
+                }];
+        }
+        if (ptype === 'custom_tool_call_output' || ptype === 'function_call_output') {
+            const callId = typeof payload.call_id === 'string' ? payload.call_id : positional(sessionId, idx);
+            return [{
+                    kind: 'tool_result',
+                    tool_use_id: callId,
+                    tool_name: toolNames.get(callId),
+                    content: joinBlocks(payload.output) || (typeof payload.output === 'string' ? payload.output : null),
+                    source_uuid: `${callId}#out`,
+                    ...(ts ? { ts } : {}),
+                }];
+        }
+        return []; // user/developer messages, reasoning, anything unknown
+    }
+    if (parsed.type === 'event_msg') {
+        if (payload.type === 'user_message' && typeof payload.message === 'string' && payload.message) {
+            return [{
+                    kind: 'prompt',
+                    prompt: payload.message,
+                    source_uuid: positional(sessionId, idx),
+                    ...(ts ? { ts } : {}),
+                }];
+        }
+        if (payload.type === 'error') {
+            const msg = typeof payload.message === 'string' ? payload.message : JSON.stringify(payload);
+            return [{
+                    kind: 'system',
+                    content: `Codex error: ${msg}`,
+                    source_uuid: positional(sessionId, idx),
+                    ...(ts ? { ts } : {}),
+                }];
+        }
+        return [];
+    }
+    return []; // session_meta, turn_context, world_state, unknown envelopes
+}
+/** Parse the full rollout JSONL and emit every ingest entry that comes
+ *  *after* the positional watermark `afterUuid`. Same contract as the
+ *  claude-code parser: returns entries in order, the new watermark, and
+ *  whether the old watermark was still valid for this file. */
+export function parseTranscript(content, afterUuid) {
+    const lines = content.split('\n');
+    // The session id lives in the first session_meta line. Without it we can
+    // still parse - positional uuids just key off an empty session id, and the
+    // stable payload ids carry dedup.
+    let sessionId = '';
+    for (const raw of lines) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed?.type === 'session_meta' && typeof parsed.payload?.session_id === 'string') {
+                sessionId = parsed.payload.session_id;
+            }
+        }
+        catch { /* not JSON - keep looking */ }
+        break; // only the first non-empty line can be session_meta
+    }
+    // A watermark pointing past EOF means the file was replaced by a SHORTER
+    // one under the same session id (a resume writes a fresh rollout; the old
+    // state file still carries the old file's position). Treat it as not-found
+    // so the caller replays from the top - otherwise every line of the new
+    // file sits "before" the watermark and capture wedges silently forever.
+    let startAfter = watermarkIndex(afterUuid, sessionId);
+    if (startAfter !== null && startAfter >= lines.length)
+        startAfter = null;
+    const foundWatermark = afterUuid === null || startAfter !== null;
+    const out = [];
+    const toolNames = new Map();
+    let lastIdx = startAfter;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (!line)
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (startAfter !== null && i <= startAfter) {
+            // Pre-watermark: record tool names only, so a post-watermark
+            // tool_result still resolves the name of an already-forwarded call.
+            const p = parsed?.payload;
+            if (parsed?.type === 'response_item' && p &&
+                (p.type === 'custom_tool_call' || p.type === 'function_call') &&
+                typeof p.call_id === 'string') {
+                toolNames.set(p.call_id, typeof p.name === 'string' && p.name ? p.name : 'tool');
+            }
+            continue;
+        }
+        const entries = lineToEntries(parsed, sessionId, i, toolNames);
+        for (const e of entries)
+            out.push(e);
+        lastIdx = i;
+    }
+    return {
+        entries: out,
+        lastUuid: lastIdx === null ? afterUuid : positional(sessionId, lastIdx),
+        foundWatermark,
+    };
+}
+//# sourceMappingURL=codex.js.map