Add cmd-mark pill awareness to getNodeLength, setCursorPosition, and setRangeEdge.
A slash-command pill uses data-cmd-mark="true" and data-name=<name>; its logical
offset length is 1 + name.length (slash trigger + name), while textContent is only
name. The cmd-mark branch in getNodeLength is placed before the textContent fallback
so the asymmetry is preserved. Both isPill predicates in setCursorPosition and
setRangeEdge now include the data-cmd-mark check alongside data-type file/agent.

Tests: 3 new cases covering getNodeLength value, branch-order asymmetry, and
setCursorPosition snap behavior; all 1312 tests pass.

…lisation

- Add createCommandMark() that builds the pill DOM: outer span with
  data-cmd-mark/name/source/icon + contenteditable=false, icon child
  (data-cmd-icon, class=command-icon, innerHTML from resolveCommandIconSvg),
  label child (data-cmd-label, textContent = name, no slash).
- renderPartsToEditor: index-0 TextPart with .command → pill + tail fragment;
  tail = content.slice(1 + name.length) preserving separator + args verbatim.
- parseEditorToParts: before main visit loop, detect leading data-cmd-mark child.
  Walk siblings collecting followingTextRun (text nodes, BR as \n); stop at
  file/agent/cmd-mark boundary. Push marked TextPart content = "/" + name + run.
  Skip consumed nodes by slicing children from startIndex = 1 + consumedSiblings.
- Mid-stream data-cmd-mark (not at index 0) falls through to visit()'s
  recursive-children branch: label textContent surfaced as plain text, no
  command metadata emitted.
- Import command-pill.css via side-effect import.
- Add editor-serialize.test.ts: pill DOM attrs, round-trips for "/cmd ",
  "/cmd args", "/cmd  args" (double-space), self-heal mid-stream pill.

Replace the plain TextPart in the command branch of extractPromptFromParts
with createCommandTextPart so the restored Prompt carries the command field.
The editor can then re-render the pill instead of falling back to raw text.

Plain-prompt and image-attachment branches are unchanged byte-for-byte.
Tests now assert command: { name, source } on all three command-mode cases.

… E1)

…xtPart

…ction

Helper module + tests. The editor-input.ts/prompt-input.tsx wiring landed in the preceding Path B commit since they share the same file.

…nput

When the user opens the slash popover by typing `/<query>` and then
selects a command from the popover, the previous code prepended the
marked TextPart without removing the typed slash literal, producing
`[marked, Text("/foo")]` with a leftover slash. Detect the slash-query
shape ([Text("/<query>")]) and replace instead of prepend.

Empty prompt and slash-query state both go through the replace branch;
the E1 branch keeps the prepend-with-original-content semantics for
non-empty unrelated prompts.

getTextLength and isNormalizedEditor both walked the DOM without
recognising the command pill. getCursorPosition feeds cloned ranges
through getTextLength, so caret math after a pill was off by one
(visible label has only `name.length` chars but the logical length
is `1 + name.length` for the implicit slash). isNormalizedEditor
returning false on a normal pill child forced the reconcile pass to
rebuild the entire editor on every keystroke, moving the caret and
breaking IME composition.

Both primitives now treat a `data-cmd-mark="true"` element the same
way getNodeLength already did: as an opaque pill whose logical length
is `1 + dataset.name.length`.

Switching to a second command via prependCommandMark drops the old
args along with the old marked TextPart. The previous commit already
behaved this way via `current.slice(1)`, but the intent was only
implicit. Add a test that asserts `content === "/new "` after
switching from `/old hello world`, plus a comment explaining the
product reasoning: a pill is an atomic unit, and args carry the old
command's semantics that may not map to the new command (e.g.
/summarize "the diff" → /translate would silently feed mismatched
arguments). This kills any ambiguity about whether args-drop was
incidental or intended.

The previous commit dropped old args on command switch out of an
overcautious "args might not fit the new command" reasoning. That
reasoning does not survive contact with the actual command system:
built-in commands like /review and /init both use \$ARGUMENTS as a
plain string substitution (e.g. `git show \$ARGUMENTS`,
`git diff \$ARGUMENTS...HEAD`), and most plugin commands do the same.
There is no schema enforcing what args mean, so any text the user
kept is still legitimate input.

Silently deleting args the user already typed costs them real work
and is not recoverable by re-selecting the original command. The
user can see the args in the editor; if they no longer fit the new
command, they remove them themselves.

Extract args from the leading marked TextPart's content (everything
after the `/<name> ` prefix) and feed them into createCommandTextPart
for the new command. Tail parts (files, agents, images) still
survive by identity. Test reversed to assert args carry over, plus
an empty-args case covering the trailing-space invariant.

