feat(freshclaude): live transcript — streamed text, tool rows, retries, notices and subagent activity while a turn runs

crates/freshell-claude-sidecar/index.mjs

@@ -37,8 +37,23 @@
 //                                    turn), and the sidecar then exits with code 2.
 //     { type:'sdk.configured',          sessionId, requestId, ok, settings?, message? }
 //     { type:'sdk.session.init',        sessionId, cliSessionId, model, cwd, tools }  // durable Claude UUID
-//     { type:'sdk.assistant',           sessionId, content, model }
-//     { type:'sdk.stream',              sessionId, event, parentToolUseId }
+//     { type:'sdk.assistant',           sessionId, content, model, uuid, messageId, parentToolUseId }
+//                                  — one per completed content block (blocks of one API message share
+//                                    messageId); parentToolUseId is set inside a subagent, else null
+//     { type:'sdk.stream',              sessionId, event, parentToolUseId:null, messageId }
+//                                  — the main thread's message_start, content_block_start/stop and
+//                                    text/thinking deltas only, stamped with the API message id of the
+//                                    message being streamed (a subagent's events, tool input JSON,
+//                                    signatures, message_delta and message_stop are not sent)
+//     { type:'sdk.retry',               sessionId, attempt, maxRetries, delayMs, errorStatus, error }
+//                                  — the CLI will retry a failed API request (errorStatus null: no HTTP
+//                                    response); live only, never a turn end
+//     { type:'sdk.notice',              sessionId, level:'info'|'warning'|'error', code, message, rateLimit? }
+//                                  — a non-terminal provider notice: RATE_LIMIT_WARNING / RATE_LIMITED
+//                                    (rateLimit {status, resetsAt?, rateLimitType?, utilization?}),
+//                                    INFORMATIONAL (the CLI's own warning or suggestion text, or a message
+//                                    that stops the turn; its quiet info/notice levels are not sent),
+//                                    COMPACTION_FAILED (the CLI's reason); never a turn end
 //     { type:'sdk.result',              sessionId, result, durationMs, costUsd, usage }
 //     { type:'sdk.turn.complete',       sessionId, at }                   // EVERY result (any subtype) except
 //                                  the stopped turn's own aborted result (an accepted user interrupt's mark
@@ -51,8 +66,16 @@
 //                                  — the command catalog without the terminal-only commands (the pinned
 //                                    CLI's until a turn's init names its own): from the boot, then
 //                                    whenever a turn's init or commands_changed changes it
-//     { type:'sdk.status',              sessionId, status }               // compacting (an ended stream sends
-//                                  no status: the server reports the session as exited)
+//     { type:'sdk.session.changed',     sessionId, reason:'transcript', uuid, parentToolUseId }
+//                                  — the CLI writes this message (assistant, user, compaction boundary,
+//                                    local command output) to its transcript under `uuid`, about 100 ms
+//                                    later; sent right after the message's own frames
+//                                    (sdk-message-frames.mjs)
+//     { type:'sdk.status',              sessionId, status }               // compacting; running when a
+//                                  compaction ends while a send still waits for its result (interim, core
+//                                  N2); an ended stream sends no status: the server reports it as exited
+//     { type:'sdk.session.metadata',    sessionId, permissionMode }       // the CLI changed its own
+//                                  permission mode (an ExitPlanMode approval); the session adopts it first
 //     { type:'sdk.error',               sessionId, message, turnFailure? } // turnFailure: a failed turn's result
 //                                  (sanitized text, no [ede_diagnostic] lines); never for the user's own Stop
 //     { type:'sdk.stream.ended',        sessionId, reason, message }      // the session's SDK stream ended
@@ -103,7 +126,7 @@
 import { createInterface } from 'node:readline'
 import { randomBytes } from 'node:crypto'
 import { configureSession, userMessageContent } from './session-settings.mjs'
