[vergram]

Summary

pi's SDK refuses prompts while compaction runs ("Cannot submit a prompt while
compaction is in progress"), so nothing typed into a compacting session could reach
the agent. The wrapper now parks those submissions and flushes them when the
compaction ends, as pi's TUI's compactionQueuedMessages does. This is the
compaction-queueing part of #812, the focused follow-up its closing comment asked for.

send("prompt") while isCompacting
  inner.prompt()
    rejects "Cannot submit a prompt while compaction is in progress"
-   error notice + text back in the composer
+   park { message, images, streamingBehavior }   # admission stays outstanding
+   ack { queued: true }                          # composer clears, queue row appears
+   drop the optimistic bubble                    # not a sent message until delivered

on compaction_end / auto_compaction_end
+  for entry in parked, FIFO
+    inner.prompt(entry, streamingBehavior ?? "followUp")
+      "started" → prompt_done for its client
+      "queued"  → rides the live run's prompt_done
+      error     → back to the queue + prompt_error

Shipped alongside, a pre-existing composer bug this feature cannot ship without: the
/compact builtin awaited its blocking compact POST while runBuiltinCommand holds
the composer's <fieldset disabled>, so the input box took no text for the whole
compaction and came back only after a remount.

/compact (builtin slash command)
-  await the blocking compact POST   # <fieldset disabled> held meanwhile
+  complete at once, run handleCompact detached
+    Compacting status, Stop compaction, result banner, error report the outcome

• Parking hooks the SDK's rejection, never pre-empts inner.prompt(), so an extension
  command typed during compaction still runs (the SDK executes commands before it refuses).
• A parked prompt keeps its admission's pendingPromptCount outstanding until delivery or
  recall, so isRunning(), the idle shutdown and the reload/clone refusals see it.
• The flush always carries a streamingBehavior, so AgentSession.prompt() queues into a
  run still finishing the compaction or starts one when idle. It never hits
  "Agent is already processing".
• get_state.queuedMessages and every queue_update merge pi's queue with the parked
  ones; clear_queue returns both, and Recall puts the text back in the composer.
• The composer stays editable: the placeholder says messages queue, and the status line
  reads "Compacting… · N queued" for a manual compaction too, where agentRunning alone
  left it unlabeled.

Evidence

Before: a prompt sent during compaction bounced with "Cannot submit a prompt while
compaction is in progress." and the text returned to the composer; with /compact the
composer was dead for the compaction's duration. Neither queued-message path worked.
After: the message is accepted, appears in the queued-messages panel, and is
delivered FIFO when the compaction ends.

New tests:

✔ /compact completes at once and runs the compaction detached      # holds the compact POST open forever
✔ /compact passes its instructions to the detached compaction
✔ prompts sent while compaction runs park and flush FIFO at compaction end
✔ recall returns parked prompts to the input and settles their admissions
✔ clear_queue returns pi's own queue beside the parked prompts
✔ a failed flush puts the prompt back in the queue and reports the error
✔ parked prompts carry their images through the flush

Plus the queued-count case in lib/chat-phase-label.test.mjs and an
editable-while-compacting case in components/ChatInput.test.mjs.

Checks: tsc --noEmit clean, npm run lint clean, npm test green end to end
(2880 tests, 2859 pass, 21 skipped, 0 fail).

The branch also carries one separable commit, test: run the suite green on Windows
(28 test files, test and fixture code only): 8.3 temp-path canonicalization, CRLF
normalization at source reads, chmod semantics, ESM absolute-path imports in the hooks
fixtures, ConPTY pid timing, and EBUSY teardown of fixture MCP servers. npm test
used to fail 66 here and hang without --test-force-exit; it now exits clean. Happy to
split it into its own PR if you prefer.

Merge Danger

Door: Two-way. A revert restores today's behavior on both paths, and there is no
schema, session-file or extension-API surface change.

Blast Radius: Prompt dispatch while a compaction runs, and the /compact builtin
command. Idle sessions, runs, steer/follow-up queueing outside compaction and other
slash commands are untouched.

• Parked text lives in the wrapper instead of the composer, so a wrapper shutdown before
  the flush drops it. The queue panel and Recall are the user's recourse while it is
  parked, and isRunning() keeps the wrapper alive meanwhile.
• A failed flush parks the message again; it retries at the next compaction end or on
  Recall, and reports prompt_error either way.
• isPromptRunning reads true while a prompt is parked. Intended ("a prompt is pending"),
  but it is a new state the status polling can observe.
• /compact no longer answers "Command completed"; the compaction's own status line,
  result banner and error banner report it. Anyone keying on that toast will notice.