@phnx-labs/agents-cli 1.22.82 → 1.22.84

package/dist/lib/session/parse.js

@@ -67,9 +67,29 @@ function sanitizeEvent(e) {
         e.hookName = sanitizeForTerminal(e.hookName);
     if (e.hookEvent)
         e.hookEvent = sanitizeForTerminal(e.hookEvent);
+    // The harness's own per-call label and turn phase are free text from the same
+    // untrusted transcript, and the timeline ships them straight to a terminal.
+    if (e.label)
+        e.label = sanitizeForTerminal(e.label);
+    if (e.phase)
+        e.phase = sanitizeForTerminal(e.phase);
     if (e.args)
         e.args = sanitizeArgsDeep(e.args);
 }
+/**
+ * Did this Claude tool_result record fail, or was it never allowed to run?
+ *
+ * Two distinct signals, both on the record ENCLOSING the `tool_result` block:
+ * `toolDenialKind` when a permission rule or hook refused the call, and
+ * `toolUseResult.interrupted` when the operator cut it short with Ctrl-C.
+ * Neither is a failure of the work, so both land on `blocked`, which is what
+ * separates "this agent is failing" from "this agent is being stopped".
+ */
+function isBlockedToolResult(raw) {
+    if (typeof raw?.toolDenialKind === 'string' && raw.toolDenialKind)
+        return true;
+    return raw?.toolUseResult?.interrupted === true;
+}
 function firstString(...values) {
     for (const value of values) {
         if (typeof value === 'string' && value.trim())
@@ -324,6 +344,22 @@ export function parseClaudeContent(content, opts = {}) {
         }
         const type = raw.type;
         const timestamp = raw.timestamp || new Date().toISOString();
+        // Claude's own file ledger: one record per file it backed up before changing
+        // it. `trackingPath` is the exact path; the record carries no add/update/
+        // delete verb, so the OPERATION still comes from the tool that touched it —
+        // this supplies the authoritative path set and touch time, nothing more.
+        if (type === 'file-history-delta' && opts.includeFileHistory) {
+            const trackingPath = typeof raw.trackingPath === 'string' ? raw.trackingPath : '';
+            if (trackingPath) {
+                events.push({
+                    type: 'file_change',
+                    agent: 'claude',
+                    timestamp: typeof raw.timestamp === 'string' ? raw.timestamp : timestamp,
+                    changes: [{ path: trackingPath, op: 'modified' }],
+                });
+            }
+            continue;
+        }
         if (type === 'assistant') {
             const contentBlocks = raw.message?.content || [];
             for (const block of contentBlocks) {
@@ -369,6 +405,13 @@ export function parseClaudeContent(content, opts = {}) {
                         path: toolInput.file_path || undefined,
                         command: toolName === 'Bash' ? toolInput.command : undefined,
                     };
+                    // Claude writes a human `description` on every Bash call (and on Agent
+                    // spawns) — the one-line label the model authored for exactly this
+                    // purpose. `summarizeToolUse` renders the command instead, so the label
+                    // was reaching no consumer; the timeline's now-line is written from it.
+                    if (typeof toolInput.description === 'string' && toolInput.description.trim()) {
+                        event.label = toolInput.description.trim();
+                    }
                     if (isLocal)
                         event._local = true;
                     // SlashCommand: the MODEL invoking a slash command programmatically
@@ -484,6 +527,12 @@ export function parseClaudeContent(content, opts = {}) {
                                 statusCode: structured.statusCode,
                                 errorCode: structured.errorCode,
                                 content: output || 'Tool execution failed',
+                                // A permission rule or a hook denied the call, or the operator cut
+                                // it short with Ctrl-C: it never completed, so it is not a failure
+                                // of the work. Claude stamps the denial kind on the enclosing
+                                // record (`toolDenialKind: 'permission-rule'`) and the interrupt
+                                // on its result (`toolUseResult.interrupted: true`).
+                                ...(isBlockedToolResult(raw) ? { blocked: true } : {}),
                             });
                         }
                         else {
@@ -589,6 +638,203 @@ function codexExecCommand(input) {
     const commands = commandsFromCodexExec(input);
     return commands.length > 0 ? commands.join('\n') : undefined;
 }
+/**
+ * Codex writes its turn TWICE in one rollout: the raw `response_item` records
+ * the model exchanged, and a parallel `event_msg` / `item_completed` stream of
+ * typed, already-classified items. The two overlap — on a 6,244-line rollout on
+ * zion (2026-09-06) the same turn appears as 648 `custom_tool_call` +
+ * 60 `function_call` records AND as 1,038 `CommandExecution` items — so the two
+ * MUST NOT be merged into one event list: every consumer that counts tool calls
+ * (digest, trajectory, insights, the tool index) would double-count.
+ *
+ * {@link parseCodexContent} therefore keeps reading `response_item` and this is
+ * a SEPARATE reader over the item stream, for consumers that want the harness's
+ * own classification instead of re-deriving it: the command as Codex parsed it
+ * (`parsed_cmd.type`), its `exit_code`/`status`, the per-path `FileChange`
+ * ledger, `AgentMessage.phase` (`commentary` is the narration between calls),
+ * web searches, sub-agent activity and compactions. The timeline fold is the
+ * consumer; `parseSession` is untouched.
+ *
+ * Version-tolerant by construction: an item type this does not know folds to a
+ * generic `other` tool_use rather than throwing, so a Codex release that adds an
+ * item type degrades to a counted step instead of an empty timeline.
+ */
+export function parseCodexItemsContent(content) {
+    const events = [];
+    for (const line of content.split('\n')) {
+        if (!line.trim())
+            continue;
+        let raw;
+        try {
+            raw = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (raw?.type !== 'event_msg')
+            continue;
+        const payload = raw.payload || {};
+        const timestamp = raw.timestamp || new Date().toISOString();
+        if (payload.type === 'turn_aborted') {
+            events.push({ type: 'interrupt', agent: 'codex', timestamp, content: 'Turn interrupted by user' });
+            continue;
+        }
+        if (payload.type !== 'item_completed')
+            continue;
+        const item = payload.item || {};
+        const id = typeof item.id === 'string' ? item.id : undefined;
+        switch (item.type) {
+            case 'AgentMessage': {
+                const text = codexItemText(item.content);
+                if (!text)
+                    break;
+                events.push({
+                    type: 'message', agent: 'codex', timestamp, role: 'assistant', content: text,
+                    ...(typeof item.phase === 'string' ? { phase: item.phase } : {}),
+                });
+                break;
+            }
+            case 'UserMessage': {
+                const text = codexItemText(item.content);
+                if (text)
+                    events.push({ type: 'message', agent: 'codex', timestamp, role: 'user', content: text });
+                break;
+            }
+            case 'CommandExecution': {
+                const command = codexItemCommand(item.command);
+                const parsed = Array.isArray(item.parsed_cmd) ? item.parsed_cmd[0] : undefined;
+                const parsedType = parsed && typeof parsed === 'object' ? parsed.type : undefined;
+                const verbClass = CODEX_PARSED_CMD_VERBS[String(parsedType)];
+                events.push({
+                    type: 'tool_use', agent: 'codex', timestamp, tool: 'Bash', callId: id,
+                    args: { command }, command,
+                    label: truncate(command.replace(/\n/g, ' ').trim(), 120),
+                    ...(verbClass ? { verbClass } : {}),
+                });
+                const exitCode = typeof item.exit_code === 'number' ? item.exit_code : undefined;
+                const failedStatus = item.status === 'failed' || item.status === 'error';
+                // A search that matched nothing exits 1 and is not a failure — the same
+                // rule the fold applies to Claude, kept here so the two agree.
+                const benign = exitCode === 1 && CODEX_BENIGN_EXIT1_RE.test(command);
+                if (failedStatus || (exitCode !== undefined && exitCode !== 0 && !benign)) {
+                    events.push({
+                        type: 'error', agent: 'codex', timestamp, tool: 'Bash', callId: id,
+                        outcome: 'error', ...(exitCode !== undefined ? { exitCode } : {}),
+                        content: 'Command failed',
+                    });
+                }
+                else if (exitCode !== undefined || item.status) {
+                    events.push({
+                        type: 'tool_result', agent: 'codex', timestamp, tool: 'Bash', callId: id,
+                        success: true, outcome: 'ok', ...(exitCode !== undefined ? { exitCode } : {}),
+                    });
+                }
+                break;
+            }
+            case 'FileChange': {
+                const changes = codexFileChanges(item.changes);
+                if (!changes.length)
+                    break;
+                events.push({ type: 'file_change', agent: 'codex', timestamp, callId: id, changes });
+                break;
+            }
+            case 'Extension': {
+                const query = typeof item.query === 'string' ? item.query : '';
+                events.push({
+                    type: 'tool_use', agent: 'codex', timestamp, tool: 'WebSearch', callId: id,
+                    args: { query }, verbClass: 'browser',
+                    label: `web search: ${truncate(query, 60)}`,
+                });
+                break;
+            }
+            case 'SubAgentActivity': {
+                // `started` opens a sub-agent; the matching `completed` would count the
+                // same spawn twice, so only the opening edge is a call.
+                if (item.kind !== 'started')
+                    break;
+                events.push({
+                    type: 'tool_use', agent: 'codex', timestamp, tool: 'Agent', callId: id,
+                    args: { path: item.agent_path }, verbClass: 'agent',
+                    label: `subagent ${String(item.agent_path ?? '').replace(/^\//, '') || 'started'}`,
+                });
+                break;
+            }
+            case 'McpToolCall': {
+                const label = `${item.server ?? ''}.${item.tool ?? ''}`.replace(/^\.|\.$/g, '');
+                events.push({
+                    type: 'tool_use', agent: 'codex', timestamp, tool: 'mcp', callId: id,
+                    args: {}, verbClass: 'other', label: label || 'mcp call',
+                });
+                break;
+            }
+            case 'ImageView': {
+                events.push({
+                    type: 'tool_use', agent: 'codex', timestamp, tool: 'Read', callId: id,
+                    args: { path: item.path }, verbClass: 'read', label: 'viewed image',
+                });
+                break;
+            }
+            case 'ContextCompaction': {
+                events.push({ type: 'hook', agent: 'codex', timestamp, hookName: 'ContextCompaction', content: 'context compacted' });
+                break;
+            }
+            case 'Reasoning':
+                // `summary_text` is empty on every rollout measured (13,461 items, 0 with
+                // text — only `encrypted_content`), so there is nothing to read. Skipped
+                // deliberately rather than emitted as an empty thinking event.
+                break;
+            default: {
+                // Unknown item type from a newer Codex: counted, never dropped, never thrown.
+                if (!item.type)
+                    break;
+                events.push({
+                    type: 'tool_use', agent: 'codex', timestamp, tool: String(item.type), callId: id,
+                    args: {}, verbClass: 'other', label: String(item.type),
+                });
+                break;
+            }
+        }
+    }
+    return events;
+}
+/** Codex `parsed_cmd[0].type` → the timeline's verb class. Anything else is derived from the command. */
+const CODEX_PARSED_CMD_VERBS = {
+    read: 'read',
+    list_files: 'read',
+    search: 'read',
+};
+/** Commands whose exit 1 means "no match", not "failed". */
+const CODEX_BENIGN_EXIT1_RE = /^\s*(rg|grep|diff|test|\[)\b/;
+/** Text of a Codex item's `content` array (`{ type, text }` blocks). */
+function codexItemText(content) {
+    if (!Array.isArray(content))
+        return '';
+    return content
+        .map((part) => (part && typeof part.text === 'string' ? part.text : ''))
+        .join(' ')
+        .trim();
+}
+/** `["/bin/zsh", "-lc", "git pull"]` → `git pull`; a plain string passes through. */
+function codexItemCommand(command) {
+    if (typeof command === 'string')
+        return command;
+    if (!Array.isArray(command))
+        return '';
+    const shellWrapped = command.length >= 3 && (command[1] === '-lc' || command[1] === '-c');
+    return (shellWrapped ? command.slice(2) : command).map(String).join(' ');
+}
+/** Codex `FileChange.changes`: `{ "<path>": { type: "add" | "update" | "delete" } }`. */
+function codexFileChanges(changes) {
+    if (!changes || typeof changes !== 'object' || Array.isArray(changes))
+        return [];
+    const ops = {
+        add: 'created', update: 'modified', delete: 'deleted',
+    };
+    return Object.entries(changes).map(([filePath, change]) => ({
+        path: filePath,
+        op: ops[String(change?.type)] ?? 'modified',
+    }));
+}
 /**
  * Parse Codex JSONL *content* (already read into a string) into normalized
  * events. Split from `parseCodex` so the tail reader can parse just the last
@@ -1164,35 +1410,32 @@ export function splitSessionFilePath(filePath) {
 export function sessionFilePathContainer(filePath) {
     return splitSessionFilePath(filePath).container;
 }
-// ---------------------------------------------------------------------------
-// OpenCode parser
-// ---------------------------------------------------------------------------
 /**
- * Parse an OpenCode session from its SQLite database.
- * filePath format: "/path/to/opencode.db#session_id"
- *
- * Data model: session -> message -> part
- * Messages have role (user/assistant) and metadata.
- * Parts contain the actual content: text, tool, reasoning, patch, step-start/finish.
- */
-/**
- * Parse a Grok (xAI CLI) session into normalized events.
- *
- * A Grok session dir holds several files; the conversation transcript is
- * `chat_history.jsonl`, one JSON object per line with a `type`:
- *   - `system`       — the system prompt (skipped; not conversational)
- *   - `user`         — `content` is an array of `{ type: 'text', text }` blocks
- *   - `assistant`    — `content` is a string, plus a `tool_calls[]` array of
- *                      `{ id, name, arguments }` (arguments is a JSON string)
- *   - `reasoning`    — chain-of-thought; text (when present) lives in `summary`
- *   - `tool_result`  — `{ tool_call_id, content }`, correlated back to the call
- *
- * The scanner records `summary.json` as the session's filePath (see
- * `readGrokMeta` in discover.ts), so resolve `chat_history.jsonl` from the same
- * dir; also accept being handed the transcript file directly. Per-line
- * timestamps aren't stored, so every event carries the session's `created_at`
- * (from summary.json), falling back to the transcript's mtime.
+ * Read `signals.json` next to a Grok transcript. Returns `undefined` when the
+ * file is absent or unreadable — a Grok session simply has no signals then, and
+ * the fold reports what it does have rather than inventing zeros.
  */
+export function readGrokSignals(filePath) {
+    const signalsPath = filePath.endsWith('signals.json')
+        ? filePath
+        : path.join(path.dirname(filePath), 'signals.json');
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(signalsPath, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+    if (!raw || typeof raw !== 'object')
+        return undefined;
+    const count = (value) => (typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0);
+    return {
+        gitCommitCount: count(raw.gitCommitCount),
+        prCreatedCount: count(raw.prCreatedCount),
+        prMergedCount: count(raw.prMergedCount),
+        toolFailureCount: count(raw.toolFailureCount),
+    };
+}
 export function parseGrok(filePath) {
     const sessionDir = path.dirname(filePath);
     const historyPath = filePath.endsWith('chat_history.jsonl')
@@ -1372,6 +1615,12 @@ export const OPENCODE_TRANSCRIPT_QUERY = `
         'callID', json_extract(p.data, '$.callID'),
         'state', json_object(
           'status', json_extract(p.data, '$.state.status'),
+          /* state.title is the human label OpenCode writes per call ("Read
+             src/index.ts") — kept so the timeline now-line reads as the harness
+             wrote it (PHNX-3939). A BLOCK comment, never a line comment: this
+             template is flattened to one line below, so a line comment would
+             swallow the rest of the query. */
+          'title', json_extract(p.data, '$.state.title'),
           'input', CASE
             WHEN LENGTH(CAST(COALESCE(json_extract(p.data, '$.state.input'), '') AS BLOB)) > ${OPENCODE_INPUT_MAX_BYTES}
             THEN json_object(
@@ -1497,6 +1746,13 @@ export function parseOpenCode(filePath) {
                     const input = state.input || {};
                     const output = state.output || '';
                     const callId = typeof partData.callID === 'string' ? partData.callID : undefined;
+                    // OpenCode writes both a per-call `input.description` and a rendered
+                    // `state.title`; either is the label a person would read.
+                    const label = typeof input.description === 'string' && input.description.trim()
+                        ? input.description.trim()
+                        : typeof state.title === 'string' && state.title.trim()
+                            ? state.title.trim()
+                            : undefined;
                     events.push({
                         type: 'tool_use',
                         agent: 'opencode',
@@ -1506,6 +1762,7 @@ export function parseOpenCode(filePath) {
                         args: input,
                         command: toolName === 'shell' ? input.command : undefined,
                         path: input.filePath || input.path || undefined,
+                        ...(label ? { label } : {}),
                     });
                     if (state.status === 'completed' || state.status === 'error') {
                         const outputStr = typeof output === 'string' ? output : JSON.stringify(output);
@@ -1521,7 +1778,28 @@ export function parseOpenCode(filePath) {
                     }
                     break;
                 }
-                // Skip step-start, step-finish, patch, file — not needed for transcript/trace
+                case 'patch': {
+                    // OpenCode's own edit ledger for one step: the exact paths it wrote.
+                    // The part records no add/update/delete verb, so the operation still
+                    // comes from the tool that produced it (see foldSessionFiles).
+                    const files = Array.isArray(partData.files) ? partData.files : [];
+                    const changes = files
+                        .map((file) => (typeof file === 'string' ? file : file?.path))
+                        .filter((filePath) => typeof filePath === 'string' && filePath.length > 0)
+                        .map((filePath) => ({ path: filePath, op: 'modified' }));
+                    if (changes.length) {
+                        events.push({ type: 'file_change', agent: 'opencode', timestamp, changes });
+                    }
+                    break;
+                }
+                case 'compaction': {
+                    events.push({
+                        type: 'hook', agent: 'opencode', timestamp,
+                        hookName: 'ContextCompaction', content: 'context compacted',
+                    });
+                    break;
+                }
+                // Skip step-start, step-finish, file — not needed for transcript/trace
             }
         }
     }
@@ -1919,6 +2197,13 @@ export function parseKimi(filePath) {
                 if (callId) {
                     toolCallMap.set(callId, toolName);
                 }
+                // Kimi writes a per-call `description` on the wire event (and sometimes
+                // inside the args) — the same human label Claude puts on a Bash call.
+                const kimiLabel = typeof event.description === 'string' && event.description.trim()
+                    ? event.description.trim()
+                    : typeof args.description === 'string' && args.description.trim()
+                        ? args.description.trim()
+                        : undefined;
                 events.push({
                     type: 'tool_use',
                     agent: 'kimi',
@@ -1928,6 +2213,7 @@ export function parseKimi(filePath) {
                     args,
                     path: args.path || args.file_path || undefined,
                     command: toolName === 'Bash' ? args.command : undefined,
+                    ...(kimiLabel ? { label: kimiLabel } : {}),
                 });
             }
             else if (eventType === 'tool.result') {
@@ -2062,7 +2348,7 @@ function parseAnthropicMessageJsonl(filePath, agent) {
                 const toolInput = block.input || {};
                 if (block.id)
                     toolUseMap.set(block.id, { tool: toolName, args: toolInput });
-                events.push({
+                const event = {
                     type: 'tool_use',
                     agent,
                     timestamp,
@@ -2071,7 +2357,15 @@ function parseAnthropicMessageJsonl(filePath, agent) {
                     args: toolInput,
                     path: toolInput.file_path || toolInput.path || undefined,
                     command: (toolName === 'Bash' || toolName === 'Execute' || toolName === 'Shell') ? toolInput.command : undefined,
-                });
+                };
+                // Both harnesses on this parser write the same per-call human label
+                // under different keys — Cursor `description`, Droid `summary` — so the
+                // timeline's now-line reads "List files" rather than `ls -la`, exactly
+                // as it does for the Claude arm above.
+                const label = firstString(toolInput.description, toolInput.summary);
+                if (label)
+                    event.label = label;
+                events.push(event);
             }
             else if (block.type === 'tool_result') {
                 const toolId = block.tool_use_id;

package/dist/lib/session/prompt.d.ts

@@ -5,7 +5,7 @@
  * wrapper tags, team-spawn boilerplate) so that only the real user intent
  * remains. Used by the session picker to show a human-readable topic line.
  */
-import type { SessionEvent } from './types.js';
+import type { SessionAttachment, SessionEvent } from './types.js';
 /**
  * True when a `role=user` message is harness-injected scaffolding, not a genuine
  * user turn. Text-based so it is cross-harness by construction (the markers are
@@ -27,6 +27,15 @@ export declare function unwrapUserQuery(text: string): string;
  * so the stored turn is the originating request, not the harness tags.
  */
 export declare function cleanFirstUserMessage(raw: string | undefined): string | undefined;
+/**
+ * LATEST genuine user message from an already-normalized event stream.
+ *
+ * The operative request of a `/continue`d, redirected, or interrupted-and-
+ * restated session is the last thing the user said, not the first (PHNX-3939).
+ * Same rejection rules as {@link firstUserMessageFromEvents} — walking from the
+ * end so a long transcript stops at the first genuine turn it meets.
+ */
+export declare function lastUserMessageFromEvents(events: SessionEvent[]): string | undefined;
 /** First genuine user message from an already-normalized event stream. */
 export declare function firstUserMessageFromEvents(events: SessionEvent[]): string | undefined;
 /**
@@ -101,5 +110,87 @@ export declare function classifyUserPrompt(raw: string | undefined, opts?: {
  * here — the caller keeps it verbatim.
  */
 export declare function cleanGeneratedSessionLabel(title: string | undefined): string | undefined;
-/** Extract a one-line topic from a raw user message, or undefined if the message is pure noise. */
+/**
+ * Extract a one-line topic from a raw user message, or undefined if the message
+ * is pure noise.
+ *
+ * Rejection is {@link isSyntheticUserMessage} — the SAME list the turn cleaner
+ * uses. This function used to consult a shorter, looser copy of it
+ * (permissions / collaboration / AGENTS.md / local-command-caveat /
+ * `<command-*>` only), which is how a `/model` echo (`<local-command-stdout>`)
+ * or a skill body ("Base directory for this skill:") became a session's topic —
+ * and then its displayed title — while `cleanFirstUserMessage` rejected the same
+ * text (PHNX-3939). Whatever is not a genuine user turn is not a topic either.
+ *
+ * The check runs twice on purpose: once on the raw message, and again after
+ * {@link cleanSessionPrompt} strips wrapper tags, since stripping can expose a
+ * marker (a skill body) that the tags were hiding.
+ */
 export declare function extractSessionTopic(raw: string): string | undefined;
+/**
+ * One classified piece of a request that is not prose: an image or file the user
+ * dropped in, or an `@path` directory reference. `name` is the basename (or the
+ * `@ref` verbatim) — the sidebar renders these as chips beside the request text.
+ */
+export interface RequestAttachmentRef {
+    kind: 'image' | 'file' | 'dir';
+    name: string;
+}
+/**
+ * A user request split into its parts, never rewritten (PHNX-3939).
+ *
+ * The rule this type exists to enforce: the request card shows what the agent
+ * was actually told. Prose is joined and whitespace-collapsed, never
+ * paraphrased or summarized — a model rewrite is what the optional summarizer's
+ * `goal` is for, and it is labeled as such. Everything that is NOT the user's
+ * sentence (screenshot paths, `host:/path` clip references, `@dir` mentions,
+ * pasted terminal echo) is pulled out into `attachments` / `pastedLines` so the
+ * sentence survives intact instead of being buried.
+ */
+export interface TidyRequest {
+    /** The user's prose, joined and whitespace-collapsed. Empty for an image-only turn. */
+    text: string;
+    /** First sentence of {@link text}, capped — the one line a row shows. */
+    headline: string;
+    kind: UserPromptKind;
+    /** The invocation this turn came in as, e.g. `/continue 8231082e`. */
+    command?: string;
+    attachments: RequestAttachmentRef[];
+    /** Lines classified as pasted terminal echo rather than prose. */
+    pastedLines: number;
+}
+/**
+ * First sentence of a block of text, flattened and capped.
+ *
+ * Leading markdown headings are skipped so the headline is the ask, not the
+ * section label. A block that then opens with markdown structure (a table row, a
+ * bullet, a numbered item) is reduced to its first LINE — a sentence-terminator
+ * scan across a table would otherwise splice two cells together. Markdown
+ * emphasis characters are dropped so a headline never renders as raw syntax. A
+ * "sentence" shorter than 12 characters is not one (an abbreviation, a version
+ * number), so the whole flattened text is kept instead.
+ */
+export declare function firstSentence(text: string, cap?: number): string;
+/**
+ * Split one raw user turn into prose, attachments and pasted terminal echo
+ * WITHOUT rewriting a word of it (PHNX-3939). Returns `undefined` when the turn
+ * is harness-injected scaffolding or carries nothing to show.
+ *
+ * Order matters and mirrors how a turn is actually assembled:
+ *   1. a `<user_query>` wrapper is unwrapped (Grok/Cursor);
+ *   2. a `/name <id>` or `<command-name>` invocation becomes `command`, and any
+ *      prose inside `<command-args>` becomes the request itself — this is what
+ *      makes a `/plan -- Wait hold on…` turn read as the user's sentence rather
+ *      than as a bare command name;
+ *   3. whole-message scaffolding is rejected;
+ *   4. a multi-line paste that opens with a command and asks nothing is pasted
+ *      output, not a request;
+ *   5. every remaining segment (split on ` -- ` and per line) is classified as
+ *      an attachment, terminal echo, or prose.
+ *
+ * `opts.attachments` are the row's own recorded attachments, folded in so an
+ * image the harness captured but the text never named still shows as a chip.
+ */
+export declare function tidyRequest(raw: string | undefined, opts?: {
+    attachments?: SessionAttachment[];
+}, depth?: number): TidyRequest | undefined;