Path A/B/C all wrote the new marked Prompt straight into the prompt
store and returned, bypassing the homepage owner mirror logic at the
end of handleInput. Result: a user who turned a slash query into a
pill on the homepage, then navigated away and came back, lost the
pill — the owner still held the pre-pill raw text and replayed that
on hydration. Same shape as the args-drop bug — the system silently
discarded work the user did.

Move the portable/pinned record() call into its own createEffect on
prompt.current() + prompt.context.items() + imageAttachments(). Every
mutation of the prompt store now flows through the same mirror,
regardless of which path produced it. handleInput's tail-only
duplicate is removed, as is the shouldReset branch's explicit
owner clear — both are subsumed by the effect (portable.record()
treats an empty payload as "clear snapshot", so reset still works).

No loop risk: portable.record() and pinned.recordEdit() both dedupe
by deep-equal payload, so hydration paths that set the prompt to
the owner's own snapshot are a no-op on re-record.

Test added to portable-draft.test.ts: a marked TextPart survives a
record + restore + consumeForHomepage round-trip with its command
field intact, pinning the contract the owner has to honor.

The mirror effect introduced last commit fires at mount with the
prompt store's default empty state. Both owner implementations treat
an empty payload as destructive: portable.record() clears the
snapshot via setSnapshot(null), and pinned.recordEdit() overwrites
the existing slot's content in place. Because the mirror effect is
declared before the hydration effect in createEditorInput, the
mount-time fire ran first and destroyed any pending portable
snapshot or pinned prefill before hydration had a chance to
consume them. Net effect: a homepage A→B navigation lost A's
draft, and a pinned prefill on mount got wiped to empty.

Add {defer: true} to the mirror effect's `on()` so the effect
skips its mount-time invocation and waits for the first real
prompt change. That change is whichever comes first: hydration
replaying a snapshot into the prompt (in which case the resulting
record() call is a deep-equal no-op against the owner's own
snapshot, no destructive overwrite), or the user typing
(legitimate record). A fresh homepage with no owner data simply
stays quiet until the user does something.

Two regression guards added to pin the hazard the defer:true
protects against — empty payload through portable.record()
destroys the snapshot, and empty payload through
pinned.recordEdit() overwrites the prefill in place. Anyone
reorganizing the mirror effect will see exactly what they're
defending against.

prompt.current() is session-keyed by {dir, id} in the prompt binding, so
homepage A -> homepage B navigation flips prompt.current() to the new
session's DEFAULT_PROMPT. defer:true only protects the initial mount fire;
the subsequent scope-swap fire would record an empty payload against the
new directory and destroy the snapshot held for the old one before the
hydration effect can move it.

Track lastSeenDir / lastSeenSessionID in the mirror effect and skip the
first fire after either changes. Hydration then runs and either applies a
pinned prefill or consumes a portable carry; the resulting prompt change
re-wakes the effect with refs updated, and recording proceeds normally
(deep-equal dedupe against the snapshot's own contents is a no-op).

Browsers usually fire an additional input event after compositionend with
inputType="insertCompositionText" and composing=false, which would wake
the mirror effect via handleInput. Not all browsers/input methods do; on
those, the final committed prompt sits in the store but never reaches
portable.record() / pinned.recordEdit(), so a draft committed via IME
alone is lost on next homepage navigation.

Add composing() to the mirror effect's tracked deps. The false->true
transition fires the effect (skipped immediately by the compose guard);
the true->false transition fires the effect with the post-commit prompt
and records it. Scope-change refs are unaffected because dir/sessionID
don't change across a compositionend.

…in tests

The mirror effect is the single source of truth for portable/pinned draft
recording. Pull it into owner-mirror.ts so the decision branches (composing
skip, session-route skip, scope-change skip, pinned vs portable routing)
can be exercised directly without going through createEffect.

Tests drive applyOwnerMirrorTick with synthetic state. They cover:
  - IME compositionend records the committed prompt without relying on a
    post-compose input event
  - session-route ticks return skip-session and leave both owners alone
  - homepage A -> homepage B navigation returns skip-scope and preserves
    the snapshot held for the old directory
  - pinned slot bound to the current dir routes to pinned (portable
    untouched); slot bound elsewhere routes to portable

`{defer: true}` on the wrapping createEffect is a SolidJS framework primitive
and is not exercised here; bun's test runner resolves solid-js to its
server build, where createEffect is a no-op. The pinned-draft.test.ts /
portable-draft.test.ts hazard-pin tests at the owner layer remain the
canonical proof of why defer matters.