@moxxy/sdk 0.11.0 → 0.13.0

package/src/fs-utils.test.ts

@@ -2,7 +2,7 @@ import { mkdtemp, readFile, readdir, stat } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { moxxyHome, moxxyPath, writeFileAtomic } from './fs-utils.js';
+import { moxxyHome, moxxyPath, writeFileAtomic, writeFileAtomicSync } from './fs-utils.js';
 
 describe('writeFileAtomic', () => {
   let dir: string;
@@ -41,6 +41,52 @@ describe('writeFileAtomic', () => {
   });
 });
 
+describe('writeFileAtomicSync', () => {
+  let dir: string;
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), 'moxxy-fss-'));
+  });
+
+  it('writes content and creates missing parent dirs', async () => {
+    const target = join(dir, 'nested', 'deep', 'file.json');
+    writeFileAtomicSync(target, '{"a":1}');
+    expect(await readFile(target, 'utf8')).toBe('{"a":1}');
+  });
+
+  it('overwrites an existing file and leaves no temp file behind', async () => {
+    const target = join(dir, 'file.txt');
+    writeFileAtomicSync(target, 'first');
+    writeFileAtomicSync(target, 'second');
+    expect(await readFile(target, 'utf8')).toBe('second');
+    const leftovers = (await readdir(dir)).filter((n) => n.includes('.tmp'));
+    expect(leftovers).toEqual([]);
+  });
+
+  it('enforces the requested mode past umask', async () => {
+    const target = join(dir, 'secret.json');
+    writeFileAtomicSync(target, 'shh', { mode: 0o600 });
+    const mode = (await stat(target)).mode & 0o777;
+    expect(mode).toBe(0o600);
+  });
+
+  it('writes binary data unchanged', async () => {
+    const target = join(dir, 'bytes.bin');
+    writeFileAtomicSync(target, new Uint8Array([0, 1, 2, 255]));
+    expect(Array.from(await readFile(target))).toEqual([0, 1, 2, 255]);
+  });
+
+  it('cleans up the temp file and throws when rename fails', async () => {
+    // A directory in place of the final file makes renameSync fail; the temp
+    // file must be removed and the error surfaced rather than swallowed.
+    const { mkdir } = await import('node:fs/promises');
+    const target = join(dir, 'as-dir');
+    await mkdir(target);
+    expect(() => writeFileAtomicSync(target, 'nope')).toThrow();
+    const leftovers = (await readdir(dir)).filter((n) => n.includes('.tmp'));
+    expect(leftovers).toEqual([]);
+  });
+});
+
 describe('moxxyHome / moxxyPath', () => {
   const original = process.env.MOXXY_HOME;
   afterEach(() => {

package/src/fs-utils.ts

@@ -1,4 +1,5 @@
 import { randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { chmod, mkdir, rename, rm, writeFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
@@ -40,6 +41,36 @@ export async function writeFileAtomic(
   }
 }
 
+/**
+ * Synchronous twin of {@link writeFileAtomic}, for the few call sites that
+ * cannot be async — boot/bootstrap and self-update gates that run before the
+ * event loop is the right tool. Same crash-atomic guarantee: write a unique
+ * sibling temp file, then `rename` it over the target. Hand-rolled
+ * `mkdirSync + writeFileSync(tmp) + renameSync` copies should call this instead.
+ */
+export function writeFileAtomicSync(
+  target: string,
+  data: string | Uint8Array,
+  opts: WriteFileAtomicOptions = {},
+): void {
+  mkdirSync(dirname(target), { recursive: true });
+  const tmp = `${target}.${process.pid}.${randomUUID()}.tmp`;
+  try {
+    writeFileSync(tmp, data, { encoding: opts.encoding ?? 'utf8' });
+    // chmod explicitly: writeFileSync's mode option is masked by umask, but a
+    // 0o600 secret file must be exactly 0o600 regardless of the host umask.
+    if (opts.mode != null) chmodSync(tmp, opts.mode);
+    renameSync(tmp, target);
+  } catch (err) {
+    try {
+      rmSync(tmp, { force: true });
+    } catch {
+      /* best-effort cleanup */
+    }
+    throw err;
+  }
+}
+
 /**
  * The moxxy home directory: `$MOXXY_HOME` when set, else `~/.moxxy`. Single
  * source of truth so the env override is honored uniformly — previously half

package/src/index.ts

@@ -19,6 +19,8 @@ export type {
   UserPromptAttachment,
   AssistantChunkEvent,
   AssistantMessageEvent,
+  ReasoningChunkEvent,
+  ReasoningMessageEvent,
   ToolCallRequestedEvent,
   ToolCallApprovedEvent,
   ToolCallDeniedEvent,
@@ -136,7 +138,30 @@ export type {
   ProviderOAuthStatus,
   ProviderAuthDescriptor,
 } from './provider.js';
+export {
+  encodeLoginPrompt,
+  decodeLoginPrompt,
+  createLoginStreamScanner,
+} from './provider-login-bridge.js';
+export type { LoginPromptRequest, LoginStreamItem } from './provider-login-bridge.js';
 export type { CacheStrategyDef, CacheStrategyContext } from './cache-strategy.js';
+export type {
+  DiffLine,
+  DiffHunk,
+  DiffRow,
+  FileDiffDisplay,
+  ToolDisplay,
+  ToolDisplayResult,
+} from './tool-display.js';
+export {
+  isToolDisplayResult,
+  isToolDisplay,
+  isFileDiffDisplay,
+  fileDiffSummary,
+  fileDiffVerb,
+  diffGutterNo,
+  toDiffRows,
+} from './tool-display.js';
 export type {
   ViewNode,
   ViewAction,
@@ -148,7 +173,7 @@ export type {
   ViewTagSpec,
   ViewRendererDef,
 } from './view-renderer.js';
-export { VIEW_PRIMITIVES, VIEW_COMPONENTS, DEFAULT_VIEW_TAGS, isSafeViewUrl } from './view-renderer.js';
+export { VIEW_PRIMITIVES, VIEW_COMPONENTS, DEFAULT_VIEW_TAGS, isSafeViewUrl, countNodes } from './view-renderer.js';
 export type {
   TunnelProviderDef,
   TunnelHandle,
@@ -158,8 +183,16 @@ export type {
 } from './tunnel.js';
 export { spawnCliTunnel, isCliTunnelAvailable } from './tunnel.js';
 export { isRetryableError, toFriendlyError, zodToJsonSchema, estimateTextTokens, type StopReason } from './provider-utils.js';
-export { writeFileAtomic, moxxyHome, moxxyPath, type WriteFileAtomicOptions } from './fs-utils.js';
+export {
+  writeFileAtomic,
+  writeFileAtomicSync,
+  moxxyHome,
+  moxxyPath,
+  type WriteFileAtomicOptions,
+} from './fs-utils.js';
 export { createMutex, type Mutex } from './mutex.js';
+export { assertNever } from './assert.js';
+export { compareSemver, parseSemverCore } from './semver.js';
 export { readRequestBody, bearerTokenMatches } from './http-utils.js';
 export {
   resolveChannelToken,
@@ -334,6 +367,22 @@ export type {
 export type { EmbeddingProvider, EmbedderDef } from './embedding.js';
 export { CachedEmbeddingProvider } from './embedding-cache.js';
 
+export { defineSurface } from './surface.js';
+export type {
+  SurfaceKind,
+  SurfaceDataMessage,
+  SurfaceInputMessage,
+  SurfaceSize,
+  SurfaceInstance,
+  SurfaceAvailability,
+  SurfaceContext,
+  SurfaceDef,
+  SurfaceRegistry,
+  SurfaceInfo,
+  OpenSurfaceResult,
+  SurfaceHost,
+} from './surface.js';
+
 export type {
   RequirementKind,
   RequirementState,

package/src/loop-helpers.test.ts

@@ -151,6 +151,46 @@ describe('projectMessagesFromLog', () => {
       content: [{ type: 'text', text: 'running it now' }],
     });
   });
+
+  it('projects only `forModel` for a rich tool result (file diff), never the display payload', () => {
+    // A Write/Edit returns { forModel, display:{kind:'file-diff', hunks:[…]} }.
+    // The model must see ONLY the short summary — the bulky hunks stay
+    // channel-side, so the context window never carries the full diff.
+    const display = {
+      forModel: 'edited /repo/a.ts — added 1 line, removed 1 line',
+      display: {
+        kind: 'file-diff' as const,
+        path: 'a.ts',
+        mode: 'update' as const,
+        added: 1,
+        removed: 1,
+        hunks: [
+          {
+            oldStart: 1,
+            oldLines: 1,
+            newStart: 1,
+            newLines: 1,
+            lines: [{ kind: 'del' as const, text: 'before', oldNo: 1 }, { kind: 'add' as const, text: 'after', newNo: 1 }],
+          },
+        ],
+      },
+    };
+    const log = reader([
+      event(0, { type: 'user_prompt', turnId: t1, source: 'user', text: 'edit it' }),
+      event(1, { type: 'tool_call_requested', turnId: t1, source: 'model', callId: 'c1', name: 'Edit', input: {} }),
+      event(2, { type: 'tool_result', turnId: t1, source: 'tool', callId: 'c1', ok: true, output: display }),
+    ]);
+
+    const messages = projectMessagesFromLog({ log });
+    const toolResult = messages.find((m) => m.role === 'tool_result');
+    const block = toolResult!.content[0]!;
+    expect(block).toMatchObject({ type: 'tool_result', content: display.forModel });
+    // The hunks / file content must NOT leak into the projected text.
+    if (block.type === 'tool_result') {
+      expect(block.content).not.toContain('hunks');
+      expect(block.content).not.toContain('before');
+    }
+  });
 });
 
 function reader(events: ReadonlyArray<MoxxyEvent>): EventLogReader {

package/src/mode-helpers.ts

@@ -11,6 +11,7 @@ import {
   toolResultStub,
   toolResultStubbed,
 } from './elision-state.js';
+import { isToolDisplayResult } from './tool-display.js';
 import { applyLazyTools } from './tool-gating.js';
 import { runCompactionIfNeeded } from './compactor-helpers.js';
 import { runElisionIfNeeded } from './elision-helpers.js';
@@ -196,6 +197,14 @@ export function projectMessages(
 
   let pendingAssistant: ProviderMessage | null = null;
   let pendingAssistantMaxSeq = -1;
+  // Reasoning block awaiting attachment to the current assistant turn. Only set
+  // for REPLAYABLE reasoning (Anthropic signature / redacted-or-Codex encrypted
+  // blob) — render-only reasoning is never sent back. Attached as content[0] of
+  // the turn's assistant message (Anthropic requires the signed thinking block
+  // first on an interleaved-thinking tool-use continuation; a missing/unsigned
+  // one is a hard 400). Dropped at any turn/compaction boundary it doesn't reach.
+  let pendingReasoning: Extract<ContentBlock, { type: 'reasoning' }> | null = null;
+  let pendingReasoningSeq = -1;
   const flush = (): void => {
     if (!pendingAssistant) return;
     const flushed = pendingAssistant;
@@ -237,6 +246,7 @@ export function projectMessages(
       if (!emittedCompactions.has(compaction)) {
         emittedCompactions.add(compaction);
         flush();
+        pendingReasoning = null;
         messages.push({
           role: 'user',
           content: [{ type: 'text', text: `[summary of earlier turns]\n${compaction.summary}` }],
@@ -249,6 +259,7 @@ export function projectMessages(
     switch (e.type) {
       case 'user_prompt': {
         flush();
+        pendingReasoning = null;
         // Elided + conversational: collapse to a stub (anchor/tiny kept full).
         if (conversationalStubbed(e, el)) {
           messages.push({
@@ -286,9 +297,26 @@ export function projectMessages(
         recordStable(e.seq);
         break;
       }
+      case 'reasoning_message': {
+        // Render-only reasoning (no signature/encrypted) is never replayed —
+        // it exists only for the live/scrollback "Thinking" view. Replayable
+        // reasoning is stashed for content[0] of this turn's assistant message.
+        if (e.signature || e.encrypted) {
+          pendingReasoning = {
+            type: 'reasoning',
+            text: e.content,
+            ...(e.signature ? { signature: e.signature } : {}),
+            ...(e.redacted ? { redacted: true } : {}),
+            ...(e.encrypted ? { encrypted: e.encrypted } : {}),
+          };
+          pendingReasoningSeq = e.seq;
+        }
+        break;
+      }
       case 'assistant_message':
         flush();
         if (conversationalStubbed(e, el)) {
+          pendingReasoning = null;
           messages.push({
             role: 'assistant',
             content: [{ type: 'text', text: conversationalStub('assistant', e.seq) }],
@@ -303,14 +331,31 @@ export function projectMessages(
         // tool_use blocks are projected from tool_call_requested events —
         // which also un-wedges historical logs that already contain one.
         if (e.content.trim().length === 0) {
+          pendingReasoning = null;
           recordStable(e.seq);
           break;
         }
-        messages.push({ role: 'assistant', content: [{ type: 'text', text: e.content }] });
+        {
+          const content: Array<ProviderMessage['content'][number]> = [];
+          if (pendingReasoning) {
+            content.push(pendingReasoning);
+            pendingReasoning = null;
+          }
+          content.push({ type: 'text', text: e.content });
+          messages.push({ role: 'assistant', content });
+        }
         recordStable(e.seq);
         break;
       case 'tool_call_requested': {
-        pendingAssistant ??= { role: 'assistant', content: [] };
+        if (!pendingAssistant) {
+          // Seed the assistant turn so the signed reasoning block is content[0],
+          // ahead of every tool_use (Anthropic's interleaved-thinking ordering).
+          pendingAssistant = { role: 'assistant', content: pendingReasoning ? [pendingReasoning] : [] };
+          if (pendingReasoning) {
+            pendingAssistantMaxSeq = Math.max(pendingAssistantMaxSeq, pendingReasoningSeq);
+            pendingReasoning = null;
+          }
+        }
         pendingAssistantMaxSeq = Math.max(pendingAssistantMaxSeq, e.seq);
         (pendingAssistant.content as Array<ProviderMessage['content'][number]>).push({
           type: 'tool_use',
@@ -330,6 +375,10 @@ export function projectMessages(
           text = toolResultStub(e.callId, toolResultBytes(e.output), recalled);
         } else if (e.error) {
           text = `[error:${e.error.kind}] ${e.error.message}`;
+        } else if (isToolDisplayResult(e.output)) {
+          // Rich result (e.g. a file diff): the model only needs the short
+          // `forModel` summary — the structured `display` is for channels.
+          text = e.output.forModel;
         } else {
           text = typeof e.output === 'string' ? e.output : JSON.stringify(e.output ?? '');
         }
@@ -361,6 +410,18 @@ export interface StreamResult {
   readonly error: { readonly message: string; readonly retryable: boolean } | null;
   /** Token usage reported by the provider on `message_end`, including cache hits/writes. */
   readonly usage?: TokenUsage;
+  /**
+   * Reasoning/thinking summary for this provider call, when the model emitted
+   * any. The mode emits it as a `reasoning_message` event (so it persists and
+   * round-trips). `signature`/`encrypted` carry Anthropic's signed thinking
+   * block / redacted blob; `redacted` marks display-suppressed reasoning.
+   */
+  readonly reasoning?: {
+    readonly text: string;
+    readonly signature?: string;
+    readonly redacted?: boolean;
+    readonly encrypted?: string;
+  };
 }
 
 /**
@@ -431,12 +492,17 @@ export async function collectProviderStream(
   // message-derived system text. Prefilling it would duplicate the prompt.
   // It stays as the side channel `onBeforeProviderCall` hooks use to inject
   // per-request system text (e.g. the memory consolidation nudge).
+  // Forward the per-provider reasoning preference, but only when THIS model
+  // advertises `supportsReasoning` — providers ignore the knob otherwise, but
+  // gating here keeps requests clean and avoids unsupported-param errors.
+  const reqReasoning = descriptor?.supportsReasoning ? ctx.reasoning : undefined;
   const req = {
     model: ctx.model,
     messages: effectiveMessages,
     ...(toolList ? { tools: toolList } : {}),
     ...(cacheHints && cacheHints.length > 0 ? { cacheHints } : {}),
     ...(opts.maxTokens !== undefined ? { maxTokens: opts.maxTokens } : {}),
+    ...(reqReasoning ? { reasoning: reqReasoning } : {}),
     signal: ctx.signal,
   };
   const transformed = await ctx.hooks.dispatchBeforeProviderCall(req, {
@@ -453,6 +519,14 @@ export async function collectProviderStream(
   let stopReason: StopReason = 'end_turn';
   let error: StreamResult['error'] = null;
   let usage: TokenUsage | undefined;
+  // Reasoning/thinking accumulation for this single provider call. Emitted as a
+  // finalized `reasoning_message` by the mode (turn-iterator / goal-loop) so it
+  // persists and round-trips; `signature`/`encrypted` carry Anthropic's signed
+  // thinking block / redacted blob for replay.
+  let reasoningText = '';
+  let reasoningSignature: string | undefined;
+  let reasoningRedacted = false;
+  let reasoningEncrypted: string | undefined;
 
   let stream: AsyncIterable<ProviderEvent>;
   try {
@@ -498,6 +572,25 @@ export async function collectProviderStream(
           error = { message: event.message, retryable: event.retryable };
           break;
         }
+        case 'reasoning_delta': {
+          reasoningText += event.delta;
+          // Live preview only — parallels `assistant_chunk`; renderers
+          // accumulate ephemerally and clear on the finalized reasoning_message.
+          await ctx.emit({
+            type: 'reasoning_chunk',
+            sessionId: ctx.sessionId,
+            turnId: ctx.turnId,
+            source: 'model',
+            delta: event.delta,
+          });
+          break;
+        }
+        case 'reasoning_signature': {
+          if (event.signature) reasoningSignature = event.signature;
+          if (event.encrypted) reasoningEncrypted = event.encrypted;
+          if (event.redacted) reasoningRedacted = true;
+          break;
+        }
         case 'message_start':
         case 'tool_use_delta':
         default:
@@ -516,7 +609,25 @@ export async function collectProviderStream(
     if (!partial.name) continue;
     finalToolUses.push({ id, name: partial.name, input: partial.input ?? {} });
   }
-  return { text, toolUses: finalToolUses, stopReason, error, ...(usage ? { usage } : {}) };
+  // Surface reasoning when there's visible text OR an opaque blob to replay
+  // (a redacted_thinking block has no text but must still round-trip).
+  const reasoning =
+    reasoningText.trim().length > 0 || reasoningEncrypted
+      ? {
+          text: reasoningText,
+          ...(reasoningSignature ? { signature: reasoningSignature } : {}),
+          ...(reasoningRedacted ? { redacted: true } : {}),
+          ...(reasoningEncrypted ? { encrypted: reasoningEncrypted } : {}),
+        }
+      : undefined;
+  return {
+    text,
+    toolUses: finalToolUses,
+    stopReason,
+    error,
+    ...(usage ? { usage } : {}),
+    ...(reasoning ? { reasoning } : {}),
+  };
 }
 
 /**

package/src/mode.ts

@@ -77,6 +77,13 @@ export interface ModeContext {
   readonly elision?: ElisionSettings;
   /** When true, send only always-on + loaded tool schemas; index the rest. */
   readonly lazyTools?: boolean;
+  /**
+   * Per-provider reasoning/thinking preference, resolved from the active
+   * provider's config at session build. Forwarded to the provider as
+   * `ProviderRequest.reasoning` by {@link collectProviderStream}, gated on the
+   * active model's `supportsReasoning`. Absent/false → reasoning off.
+   */
+  readonly reasoning?: { readonly effort?: 'low' | 'medium' | 'high' } | boolean;
   readonly permissions: PermissionResolver;
   /**
    * Optional generic "ask the user a question" gate. Any loop strategy can

package/src/plugin.ts

@@ -9,6 +9,7 @@ import type { LifecycleHooks } from './hooks.js';
 import type { ModeDef } from './mode.js';
 import type { ProviderDef } from './provider.js';
 import type { MoxxyRequirement } from './requirements.js';
+import type { SurfaceDef } from './surface.js';
 import type { ToolDef } from './tool.js';
 import type { TranscriberDef } from './transcriber.js';
 import type { SynthesizerDef } from './synthesizer.js';
@@ -16,7 +17,7 @@ import type { ViewRendererDef } from './view-renderer.js';
 import type { TunnelProviderDef } from './tunnel.js';
 import type { WorkflowExecutorDef } from './workflow.js';
 
-export type PluginKind = 'tools' | 'provider' | 'mode' | 'compactor' | 'cache-strategy' | 'view-renderer' | 'tunnel-provider' | 'mcp' | 'cli' | 'channel' | 'hooks' | 'agent' | 'command' | 'transcriber' | 'synthesizer' | 'embedder' | 'isolator' | 'workflow-executor';
+export type PluginKind = 'tools' | 'provider' | 'mode' | 'compactor' | 'cache-strategy' | 'view-renderer' | 'tunnel-provider' | 'mcp' | 'cli' | 'channel' | 'surface' | 'hooks' | 'agent' | 'command' | 'transcriber' | 'synthesizer' | 'embedder' | 'isolator' | 'workflow-executor';
 
 export interface PluginSpec {
   readonly name: string;
@@ -44,6 +45,14 @@ export interface PluginSpec {
    */
   readonly tunnelProviders?: ReadonlyArray<TunnelProviderDef>;
   readonly channels?: ReadonlyArray<ChannelDef>;
+  /**
+   * Interactive surfaces contributed by the plugin — long-lived panes a human
+   * and the agent drive together (an embedded terminal, an in-window browser).
+   * Registered into the session's `SurfaceRegistry`; the runner exposes them to
+   * thin clients over the `surface.*` protocol family. The plugin's own tools
+   * reach the same underlying resource through module state. See {@link SurfaceDef}.
+   */
+  readonly surfaces?: ReadonlyArray<SurfaceDef>;
   /**
    * Speech-to-text backends contributed by the plugin. Selected by name via
    * `session.transcribers.setActive(name)`; channels with audio input use

package/src/provider-login-bridge.test.ts

@@ -0,0 +1,78 @@
+import { describe, expect, it } from 'vitest';
+import {
+  createLoginStreamScanner,
+  decodeLoginPrompt,
+  encodeLoginPrompt,
+  type LoginStreamItem,
+} from './provider-login-bridge.js';
+
+describe('encode/decode login prompt', () => {
+  it('round-trips a request', () => {
+    const marker = encodeLoginPrompt({ question: 'Paste token:', mask: true });
+    // NUL-bracketed.
+    expect(marker.startsWith('\u0000')).toBe(true);
+    expect(marker.endsWith('\u0000')).toBe(true);
+    const inner = marker.slice(1, -1);
+    expect(decodeLoginPrompt(inner)).toEqual({ question: 'Paste token:', mask: true });
+  });
+
+  it('rejects non-marker segments', () => {
+    expect(decodeLoginPrompt('just text')).toBeNull();
+    expect(decodeLoginPrompt('{"tag":"other","question":"x"}')).toBeNull();
+    expect(decodeLoginPrompt('{not json')).toBeNull();
+  });
+});
+
+/** Drain a scanner across the given chunks into a flat item list. */
+function scanAll(chunks: string[]): LoginStreamItem[] {
+  const scanner = createLoginStreamScanner();
+  return chunks.flatMap((c) => [...scanner.push(c)]);
+}
+
+describe('createLoginStreamScanner', () => {
+  it('passes plain output straight through', () => {
+    expect(scanAll(['hello world'])).toEqual([{ type: 'output', text: 'hello world' }]);
+  });
+
+  it('extracts a marker with surrounding output', () => {
+    const stream = 'opening browser\n' + encodeLoginPrompt({ question: 'Paste code:', mask: false }) + 'done\n';
+    expect(scanAll([stream])).toEqual([
+      { type: 'output', text: 'opening browser\n' },
+      { type: 'prompt', prompt: { question: 'Paste code:', mask: false } },
+      { type: 'output', text: 'done\n' },
+    ]);
+  });
+
+  it('reassembles a marker split across chunks', () => {
+    const marker = encodeLoginPrompt({ question: 'Paste token:', mask: true });
+    const mid = Math.floor(marker.length / 2);
+    const items = scanAll(['prefix', marker.slice(0, mid), marker.slice(mid), 'suffix']);
+    expect(items).toEqual([
+      { type: 'output', text: 'prefix' },
+      { type: 'prompt', prompt: { question: 'Paste token:', mask: true } },
+      { type: 'output', text: 'suffix' },
+    ]);
+  });
+
+  it('handles two prompts in sequence', () => {
+    const a = encodeLoginPrompt({ question: 'first', mask: false });
+    const b = encodeLoginPrompt({ question: 'second', mask: true });
+    expect(scanAll([a + b])).toEqual([
+      { type: 'prompt', prompt: { question: 'first', mask: false } },
+      { type: 'prompt', prompt: { question: 'second', mask: true } },
+    ]);
+  });
+
+  it('holds back a lone opening NUL until its partner arrives', () => {
+    const scanner = createLoginStreamScanner();
+    const marker = encodeLoginPrompt({ question: 'q', mask: false });
+    // Feed everything except the closing NUL: nothing should surface yet.
+    expect([...scanner.push('text' + marker.slice(0, -1))]).toEqual([
+      { type: 'output', text: 'text' },
+    ]);
+    // Closing NUL completes the marker.
+    expect([...scanner.push('\u0000')]).toEqual([
+      { type: 'prompt', prompt: { question: 'q', mask: false } },
+    ]);
+  });
+});