-import { resultFrames } from './sdk-message-frames.mjs'
+import { createFrameState, frameLogRecord, framesForSdkMessage, resultFrames } from './sdk-message-frames.mjs'
 import { createTurnCompleteGate } from './turn-complete-gate.mjs'
 import { checkpointAttemptOf, rememberCheckpointAttempt, takeCheckpointIdentity } from './checkpoint-identity.mjs'
 import { nextMonotonic } from './monotonic-clock.mjs'
@@ -323,34 +346,9 @@ function handleSdkMessage(sessionId, msg) {
           st.commandCatalog = commands
           publishCommandsIfChanged(sessionId, st)
         }
-      } else if (msg.subtype === 'status' && msg.status === 'compacting') {
-        emit({ type: 'sdk.status', sessionId, status: 'compacting' })
-      } else if (msg.subtype === 'compact_boundary') {
-        // kata 1wxv ep3-r1 F1: the bare compacting STATUS frame carries no
-        // trigger — the SDK fires it for an explicit `/compact` AND for its
-        // own automatic context compaction, and misattributing the automatic
-        // one to a queued explicit compact wedges the rollback busy gate
-        // (the phantom compact absorbs the turn's own terminal edge). Only the
-        // compact COMPLETION boundary discriminates the trigger; relay it.
-        // Fail toward 'auto' on a missing/unknown trigger so promotion to a
-        // queued explicit compact never happens without a proven manual run.
-        const trigger = msg.compact_metadata?.trigger === 'manual' ? 'manual' : 'auto'
-        emit({ type: 'sdk.compact_boundary', sessionId, trigger })
       }
       break
     }
-    case 'assistant': {
-      const content = msg.message?.content || []
-      const blocks = content.map((b) => {
-        if (b.type === 'text') return { type: 'text', text: b.text }
-        if (b.type === 'thinking') return { type: 'thinking', thinking: b.thinking }
-        if (b.type === 'tool_use') return { type: 'tool_use', id: b.id, name: b.name, input: b.input }
-        if (b.type === 'tool_result') return { type: 'tool_result', tool_use_id: b.tool_use_id, content: b.content, is_error: b.is_error }
-        return b
-      })
-      emit({ type: 'sdk.assistant', sessionId, content: blocks, model: msg.message?.model })
-      break
-    }
     case 'result': {
       // The awaited turn's terminal frame arrived: drop one pending send
       // (clamped at 0 — an unsolicited result must not underflow the counter).
@@ -369,14 +367,29 @@ function handleSdkMessage(sessionId, msg) {
       }
       break
     }
-    case 'stream_event': {
-      emit({ type: 'sdk.stream', sessionId, event: msg.event, parentToolUseId: msg.parent_tool_use_id })
-      break
-    }
     default:
-      // Unhandled SDK message type — ignored (matches SdkBridge default).
       break
   }
+  // The content kinds (assistant, user, stream events, status, retries and
+  // notices): a pure mapping, sdk-message-frames.mjs. Any kind it does not
+  // map is dropped there.
+  const frames = framesForSdkMessage(sessionId, msg, {
+    stream: st.frameState,
+    permissionMode: st.settings.permissionMode,
+    turnPending: st.pendingResults > 0,
+  })
+  for (const frame of frames) {
+    // The CLI changed its own permission mode (an ExitPlanMode approval): the
+    // session adopts it before saying so, so a configure to that mode applies
+    // nothing and the permission channel sees the mode the CLI is in.
+    if (frame.type === 'sdk.session.metadata' && frame.permissionMode !== undefined) {
+      st.settings.permissionMode = frame.permissionMode
+      st.permissionMode = frame.permissionMode
+    }
+    emit(frame)
+    const record = frameLogRecord(frame)
+    if (record) log(record.severity, record.event, record.fields)
+  }
 }
 
 async function consumeStream(sessionId, sdkQuery) {
@@ -508,6 +521,8 @@ function handleCreate(req) {
     turnCompleteGate: createTurnCompleteGate(),
     pendingResults: 0,
     pendingCheckpointAttempts: new Map(),
+    // The content mapping's own per-session state (sdk-message-frames.mjs).
+    frameState: createFrameState(),
   }
   const { iterable, handle } = createInputStream((isCompact) => {
     if (isCompact) state.handedCompactLikely = true