@workerdeck/ui 2.7.2 → 2.9.0

package/src/components/agent/SkillsDialog.tsx

@@ -42,7 +42,7 @@ export function SkillsDialog({ skills, open, onOpenChange, onUse, className }: S
               ? skill.name !== (skill.displayName ?? skill.name)
                 ? skill.name
                 : undefined
-              : 'Capabilities the agent can choose to use. Not commands — the model picks them from their descriptions.'
+              : 'Capabilities the agent can choose to use. Not commands - the model picks them from their descriptions.'
           }
           actions={
             skill ? (
@@ -67,7 +67,7 @@ export function SkillsDialog({ skills, open, onOpenChange, onUse, className }: S
 
 function SkillList({ skills, onSelect }: { skills: SkillInfo[] | undefined; onSelect: (name: string) => void }) {
   if (!skills) {
-    return <p className="py-6 text-center text-body-sm text-fg-4">Skills are listed once the session connects — send a message first.</p>
+    return <p className="py-6 text-center text-body-sm text-fg-4">Skills are listed once the session connects - send a message first.</p>
   }
   if (skills.length === 0) {
     return <p className="py-6 text-center text-body-sm text-fg-4">This session found no skills.</p>
@@ -142,7 +142,7 @@ function SkillView({ skill, onUse, onUsed }: { skill: SkillInfo; onUse?: (skill:
             Use this skill
           </Button>
           <p className="mt-1.5 text-label text-fg-4">
-            Writes an opening message into the composer for you to edit — it isn’t sent, and there is no command that runs a skill directly.
+            Writes an opening message into the composer for you to edit - it isn’t sent, and there is no command that runs a skill directly.
           </p>
         </div>
       ) : null}

package/src/components/agent/StatusBar.tsx

@@ -85,7 +85,7 @@ function RateLimitMeter({ label, info, now }: { label: string; info: RateLimitIn
         <div className="flex min-w-36 flex-col gap-1 py-0.5">
           <div className="flex items-center justify-between gap-2">
             <span>{label} usage</span>
-            <span className="font-mono text-fg-3">{pct !== undefined ? `${pct.toFixed(1)}%` : '—'}</span>
+            <span className="font-mono text-fg-3">{pct !== undefined ? `${pct.toFixed(1)}%` : '-'}</span>
           </div>
           {resetsAtMs !== undefined ? (
             <div className="flex items-center justify-between gap-2">

package/src/components/agent/TaskList.tsx

@@ -7,7 +7,7 @@ import { cn } from '../../lib/utils.ts'
 export interface TaskListProps {
   tasks: readonly SessionTask[]
   showCompleted: boolean
-  // Absent where the toggle lives outside this list — VS Code puts it in the view's title bar.
+  // Absent where the toggle lives outside this list - VS Code puts it in the view's title bar.
   onShowCompletedChange?: (showCompleted: boolean) => void
   onSelectTask?: (task: SessionTask) => void
   className?: string
@@ -36,7 +36,7 @@ export function TaskList({ tasks, showCompleted, onShowCompletedChange, onSelect
       </div>
       {shown.length === 0 ? (
         <p className="py-6 text-center text-body-sm text-fg-4">
-          {tasks.length === 0 ? 'No tasks yet — a checklist appears once the agent plans one.' : `${hidden} completed, all hidden.`}
+          {tasks.length === 0 ? 'No tasks yet - a checklist appears once the agent plans one.' : `${hidden} completed, all hidden.`}
         </p>
       ) : (
         <div className="flex flex-col">

package/src/components/agent/TranscriptRows.tsx

@@ -91,7 +91,7 @@ function StickyPromptLane({
 }
 
 // The virtualized row lane and its scroll-ownership regime. Two things want to write
-// `scrollTop` — the follow spring and the virtualizer's size-change corrections — and they are
+// `scrollTop` - the follow spring and the virtualizer's size-change corrections - and they are
 // split by regime here: pinned, corrections are suppressed outright; escaped, the virtualizer
 // corrects so the scrollback holds still (GOTCHAS "The transcript is virtualized").
 export function TranscriptRows({

package/src/components/agent/UsageDialog.tsx

@@ -44,7 +44,7 @@ export function UsageDialog({
           {rateLimits.length === 0 ? (
             <p className="py-6 text-center text-body-sm text-fg-4">
               {engine === 'claude'
-                ? 'This session reports no plan windows — API-key sessions have none, and a subscription session reports them once a turn has run.'
+                ? 'This session reports no plan windows - API-key sessions have none, and a subscription session reports them once a turn has run.'
                 : `Plan windows are a claude.ai subscription thing; this session runs on the ${engine} engine.`}
             </p>
           ) : (

package/src/components/agent/UsageMeters.tsx

@@ -1,5 +1,5 @@
 import { useEffect, useState } from 'react'
-import type { UsageWindowRow } from '@workerdeck/protocol'
+import { usageIsStale, type UsageWindowRow } from '@workerdeck/protocol'
 import { RotateCcw } from 'lucide-react'
 import { cn } from '../../lib/utils.ts'
 import { formatAgoPrecise, formatCountdown, formatRateLimitWindowLong, rateLimitWindowSeconds } from '../../lib/format.ts'
@@ -33,6 +33,9 @@ export function UsageMeters({ windows, now, className }: { windows: UsageWindowR
 function UsageMeter({ window, now }: { window: UsageWindowRow; now: number }) {
   const { key: windowKey, info, updatedAt, inferredReset } = window
   const utilization = info.utilization ?? 0
+  // Drawn differently rather than hidden: this is still the best answer anyone has, it is just not a claim about
+  // right now, and a stale reading asserted as current is how a number from two days ago passes for the truth.
+  const stale = usageIsStale(window, now)
   const resetsAtMs = info.resetsAt !== undefined ? info.resetsAt * 1000 : undefined
   const duration = rateLimitWindowSeconds(windowKey)
   const remaining = resetsAtMs !== undefined ? (resetsAtMs - now) / 1000 : undefined
@@ -44,13 +47,18 @@ function UsageMeter({ window, now }: { window: UsageWindowRow; now: number }) {
     <div>
       <div className="flex items-baseline justify-between gap-3">
         <span className="truncate text-body-sm text-fg-1">{formatRateLimitWindowLong(windowKey)}</span>
-        <span className={cn('shrink-0 font-mono text-body-sm font-medium', info.status === 'rejected' ? 'text-danger' : 'text-fg-1')}>
+        <span
+          className={cn(
+            'shrink-0 font-mono text-body-sm font-medium',
+            info.status === 'rejected' ? 'text-danger' : stale ? 'text-fg-4' : 'text-fg-1',
+          )}
+        >
           {utilization.toFixed(0)}% used
         </span>
       </div>
       <div className="relative mt-2 h-2 rounded-full bg-border">
         <div
-          className={cn('h-full rounded-full', meterTintClass(utilization))}
+          className={cn('h-full rounded-full', meterTintClass(utilization), stale && 'opacity-40')}
           style={{ width: `${Math.min(100, Math.max(2, utilization))}%` }}
         />
         {pace !== undefined ? (
@@ -71,7 +79,12 @@ function UsageMeter({ window, now }: { window: UsageWindowRow; now: number }) {
         {info.isUsingOverage ? <span className="text-warning">overage</span> : null}
         {info.status === 'rejected' ? <span className="text-danger">limit reached</span> : null}
         {inferredReset ? <span>window reset · nothing reported since</span> : null}
-        {updatedAt && !inferredReset ? <span>{formatAgoPrecise(updatedAt, now)}</span> : null}
+        {updatedAt && !inferredReset ? (
+          <span className={cn(stale && 'text-warning')}>
+            {stale ? 'last reported ' : ''}
+            {formatAgoPrecise(updatedAt, now)}
+          </span>
+        ) : null}
       </div>
     </div>
   )

package/src/components/agent/composer-commands.ts

@@ -0,0 +1,142 @@
+import type { SkillInfo, SlashCommandInfo } from '@workerdeck/protocol'
+
+export type ClientCommand = {
+  name: string
+  description: string
+  argumentHint?: string
+  // Selecting the row populates the composer with `/name ` instead of resolving to a chip, so the
+  // argument is typed before anything is submitted.
+  requiresArgs?: boolean
+  // True when the command consumed the input. False hands the text back to the engine, which is how
+  // `/model` with no argument still reaches a CLI that implements it natively.
+  run: (args: string) => boolean
+}
+
+export type ComposerRow =
+  | { kind: 'command'; name: string; description?: string; argumentHint?: string; aliases?: string[] }
+  | { kind: 'client'; name: string; description?: string; argumentHint?: string; command: ClientCommand }
+  | { kind: 'skill'; name: string; label: string; description?: string; enabled: boolean; scope?: string; skill: SkillInfo }
+
+const KIND_ORDER: Record<ComposerRow['kind'], number> = { command: 0, client: 1, skill: 2 }
+
+export function cleanCommandName(name: string): string {
+  return name.replace(/\s*\(MCP\)$/i, '')
+}
+
+export function skillPrompt(skill: SkillInfo): string {
+  const base = skill.defaultPrompt?.trim() || `Use the ${skill.displayName ?? skill.name} skill:`
+  return /\s$/.test(base) ? base : base + ' '
+}
+
+export function mergeComposerRows(sources: {
+  commands?: readonly SlashCommandInfo[]
+  clientCommands?: readonly ClientCommand[]
+  skills?: readonly SkillInfo[]
+}): ComposerRow[] {
+  const rows: ComposerRow[] = []
+  const engineNames = new Set<string>()
+  for (const command of sources.commands ?? []) {
+    const name = cleanCommandName(command.name)
+    if (engineNames.has(name)) {
+      continue
+    }
+    engineNames.add(name)
+    for (const alias of command.aliases ?? []) {
+      engineNames.add(cleanCommandName(alias))
+    }
+    rows.push({ kind: 'command', name, description: command.description, argumentHint: command.argumentHint, aliases: command.aliases })
+  }
+  for (const command of sources.clientCommands ?? []) {
+    if (engineNames.has(command.name)) {
+      continue
+    }
+    rows.push({ kind: 'client', name: command.name, description: command.description, argumentHint: command.argumentHint, command })
+  }
+  for (const skill of sources.skills ?? []) {
+    rows.push({
+      kind: 'skill',
+      name: skill.name,
+      label: skill.displayName ?? skill.name,
+      description: skill.shortDescription ?? skill.description,
+      enabled: skill.enabled,
+      scope: skill.scope,
+      skill,
+    })
+  }
+  return rows
+}
+
+function haystacks(row: ComposerRow): string[] {
+  if (row.kind === 'skill') {
+    return [row.name, row.label, ...row.name.split(/[-:_]/)]
+  }
+  return [row.name, ...(row.kind === 'command' ? (row.aliases ?? []) : []), ...row.name.split(':')]
+}
+
+export function matchScore(query: string, candidates: readonly string[]): number {
+  const needle = query.toLowerCase()
+  const lowered = candidates.map((s) => s.toLowerCase())
+  if (lowered.some((h) => h.startsWith(needle))) {
+    return 2
+  }
+  return lowered.some((h) => h.includes(needle)) ? 1 : 0
+}
+
+export function rankComposerRows(query: string, rows: readonly ComposerRow[]): ComposerRow[] {
+  const scored: Array<{ score: number; index: number; row: ComposerRow }> = []
+  rows.forEach((row, index) => {
+    if (row.kind === 'skill' && !row.enabled) {
+      return
+    }
+    const score = matchScore(query, haystacks(row))
+    if (score > 0) {
+      scored.push({ score, index, row })
+    }
+  })
+  scored.sort((a, b) => b.score - a.score || KIND_ORDER[a.row.kind] - KIND_ORDER[b.row.kind] || a.index - b.index)
+  return scored.map(({ row }) => row)
+}
+
+export function matchClientCommand(text: string, commands: readonly ClientCommand[]): { command: ClientCommand; args: string } | undefined {
+  const match = /^\/([\w:-]+)[ \t]*([\s\S]*)$/.exec(text.trim())
+  if (!match) {
+    return undefined
+  }
+  const command = commands.find((c) => c.name === match[1])
+  return command ? { command, args: match[2]!.trim() } : undefined
+}
+
+// The serializable projection a native host (the VS Code QuickPick) renders. `insertText` is resolved here
+// so no second surface reimplements skillPrompt or the leading slash.
+export type ComposerCommandRow = {
+  kind: ComposerRow['kind']
+  name: string
+  label: string
+  description?: string
+  scope?: string
+  enabled: boolean
+  insertText: string
+}
+
+export function composerCommandRows(rows: readonly ComposerRow[]): ComposerCommandRow[] {
+  return rows.map((row) =>
+    row.kind === 'skill'
+      ? {
+          kind: row.kind,
+          name: row.name,
+          label: row.label,
+          description: row.description,
+          scope: row.scope,
+          enabled: row.enabled,
+          insertText: skillPrompt(row.skill),
+        }
+      : {
+          kind: row.kind,
+          name: row.name,
+          label: `/${row.name}`,
+          description: row.description,
+          enabled: true,
+          insertText: `/${row.name} `,
+        },
+  )
+}

package/src/components/agent/use-path-links.ts

@@ -1,4 +1,5 @@
 import { useEffect, type RefObject } from 'react'
+import { parseFileLink } from '../../lib/file-link.ts'
 
 export type PathHit = { path: string; line?: number }
 
@@ -119,11 +120,5 @@ export function usePathLinks({
 }
 
 export function resolveAgainstCwd(path: string, cwd: string | undefined): string {
-  if (path.startsWith('/')) {
-    return path
-  }
-  if (!cwd) {
-    return path
-  }
-  return `${cwd.replace(/\/$/, '')}/${path.replace(/^\.\//, '')}`
+  return parseFileLink(path, cwd)?.path ?? path
 }

package/src/components/agent/use-subagent-frame.ts

@@ -6,7 +6,7 @@ import { subagentItems, type ToolCallItem } from '../terminal/blocks.ts'
 // The sub-agent frame machine: which agent frame is on screen, how it is entered (a host
 // `openSubagent` request or a Task row in the transcript), how it is left (Escape, the strip's
 // Back, or the host withdrawing), and what the transcript reveals on the way out. The frame
-// round-trips through the host's URL — the anti-loop rules live in GOTCHAS ("The sub-agent
+// round-trips through the host's URL - the anti-loop rules live in GOTCHAS ("The sub-agent
 // frame round-trips through the URL"); here they mean: entry keys on the nonce alone, and the
 // report is deduped through a ref, so an echo of our own report is inert on arrival.
 export function useSubagentFrame(options: {
@@ -51,7 +51,7 @@ export function useSubagentFrame(options: {
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [openSubagentNonce])
 
-  // A reveal targets the root transcript, so it closes whatever frame is open — without the
+  // A reveal targets the root transcript, so it closes whatever frame is open - without the
   // return reveal, which would fight the requested one.
   const revealNonce = reveal?.nonce
   useEffect(() => {

package/src/components/agent/use-transcript-jumps.ts

@@ -7,12 +7,12 @@ import { gapBefore, type TranscriptRow } from './transcript-rows.ts'
 const AIM_PASSES = 4
 const AIM_SETTLE_MS = 50
 
-// How long a send's re-pin outlasts the click — long enough to eat a trackpad's momentum tail.
+// How long a send's re-pin outlasts the click - long enough to eat a trackpad's momentum tail.
 export const REPIN_HOLD_MS = 750
 
 type RepinTarget = Pick<ReturnType<typeof useStickToBottomContext>, 'scrollToBottom' | 'state'>
 
-// The send re-pin: a held, escape-proof pin, not one `scrollToBottom('instant')` — a trackpad's
+// The send re-pin: a held, escape-proof pin, not one `scrollToBottom('instant')` - a trackpad's
 // trailing momentum tick reads as escape intent and aborts the one-shot before its first frame
 // (GOTCHAS "The send re-pin is a held pin"). Every line is load-bearing: clear the stale escape
 // flag, hold through the momentum tail, seed the `ignoreEscapes` record the library only

package/src/components/prompt-area/clipboard-helpers.ts

@@ -19,7 +19,7 @@ function isRecord(value: unknown): value is Record<string, unknown> {
  * corresponding node kind encountered during a depth-first walk.
  */
 type FragmentVisitor = {
-  /** A text node — receives its text content (may be empty). */
+  /** A text node - receives its text content (may be empty). */
   onText: (text: string) => void
   /** A chip element (has `data-chip-trigger`). */
   onChip: (node: HTMLElement) => void
@@ -191,7 +191,7 @@ export function insertSegmentsAtCursor(currentSegments: Segment[], pastedSegment
       insertOnce()
       result.push(seg)
     } else {
-      // Cursor falls inside this text segment — split it.
+      // Cursor falls inside this text segment - split it.
       const splitAt = cursorOffset - offset
       const before = seg.text.slice(0, splitAt)
       const after = seg.text.slice(splitAt)

package/src/components/prompt-area/cursor-helpers.ts

@@ -3,12 +3,12 @@
  *
  * Invariants:
  * - All functions are synchronous. Never return a promise or cross a microtask
- *   boundary after a DOM mutation — that can cause the browser to fire
+ *   boundary after a DOM mutation - that can cause the browser to fire
  *   `selectionchange` and reset the caret.
  * - Never cache a `Selection` or `Range` across calls. Ranges become detached
  *   after DOM mutations. Each function calls `window.getSelection()` or
  *   `getSelectionRange()` fresh.
- * - Chip nodes are treated atomically via `isChipElement` — we never descend
+ * - Chip nodes are treated atomically via `isChipElement` - we never descend
  *   into a contentEditable=false subtree when mapping offsets.
  */
 import {
@@ -120,11 +120,11 @@ export function createRangeAtOffset(editor: HTMLElement, targetOffset: number):
  * Where the caret is on screen, in viewport coordinates.
  *
  * A collapsed range usually measures fine, but not when it sits *between* child
- * nodes of an element — which is exactly where a freshly inserted newline puts
+ * nodes of an element - which is exactly where a freshly inserted newline puts
  * it, because this editor's content is a flat run of text nodes and `<br>`s
  * directly under the editor element. There `getBoundingClientRect()` is all
  * zeros, and the obvious fallback (measure `startContainer`'s element) resolves
- * to the editor itself, whose rect is the viewport box — so it reports the
+ * to the editor itself, whose rect is the viewport box - so it reports the
  * caret as trivially visible and scrolls nothing.
  *
  * So measure the neighbour instead: the child the caret sits before, or failing
@@ -163,14 +163,14 @@ function caretRect(range: Range): DOMRect | null {
  * The editor is its own scroll container once it hits `maxHeight`
  * (`prompt-area.tsx` sets `overflowY: auto` there). Typing scrolls the caret
  * into view for free, because that is the browser's own behaviour for a native
- * edit — but every path that calls `preventDefault()` and rebuilds the DOM
+ * edit - but every path that calls `preventDefault()` and rebuilds the DOM
  * itself (Shift+Enter, list continuation, undo/redo, the bold/italic wrap,
  * paste) places the caret with a Range instead, and setting a selection does
  * not scroll anything. The symptom is a prompt that has grown past its cap and
  * stops following what you are writing: type and it scrolls, press Shift+Enter
  * and the new line appears below the fold.
  *
- * A no-op when the caret is already visible, so it is safe on every call — it
+ * A no-op when the caret is already visible, so it is safe on every call - it
  * corrects an off-screen caret rather than scrolling to one.
  */
 export function scrollCaretIntoView(editor: HTMLElement): void {
@@ -334,7 +334,7 @@ export function findDOMPosition(container: HTMLElement, targetOffset: number): {
       }
       remaining -= 1
     } else if (isHTMLElement(child)) {
-      // Decoration element (markdown span, URL anchor) — recurse
+      // Decoration element (markdown span, URL anchor) - recurse
       const textLen = (child.textContent ?? '').length
       if (remaining <= textLen) {
         const result = findDOMPosition(child, remaining)

package/src/components/prompt-area/dom-helpers.ts

@@ -73,7 +73,7 @@ export function isLinkElement(node: Node): node is HTMLAnchorElement {
 export function safeJsonParse(json: string): unknown {
   try {
     // JSON.parse returns `any` by default. We narrow it to `unknown`
-    // which is the safest pattern — callers must validate before use.
+    // which is the safest pattern - callers must validate before use.
     const parsed: unknown = JSON.parse(json)
     return parsed
   } catch {
@@ -208,11 +208,11 @@ export function indexOfChildNode(parent: HTMLElement, child: Node): number {
  * `readSegmentsFromDOM` in use-prompt-area.ts. This is the single predicate
  * shared with `domChildIndexToSegmentIndex` below, so a DOM child index can
  * never map to a different segment index than the one the reader actually
- * produces — decoration elements (the URL `<a>` from `decorateURLsInEditor`,
+ * produces - decoration elements (the URL `<a>` from `decorateURLsInEditor`,
  * the markdown `<span data-md>` from `decorateMarkdownInEditor`) fall through
  * to the reader's "unknown element" branch and DO produce a text segment, so
  * they must count here too, not just chips/text/`<br>`. A chip element only
- * counts if `chipNodeToSegment` would actually accept it — the reader skips a
+ * counts if `chipNodeToSegment` would actually accept it - the reader skips a
  * chip missing a required attribute (trigger/value/display), so this must too.
  */
 export function childProducesSegment(child: Node): boolean {
@@ -348,7 +348,7 @@ export function normalizeEditorDOM(editor: HTMLElement): boolean {
  * Walks direct-child text nodes in the editor and wraps URL text in
  * `<a>` elements for visual styling and clickability.
  *
- * This is a DOM-only decoration — it does NOT modify the segment model.
+ * This is a DOM-only decoration - it does NOT modify the segment model.
  * The `<a>` elements are stripped by `normalizeEditorDOM` on every input cycle,
  * so they are re-applied fresh each time.
  *
@@ -393,7 +393,7 @@ export function decorateURLsInEditor(editor: HTMLElement): boolean {
       continue
     }
 
-    // Validate URLs upfront – only keep those with safe protocols (CWE-79)
+    // Validate URLs upfront - only keep those with safe protocols (CWE-79)
     const safeMatches: Array<{ url: string; href: string; index: number }> = []
     for (const { url, index } of matches) {
       try {
@@ -447,7 +447,7 @@ export function decorateURLsInEditor(editor: HTMLElement): boolean {
  * Walks direct-child text nodes in the editor and wraps markdown-formatted
  * text (`**bold**`, `*italic*`, `***bold-italic***`) in styled `<span>` elements.
  *
- * This is a DOM-only decoration — it does NOT modify the segment model.
+ * This is a DOM-only decoration - it does NOT modify the segment model.
  * The `<span>` elements are stripped by `normalizeEditorDOM` on every input cycle,
  * so they are re-applied fresh each time.
  *
@@ -529,7 +529,7 @@ export function decorateMarkdownInEditor(editor: HTMLElement): boolean {
         fragment.appendChild(document.createTextNode(text.slice(lastIndex, index)))
       }
 
-      // Parent span — textContent still returns full match (e.g. "**world**")
+      // Parent span - textContent still returns full match (e.g. "**world**")
       const span = document.createElement('span')
       span.dataset.md = 'true'
 
@@ -642,7 +642,7 @@ export function decorateBulletsInEditor(editor: HTMLElement): boolean {
  * unchanged) and is stripped by {@link normalizeEditorDOM} each input cycle.
  * Must run BEFORE the node-splitting passes ({@link decorateURLsInEditor},
  * {@link decorateMarkdownInEditor}, {@link decorateBulletsInEditor}) so every
- * direct-child text node is still a whole line — otherwise a mid-line split
+ * direct-child text node is still a whole line - otherwise a mid-line split
  * fragment beginning with whitespace would let the `^` anchor false-match
  * non-line-leading whitespace.
  *

package/src/components/prompt-area/html-to-markdown.ts

@@ -240,7 +240,7 @@ function serializeNode(node: Node, depth: number): string {
       return `\n\n${serializeList(node, depth)}\n\n`
     }
     case 'LI': {
-      // A stray <li> outside a list wrapper — emit its content as a line.
+      // A stray <li> outside a list wrapper - emit its content as a line.
       return `${serializeChildren(node, depth).trim()}\n`
     }
     case 'PRE': {
@@ -284,7 +284,7 @@ function normalizeOutput(markdown: string): string {
 /**
  * Converts an HTML string to markdown source text. Returns '' for empty or
  * body-less input. Block markdown (headings, lists, quotes, fences, tables,
- * links) is emitted as literal markdown text — that is the editor's intended
+ * links) is emitted as literal markdown text - that is the editor's intended
  * display; only `*`/`**`/`***` and bare URLs get visually decorated inline.
  */
 export function htmlToMarkdown(html: string): string {

package/src/components/prompt-area/prompt-area-engine.ts

@@ -77,7 +77,7 @@ export function truncateSegmentsToLength(segments: Segment[], maxLength: number)
  * in the editor model: a space, newline, or tab.
  *
  * Trigger detection, paste auto-resolution, and position validation all rely
- * on the *same* notion of a boundary — keeping it here prevents the three
+ * on the *same* notion of a boundary - keeping it here prevents the three
  * call sites from silently drifting apart (e.g. one handling tabs and the
  * others not).
  */
@@ -284,7 +284,7 @@ export function resolveChip(
  * The sibling of {@link resolveChip}, for suggestions that are a typing aid
  * rather than a token: what lands in the document is ordinary editable text the
  * user is expected to finish and change, and it must not look or behave like a
- * resolved chip — no immutability, no trigger character, nothing for a consumer
+ * resolved chip - no immutability, no trigger character, nothing for a consumer
  * to parse back out. The caret is left at the end of the inserted text so typing
  * continues from there.
  */
@@ -303,7 +303,7 @@ export function resolveText(
   for (const seg of segments) {
     if (seg.type === 'chip') {
       const chipEnd = offset + `${seg.trigger}${seg.displayText}`.length
-      // A trigger range can never overlap a chip — chips are atomic — so a chip
+      // A trigger range can never overlap a chip - chips are atomic - so a chip
       // is either wholly before or wholly after, and is kept either way.
       if (chipEnd <= triggerStart || offset >= triggerEnd) {
         newSegments.push(seg)
@@ -444,7 +444,7 @@ function splitTextByTriggerPatterns(text: string, triggerByChar: Map<string, Tri
           const query = text.slice(i + 1, end)
           if (query.length > 0) {
             // Treat both undefined and '' from onSelect as "no custom label"
-            // and fall back to the query — an empty displayText would render
+            // and fall back to the query - an empty displayText would render
             // a blank chip.
             const displayText = trigger.onSelect?.({ value: query, label: query }) || query
             segments.push({

package/src/components/prompt-area/prompt-area-list-ops.ts

@@ -1,6 +1,6 @@
 /**
  * List auto-formatting logic for the PromptArea component.
- * Pure — no DOM dependencies, fully testable in Node.
+ * Pure - no DOM dependencies, fully testable in Node.
  */
 import type { Segment } from './types.ts'
 import { replaceTextRange, segmentsToPlainText } from './prompt-area-engine.ts'
@@ -26,7 +26,7 @@ export type ListContext = {
 }
 
 /**
- * Parsed shape of a single list line — the SINGLE source of truth for what
+ * Parsed shape of a single list line - the SINGLE source of truth for what
  * counts as a list line (both `getListContext` and the renumber engine derive
  * from this, so the bullet/number regexes live in exactly one place).
  *
@@ -127,7 +127,7 @@ export function autoFormatListPrefix(segments: Segment[], cursorPos: number): {
 }
 
 /**
- * Handles Enter key in a list line — continues the list or exits.
+ * Handles Enter key in a list line - continues the list or exits.
  */
 export function insertListContinuation(segments: Segment[], cursorPos: number): { segments: Segment[]; cursorOffset: number } | null {
   const plainText = segmentsToPlainText(segments)
@@ -186,8 +186,8 @@ function getPrevListLineLevel(text: string, lineStart: number): number | null {
 /**
  * Indents a list item by one level (adds 2 spaces before the prefix), capped at
  * one level deeper than the line above. An item can only nest under a preceding
- * sibling, so the first item of a list — or an item already one level below its
- * parent — cannot indent further (returns null). This keeps sub-items visually
+ * sibling, so the first item of a list - or an item already one level below its
+ * parent - cannot indent further (returns null). This keeps sub-items visually
  * connected to a parent instead of drifting arbitrarily deep.
  */
 export function indentListItem(segments: Segment[], cursorPos: number): { segments: Segment[]; cursorOffset: number } | null {
@@ -259,8 +259,8 @@ function swapListPrefixLine(line: string, markdownEnabled: boolean): string {
 /**
  * Returns the set of line indices that sit inside a *balanced* fenced code
  * block (a ```…``` pair), so their leading "- "/"• " markers are preserved
- * verbatim. An unterminated (unpaired) fence marker is NOT protective — its
- * following lines still normalize — so a stray "```" in prose does not silently
+ * verbatim. An unterminated (unpaired) fence marker is NOT protective - its
+ * following lines still normalize - so a stray "```" in prose does not silently
  * suppress bullet normalization for the rest of the text.
  */
 function fenceProtectedLineIndices(lines: string[]): Set<number> {
@@ -351,12 +351,12 @@ export function normalizeListPrefixes(segments: Segment[], markdownEnabled: bool
 export type NumberEdit = { oldStart: number; oldEnd: number; newText: string }
 
 /**
- * Whether the text holds a genuine ordered-list run worth renumbering — a run
+ * Whether the text holds a genuine ordered-list run worth renumbering - a run
  * of 2+ consecutive same-level numbered lines that either starts at 1 or is
  * already a contiguous `n, n+1, …` sequence. Used to gate the paste path so a
  * copied list fragment (`3. 4. 5.` → renumber, or a broken `1. 1. 1.`) is
  * rebuilt, while incidental numeric-leading prose that `parseListLine` would
- * otherwise treat as a list — `1985. Born / 2020. Died`, `5. / 10. / 15.` — is
+ * otherwise treat as a list - `1985. Born / 2020. Died`, `5. / 10. / 15.` - is
  * left untouched.
  */
 export function hasOrderedListRun(text: string): boolean {
@@ -395,7 +395,7 @@ export function hasOrderedListRun(text: string): boolean {
  * Recomputes ordered-list numbering across the whole text. Returns the new text
  * plus the list of changed digit runs (ascending by `oldStart`) for cursor
  * remapping. When nothing changes, returns the SAME text reference and an empty
- * `edits` array — the no-op guard that keeps this off the typing hot path.
+ * `edits` array - the no-op guard that keeps this off the typing hot path.
  */
 export function renumberOrderedListLines(text: string): { text: string; edits: NumberEdit[] } {
   // Cheap pre-gate: with no ordered-list line there is nothing to renumber, so

package/src/components/prompt-area/prompt-area.tsx

@@ -277,7 +277,7 @@ export function PromptArea({
     ) : null
 
   // Typography (font-size/line-height) lives on the container, not the editor, so
-  // it cascades to the editor AND the placeholder overlays — and a consumer can
+  // it cascades to the editor AND the placeholder overlays - and a consumer can
   // override all three at once via `className` (e.g. `text-base leading-6`).
   return (
     <div className={cn('prompt-area-container relative text-sm leading-relaxed', className)}>
@@ -316,7 +316,7 @@ export function PromptArea({
           onBlur={handleBlurCombined}
         />
 
-        {/* Overflow gradient indicator – visible when auto-grow is collapsed and content is clipped */}
+        {/* Overflow gradient indicator - visible when auto-grow is collapsed and content is clipped */}
         {autoGrow && hasOverflow && !isFocused && (
           <div
             aria-hidden="true"