gipity 1.0.428 → 1.1.1

package/dist/agents/claude-code.js

@@ -0,0 +1,53 @@
+import { ensureClaudeInstalled, CLAUDE_PACKAGE } from '../claude-setup.js';
+export const claudeCodeAdapter = {
+    key: 'claude',
+    source: 'claude_code',
+    displayName: 'Claude Code',
+    providerName: 'Anthropic',
+    binary: 'claude',
+    models: [
+        { id: 'opus', label: 'Opus' },
+        { id: 'sonnet', label: 'Sonnet' },
+        { id: 'haiku', label: 'Haiku' },
+    ],
+    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,49 @@
+export const codexAdapter = {
+    key: 'codex',
+    source: 'codex',
+    displayName: 'Codex',
+    providerName: 'OpenAI',
+    binary: 'codex',
+    models: [
+        { id: 'gpt-5.1-codex', label: 'GPT-5.1 Codex' },
+        { id: 'gpt-5.1-codex-mini', label: 'GPT-5.1 Codex Mini' },
+    ],
+    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,54 @@
+export const grokAdapter = {
+    key: 'grok',
+    source: 'grok',
+    displayName: 'Grok',
+    providerName: 'xAI',
+    binary: 'grok',
+    models: [
+        { id: 'grok-4.5', label: 'Grok 4.5' },
+        { id: 'grok-code', label: 'Grok Code' },
+    ],
+    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

@@ -195,6 +195,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

package/dist/capture/sources/grok.js

@@ -0,0 +1,178 @@
+/**
+ * Grok Build chat_history.jsonl transcript → ingest entries.
+ *
+ * Grok Build persists each session under
+ *   ~/.grok/sessions/<urlencoded-cwd>/<session_id>/
+ * with several files; `chat_history.jsonl` is the clean one-message-per-line
+ * conversation log and our parse target (events.jsonl is lifecycle noise,
+ * updates.jsonl is a chunked ACP stream). Verified against real sessions
+ * (Grok Build / grok-4.5, 2026-07-13). Line shapes:
+ *
+ *   { type: 'system',      content }                          → SKIP (system prompt)
+ *   { type: 'user',        content, synthetic_reason?, prompt_index? }
+ *       synthetic_reason present → SKIP (injected context, not the user)
+ *       else → prompt entry
+ *   { type: 'assistant',   content, tool_calls?: [{id,name,arguments}],
+ *                          model_id?, reasoning_effort? }     → assistant (+ tool_use per call)
+ *   { type: 'tool_result', tool_call_id, content }            → tool_result
+ *   { type: 'reasoning',   encrypted_content, summary }       → SKIP (parity with Claude parser)
+ *
+ * Grok hook payloads may not carry a transcript path; the capture runner
+ * derives it from the hook's cwd + session_id
+ * (`~/.grok/sessions/<encodeURIComponent(cwd)>/<session_id>/chat_history.jsonl`).
+ *
+ * Dedup/watermark: chat_history lines carry no uuid or timestamp, so uuids
+ * are synthesized. tool_use/tool_result key off the stable `tool_calls[].id`
+ * (`call-<uuid>-N`), which survives file rewrites; assistant/prompt entries
+ * use positional `<session_id>#<lineIndex>` uuids. The watermark is
+ * positional; a foreign watermark (session id mismatch / rotated file) makes
+ * the caller replay from the top, and the server's source_uuid unique index
+ * collapses anything already forwarded.
+ */
+function positional(sessionId, idx) {
+    return `${sessionId}#${idx}`;
+}
+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 contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        // Defensive: some harness versions may block-structure content.
+        const parts = [];
+        for (const b of content) {
+            if (b && typeof b.text === 'string')
+                parts.push(b.text);
+        }
+        return parts.join('\n');
+    }
+    return '';
+}
+function lineToEntries(parsed, sessionId, idx, toolNames) {
+    if (!parsed || typeof parsed !== 'object' || typeof parsed.type !== 'string')
+        return [];
+    if (parsed.type === 'user') {
+        if (parsed.synthetic_reason)
+            return []; // injected context, not the user
+        let prompt = contentToText(parsed.content);
+        if (!prompt)
+            return [];
+        // Grok also injects an environment block as a PLAIN user line (no
+        // synthetic_reason) at session start - recognizable by its wrapper tag.
+        if (prompt.startsWith('<user_info>'))
+            return [];
+        // The real prompt arrives wrapped in <user_query> tags - unwrap for
+        // clean display; the wrapper is Grok plumbing, not what the user typed.
+        const m = prompt.match(/^<user_query>\s*([\s\S]*?)\s*<\/user_query>$/);
+        if (m)
+            prompt = m[1];
+        if (!prompt)
+            return [];
+        return [{ kind: 'prompt', prompt, source_uuid: positional(sessionId, idx) }];
+    }
+    if (parsed.type === 'assistant') {
+        const text = contentToText(parsed.content);
+        const out = [];
+        const calls = Array.isArray(parsed.tool_calls) ? parsed.tool_calls : [];
+        if (text || calls.length) {
+            out.push({
+                kind: 'assistant',
+                text,
+                blocks: text ? [{ type: 'text', text }] : [],
+                ...(typeof parsed.model_id === 'string' ? { model: parsed.model_id } : {}),
+                source_uuid: positional(sessionId, idx),
+            });
+        }
+        for (const call of calls) {
+            if (!call || typeof call.id !== 'string' || !call.id)
+                continue;
+            const toolName = typeof call.name === 'string' && call.name ? call.name : 'tool';
+            toolNames.set(call.id, toolName);
+            let toolInput = call.arguments ?? null;
+            if (typeof toolInput === 'string') {
+                try {
+                    toolInput = JSON.parse(toolInput);
+                }
+                catch { /* keep raw string */ }
+            }
+            out.push({
+                kind: 'tool_use',
+                tool_use_id: call.id,
+                tool_name: toolName,
+                tool_input: toolInput,
+                source_uuid: call.id,
+            });
+        }
+        return out;
+    }
+    if (parsed.type === 'tool_result') {
+        if (typeof parsed.tool_call_id !== 'string' || !parsed.tool_call_id)
+            return [];
+        return [{
+                kind: 'tool_result',
+                tool_use_id: parsed.tool_call_id,
+                tool_name: toolNames.get(parsed.tool_call_id),
+                content: parsed.content ?? null,
+                source_uuid: `${parsed.tool_call_id}#out`,
+            }];
+    }
+    return []; // system, reasoning, unknown
+}
+/** Parse the full chat_history JSONL and emit every ingest entry that comes
+ *  *after* the positional watermark `afterUuid`. Same contract as the
+ *  claude-code parser. */
+export function parseTranscript(content, afterUuid, ctx = {}) {
+    const sessionId = ctx.sessionId ?? '';
+    const lines = content.split('\n');
+    // A watermark pointing past EOF means the file shrank under the same
+    // session id (e.g. a rewind rewrote chat_history). Treat it as not-found
+    // so the caller replays from the top - otherwise capture wedges silently.
+    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.
+            if (parsed?.type === 'assistant' && Array.isArray(parsed.tool_calls)) {
+                for (const call of parsed.tool_calls) {
+                    if (call && typeof call.id === 'string' && call.id) {
+                        toolNames.set(call.id, typeof call.name === 'string' && call.name ? call.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=grok.js.map

package/dist/client-context.js

@@ -27,6 +27,8 @@ export function detectHarness() {
     }
     if (hasEnvPrefix('CODEX_'))
         return { harness: 'codex' };
+    if (hasEnvPrefix('GROK_'))
+        return { harness: 'grok', harnessSession: process.env.GROK_SESSION_ID };
     if (process.env.CURSOR_TRACE_ID || hasEnvPrefix('CURSOR_') || (process.env.TERM_PROGRAM ?? '').toLowerCase().includes('cursor')) {
         return { harness: 'cursor' };
     }