ompchamber 0.8.0 → 1.1.0

package/src/shared/lib/chat/composer/commands.ts

@@ -0,0 +1,290 @@
+import type { ComposerMatchItem, ComposerPickItem, ComposerSubcommand } from '@/shared/types';
+import { SKILL_NAMESPACE, SKILL_NAMESPACE_TOKEN } from '@/shared/lib/chat/composer/trigger';
+
+/**
+ * Slash-command ranking, ported from oh-my-pi's `pi-tui/autocomplete.ts`
+ * (`scoreCommandTextMatch`, `skillBareNameBreakoutTier`, `collapseSkillNamespace`,
+ * `buildSlashCommandCompletions`, `buildArgumentCompletions`). Keeping the
+ * formulas identical is the point: the chamber's popup must order and match
+ * `/`-tokens exactly like the CLI it drives.
+ */
+
+/** Subsequence match, oh-my-pi's `subsequenceMatch`. */
+function subsequenceMatch(query: string, target: string): boolean {
+  if (query.length === 0) return true;
+  if (query.length > target.length) return false;
+
+  let qi = 0;
+  for (let ti = 0; ti < target.length && qi < query.length; ti++) {
+    if (query[qi] === target[ti]) qi++;
+  }
+  return qi === query.length;
+}
+
+/** Ranked-tier subsequence score (100/80/60/40−gaps·5); higher is better, 0 is no match. */
+function subsequenceScore(query: string, target: string): number {
+  if (query.length === 0) return 1;
+  if (target === query) return 100;
+  if (target.startsWith(query)) return 80;
+  if (target.includes(query)) return 60;
+
+  let qi = 0;
+  let gaps = 0;
+  let lastMatchIdx = -1;
+  for (let ti = 0; ti < target.length && qi < query.length; ti++) {
+    if (query[qi] === target[ti]) {
+      if (lastMatchIdx >= 0 && ti - lastMatchIdx > 1) gaps++;
+      lastMatchIdx = ti;
+      qi++;
+    }
+  }
+  if (qi !== query.length) return 0;
+
+  return Math.max(1, 40 - gaps * 5);
+}
+
+/**
+ * oh-my-pi's `scoreCommandTextMatch`. Prefix matches share one flat score so
+ * same-prefix commands keep their list order; a length penalty here would rank
+ * the shorter name first (e.g. `/set` → `setup` above `settings`).
+ */
+function scoreCommandTextMatch(lowerPrefix: string, lowerTarget: string): number {
+  if (lowerPrefix.length === 0) return 1;
+  if (lowerPrefix === lowerTarget) return 1000;
+  if (lowerTarget.startsWith(lowerPrefix)) return 900;
+  return subsequenceMatch(lowerPrefix, lowerTarget) ? subsequenceScore(lowerPrefix, lowerTarget) : 0;
+}
+
+/** Exact/leading-prefix tier for ordinary command names and aliases. */
+function commandBreakoutTier(lowerPrefix: string, lowerTarget: string): number {
+  if (lowerPrefix === lowerTarget) return 1000;
+  if (lowerTarget.startsWith(lowerPrefix)) return 900;
+  return 0;
+}
+
+/**
+ * Match a bare skill name from the beginning of any hyphen-delimited segment
+ * (oh-my-pi's `skillBareNameBreakoutTier`), so `/last` surfaces
+ * `skill:research-last30days`.
+ */
+function skillBareNameBreakoutTier(lowerPrefix: string, lowerBareName: string): number {
+  if (lowerPrefix.length === 0) return 0;
+  if (lowerPrefix === lowerBareName) return 1000;
+  if (lowerBareName.startsWith(lowerPrefix)) return 900;
+
+  let segmentStart = 0;
+  while (segmentStart < lowerBareName.length) {
+    while (segmentStart < lowerBareName.length && lowerBareName.charCodeAt(segmentStart) !== 45) {
+      segmentStart += 1;
+    }
+    segmentStart += 1;
+    if (segmentStart >= lowerBareName.length) break;
+
+    if (lowerBareName.startsWith(lowerPrefix, segmentStart)) {
+      let segmentEnd = segmentStart;
+      while (segmentEnd < lowerBareName.length && lowerBareName.charCodeAt(segmentEnd) !== 45) {
+        segmentEnd += 1;
+      }
+      return lowerPrefix.length === segmentEnd - segmentStart ? 1000 : 900;
+    }
+  }
+
+  return 0;
+}
+
+/**
+ * Whether a mid-prompt slash token (`prose … /tok`) is skill-shaped enough to
+ * surface `name` (oh-my-pi's `midPromptSkillTokenMatches`). Deliberately
+ * stricter than submitted-command matching: a stray `/word` in running prose
+ * must not keep the popup alive through fuzzy name/description hits.
+ */
+function midPromptSkillTokenMatches(lowerToken: string, name: string, description: string): boolean {
+  if (SKILL_NAMESPACE.startsWith(lowerToken)) return true;
+  const lowerName = name.toLowerCase();
+  if (lowerToken.startsWith(SKILL_NAMESPACE)) {
+    if (scoreCommandTextMatch(lowerToken, lowerName) > 0) return true;
+    return description.length > 0 && scoreCommandTextMatch(lowerToken, description.toLowerCase()) > 0;
+  }
+  return (
+    lowerName.startsWith(SKILL_NAMESPACE) &&
+    skillBareNameBreakoutTier(lowerToken, lowerName.slice(SKILL_NAMESPACE.length)) > 0
+  );
+}
+
+/** The collapsed `/skill:` group row: one entry standing in for every skill. */
+function skillNamespaceRow(skillCount: number): ComposerPickItem {
+  return {
+    id: 'command-skill-namespace',
+    name: SKILL_NAMESPACE,
+    description: `${skillCount} skill${skillCount === 1 ? '' : 's'}`,
+    kind: 'skill',
+    source: 'skill',
+    token: SKILL_NAMESPACE_TOKEN,
+    // Accepted without a trailing space so the popup reopens on the individual
+    // skills — oh-my-pi's namespace-row accept path.
+    insertWithoutSpace: true,
+  };
+}
+
+/**
+ * Collapse `skill:*` entries into a single `/skill:` namespace row while the
+ * typed prefix has not committed to the namespace (oh-my-pi's
+ * `collapseSkillNamespace`). A skill breaks out of the group only when its bare
+ * name matches the prefix at the beginning of the name or a hyphen-delimited
+ * segment, at a strictly stronger tier than every non-skill command name and
+ * alias; a tie keeps the popup command-only, and fuzzy-only skill hits never
+ * surface.
+ */
+function collapseSkillNamespace(items: ComposerPickItem[], lowerPrefix: string): ComposerPickItem[] {
+  if (lowerPrefix.startsWith(SKILL_NAMESPACE)) return items;
+  const approachesNamespace = SKILL_NAMESPACE.startsWith(lowerPrefix);
+  let commandTier = 0;
+  if (!approachesNamespace) {
+    for (const item of items) {
+      const name = item.name.toLowerCase();
+      if (name.startsWith(SKILL_NAMESPACE)) continue;
+      commandTier = Math.max(commandTier, commandBreakoutTier(lowerPrefix, name));
+      for (const alias of item.aliases ?? []) {
+        commandTier = Math.max(commandTier, commandBreakoutTier(lowerPrefix, alias.toLowerCase()));
+      }
+      if (commandTier === 1000) break;
+    }
+  }
+
+  let skillCount = 0;
+  const rest = items.filter((item) => {
+    const name = item.name.toLowerCase();
+    if (!name.startsWith(SKILL_NAMESPACE)) return true;
+    skillCount += 1;
+    return (
+      !approachesNamespace &&
+      skillBareNameBreakoutTier(lowerPrefix, name.slice(SKILL_NAMESPACE.length)) > commandTier
+    );
+  });
+
+  if (skillCount === 0) return items;
+  if (!SKILL_NAMESPACE.startsWith(lowerPrefix)) return rest;
+  rest.push(skillNamespaceRow(skillCount));
+  return rest;
+}
+
+/** Prefix-match range for the rendered name, or null when nothing aligns. */
+function prefixMatch(name: string, query: string): { start: number; end: number } | null {
+  if (query.length === 0) return null;
+  return name.toLowerCase().startsWith(query.toLowerCase()) ? { start: 0, end: query.length } : null;
+}
+
+/**
+ * Score one command item the way oh-my-pi's `buildSlashCommandCompletions`
+ * does: the stronger of the name score (skills also match on their bare name)
+ * and half the description subsequence score. When an alias outscores the
+ * primary name the alias becomes the surfaced token, so `/models` inserts
+ * `/models`.
+ */
+function rankCommandItem(
+  item: ComposerPickItem,
+  lowerPrefix: string,
+): { item: ComposerPickItem; score: number; match: { start: number; end: number } | null } | null {
+  const name = item.name;
+  const lowerName = name.toLowerCase();
+  const isSkillCommand = lowerName.startsWith(SKILL_NAMESPACE);
+
+  const nameScore =
+    lowerPrefix.length === 0 && isSkillCommand
+      ? 950
+      : isSkillCommand
+        ? Math.max(
+            scoreCommandTextMatch(lowerPrefix, lowerName),
+            skillBareNameBreakoutTier(lowerPrefix, lowerName.slice(SKILL_NAMESPACE.length)),
+          )
+        : scoreCommandTextMatch(lowerPrefix, lowerName);
+
+  const lowerDesc = item.description.toLowerCase();
+  const descScore =
+    lowerDesc && subsequenceMatch(lowerPrefix, lowerDesc) ? subsequenceScore(lowerPrefix, lowerDesc) * 0.5 : 0;
+
+  const primaryScore = Math.max(nameScore, descScore);
+  let best = primaryScore > 0 ? { item, score: primaryScore, match: prefixMatch(name, lowerPrefix) } : undefined;
+
+  if (lowerPrefix.length > 0) {
+    for (const alias of item.aliases ?? []) {
+      if (alias.toLowerCase() === lowerName) continue;
+      const aliasScore = scoreCommandTextMatch(lowerPrefix, alias.toLowerCase());
+      if (aliasScore === 0 || (best && aliasScore <= best.score)) continue;
+      best = {
+        item: { ...item, name: alias, token: `/${alias}` },
+        score: aliasScore,
+        match: prefixMatch(alias, lowerPrefix),
+      };
+    }
+  }
+
+  return best ?? null;
+}
+
+function rankCommands(items: ComposerPickItem[], lowerPrefix: string): ComposerMatchItem[] {
+  const ranked: Array<{ item: ComposerPickItem; score: number; match: { start: number; end: number } | null }> = [];
+  for (const item of items) {
+    const hit = rankCommandItem(item, lowerPrefix);
+    if (hit) ranked.push(hit);
+  }
+  // Equal scores keep list order — oh-my-pi falls back to usage, which the
+  // chamber does not track, then to stable registry order.
+  ranked.sort((a, b) => b.score - a.score);
+  return ranked.map((entry) => ({ ...entry.item, match: entry.match }));
+}
+
+/**
+ * Filter `/`-command items for the command-name phase. `midPrompt` restricts
+ * the pool to skills (oh-my-pi's mid-prompt lookup); otherwise skills collapse
+ * into the `/skill:` namespace row until the prefix commits to the namespace.
+ */
+export function filterCommandItems(items: ComposerPickItem[], query: string, midPrompt = false): ComposerMatchItem[] {
+  const lowerPrefix = query.toLowerCase();
+
+  if (midPrompt) {
+    const skills = items.filter(
+      (item) =>
+        item.name.toLowerCase().startsWith(SKILL_NAMESPACE) &&
+        midPromptSkillTokenMatches(lowerPrefix, item.name, item.description),
+    );
+    return rankCommands(skills, lowerPrefix);
+  }
+
+  return rankCommands(collapseSkillNamespace(items, lowerPrefix), lowerPrefix);
+}
+
+/**
+ * Subcommand items for the `args` phase, mirroring oh-my-pi's declarative
+ * `buildArgumentCompletions`: a case-insensitive prefix match on the
+ * subcommand name, and nothing once the argument text itself contains a space.
+ */
+export function commandArgumentItems(
+  items: ComposerPickItem[],
+  command: string,
+  query: string,
+): ComposerMatchItem[] {
+  if (query.includes(' ')) return [];
+
+  const lower = query.toLowerCase();
+  const lowerCommand = command.toLowerCase();
+  const owner = items.find(
+    (item) =>
+      item.name.toLowerCase() === lowerCommand ||
+      (item.aliases ?? []).some((alias) => alias.toLowerCase() === lowerCommand),
+  );
+  const subcommands: ComposerSubcommand[] = owner?.subcommands ?? [];
+  if (subcommands.length === 0) return [];
+
+  return subcommands
+    .filter((sub) => sub.name.toLowerCase().startsWith(lower))
+    .map((sub) => ({
+      id: `${owner?.id ?? command}-sub-${sub.name}`,
+      name: sub.name,
+      description: sub.description ?? sub.usage ?? '',
+      kind: 'command' as const,
+      source: 'command' as const,
+      token: sub.name,
+      match: prefixMatch(sub.name, query),
+    }));
+}

package/src/shared/lib/chat/composer/composer.test.ts

@@ -0,0 +1,157 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The composer's `/` popup must match oh-my-pi's own editor, because the text
+ * it inserts is fed straight back to omp as a prompt. The expected values here
+ * were read off `@oh-my-pi/pi-tui`'s `CombinedAutocompleteProvider` driving the
+ * same command pool, so a regression in ranking, the `/skill:` namespace
+ * collapse, or the subcommand phase fails this file.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import type { ComposerPickItem } from '@/shared/types';
+import { detectComposerTrigger, insertToken, tokenForItem } from '@/shared/lib/chat/composer/trigger';
+import { filterComposerItems } from '@/shared/lib/chat/composer/filter';
+
+function item(over: Partial<ComposerPickItem> & { name: string }): ComposerPickItem {
+  const isSkill = over.name.startsWith('skill:');
+  return {
+    id: `i-${over.name}`,
+    description: '',
+    kind: isSkill ? 'skill' : 'command',
+    source: isSkill ? 'skill' : 'command',
+    token: `/${over.name}`,
+    ...over,
+  };
+}
+
+const POOL: ComposerPickItem[] = [
+  item({ name: 'security', description: 'Plan, run, inspect, import, and compare security scans' }),
+  item({ name: 'model', description: 'Show current model selection', aliases: ['models'] }),
+  item({
+    name: 'fast',
+    description: 'Toggle fast mode',
+    subcommands: [
+      { name: 'on', description: 'Enable fast mode' },
+      { name: 'off', description: 'Disable fast mode' },
+      { name: 'status', description: 'Show fast mode status' },
+    ],
+  }),
+  item({ name: 'retry', description: 'Retry the last failed agent turn' }),
+  item({ name: 'rename', description: 'Rename the current session' }),
+  item({ name: 'compact', description: 'Compact the conversation' }),
+  item({ name: 'wt', description: 'Move this session into a new worktree', aliases: ['worktree'] }),
+  item({ name: 'skill:handoff', description: 'Compact the current conversation into a handoff document' }),
+  item({ name: 'skill:diagnose', description: 'Disciplined diagnosis loop for hard bugs' }),
+  item({ name: 'skill:research-last30days', description: 'Research last 30 days' }),
+  item({ name: 'skill:zoom-out', description: 'Zoom out' }),
+];
+
+/** Tokens the popup offers for a draft, as omp's provider would order them. */
+function tokensFor(text: string, caret = text.length): string[] {
+  const trigger = detectComposerTrigger(text, caret);
+  return trigger ? filterComposerItems(POOL, trigger).map((m) => m.token) : [];
+}
+
+/** What the popup offers after accepting `pick` from `text`. */
+function acceptThenRequery(text: string, pick: string): { value: string; requery: string[] } {
+  const trigger = detectComposerTrigger(text, text.length);
+  if (!trigger) throw new Error(`no trigger for ${text}`);
+  const match = filterComposerItems(POOL, trigger).find((m) => m.token === pick || m.name === pick);
+  if (!match) throw new Error(`no match ${pick} for ${text}`);
+  const next = insertToken(text, trigger, tokenForItem(match));
+  return { value: next.value, requery: tokensFor(next.value, next.caret) };
+}
+
+describe('composer slash commands', () => {
+  test('skills collapse into one namespace row while the prefix is generic', () => {
+    expect(tokensFor('/')).toEqual([
+      '/skill:',
+      '/security',
+      '/model',
+      '/fast',
+      '/retry',
+      '/rename',
+      '/compact',
+      '/wt',
+    ]);
+  });
+
+  test('a skill breaks out only on a stronger match than every command', () => {
+    // `handoff` wins the namespace tier; `zoom-out` matches on a later segment.
+    expect(tokensFor('/han')).toEqual(['/skill:handoff', '/retry', '/compact', '/wt']);
+    expect(tokensFor('/z')).toEqual(['/skill:zoom-out']);
+    // A tie leaves the popup command-only.
+    expect(tokensFor('/re')).toEqual(['/retry', '/rename', '/worktree', '/security', '/model']);
+  });
+
+  test('an alias outranking its command name is what gets inserted', () => {
+    expect(tokensFor('/models')).toEqual(['/models']);
+    expect(tokensFor('/worktree')).toEqual(['/worktree']);
+  });
+
+  test('a slash token with no command match offers nothing', () => {
+    // `/tmp/fo` is a path, not a command: an empty popup would just cover the composer.
+    expect(tokensFor('/zzz')).toEqual([]);
+    expect(tokensFor('/tmp/fo')).toEqual([]);
+    expect(tokensFor('/retry ')).toEqual([]);
+  });
+
+  test('a command with subcommands switches to the argument phase', () => {
+    expect(tokensFor('/fast ')).toEqual(['on', 'off', 'status']);
+    expect(tokensFor('/fast o')).toEqual(['on', 'off']);
+    // Past the subcommand, or with a space inside the argument, completion stops.
+    expect(tokensFor('/fast on ')).toEqual([]);
+    expect(tokensFor('/fast  o')).toEqual([]);
+  });
+
+  test('accepting a command reopens on its subcommands, not an empty list', () => {
+    expect(acceptThenRequery('/fast', '/fast')).toEqual({ value: '/fast ', requery: ['on', 'off', 'status'] });
+    expect(acceptThenRequery('/models', '/models')).toEqual({ value: '/models ', requery: [] });
+  });
+
+  test('accepting the namespace row keeps the caret on the namespace', () => {
+    // No trailing space: the popup must reopen on the individual skills.
+    expect(acceptThenRequery('/sk', '/skill:')).toEqual({
+      value: '/skill:',
+      requery: ['/skill:handoff', '/skill:diagnose', '/skill:research-last30days', '/skill:zoom-out'],
+    });
+    expect(acceptThenRequery('/skill:', '/skill:handoff')).toEqual({
+      value: '/skill:handoff ',
+      requery: [],
+    });
+  });
+
+  test('a mid-prompt slash token only ever surfaces skills', () => {
+    expect(tokensFor('fix bug /skill:han')).toEqual(['/skill:handoff']);
+    expect(tokensFor('fix bug /han')).toEqual(['/skill:handoff']);
+    // `/fast` mid-prose is not a skill, so nothing opens.
+    expect(tokensFor('prose /fast')).toEqual([]);
+  });
+
+  test('a leading slash survives indentation', () => {
+    expect(tokensFor('  /fa')).toEqual(['/fast', '/retry']);
+  });
+});
+
+describe('composer slash trigger', () => {
+  test('reports the phase and the span each accept replaces', () => {
+    expect(detectComposerTrigger('/fast', 5)).toMatchObject({ kind: 'command', phase: 'name', query: 'fast', replaceFrom: 0 });
+    expect(detectComposerTrigger('/fast o', 7)).toMatchObject({ kind: 'command', phase: 'args', query: 'o', command: 'fast', replaceFrom: 6 });
+    // Earlier arguments survive acceptance: the replacement span is the
+    // argument text (oh-my-pi's `beforePrefix`), not the whole invocation.
+    expect(detectComposerTrigger('/security plan s', 16)).toMatchObject({ phase: 'args', query: 'plan s', replaceFrom: 10 });
+    // ...and a space inside the argument ends completion, as in oh-my-pi.
+    expect(tokensFor('/security plan s')).toEqual([]);
+  });
+
+  test('an @mention trigger keeps its own span', () => {
+    expect(detectComposerTrigger('@file:src/a', 11)).toMatchObject({ kind: 'mention', query: 'file:src/a', start: 0 });
+    expect(detectComposerTrigger('see @sonic', 10)).toMatchObject({ kind: 'mention', query: 'sonic', start: 4 });
+    expect(detectComposerTrigger('foo@bar', 7)).toBeNull();
+  });
+});

package/src/shared/lib/chat/composer/filter.ts

@@ -1,8 +1,10 @@
-import type { ComposerMatchItem, ComposerPickItem } from '@/shared/types';
+import type { ComposerMatchItem, ComposerPickItem, ComposerTrigger } from '@/shared/types';
+import { filterCommandItems, commandArgumentItems } from '@/shared/lib/chat/composer/commands';
 
 /** Detects the `file:` query prefix (case-insensitive) that scopes to files. */
 const FILE_QUERY_PREFIX_RE = /^file:/i;
 
+/** Rank tiers for `@` mentions (chamber-only; omp's file completion is path-based). */
 interface RankedMatch {
   tier: number;
   index: number;
@@ -13,7 +15,7 @@ interface RankedMatch {
  * Score a single item against a query. Tier order: exact name > name
  * startsWith > name includes > description includes. Returns null on no match.
  */
-export function rankComposerItem(
+function rankComposerItem(
   name: string,
   description: string,
   query: string,
@@ -35,13 +37,16 @@ export function rankComposerItem(
   return null;
 }
 
-/** Filter items by query, ranked by tier then original order. */
-export function filterComposerItems(items: ComposerPickItem[], query: string): ComposerMatchItem[] {
+/**
+ * Filter `@` mention items by query, ranked by tier then original order.
+ *
+ * `file:` scopes the pool to files and ranks on the path remainder, so
+ * `@file:composer` finds `app/lib/chat/composer/client.ts`. Bare `@` keeps the
+ * full agents + files pool.
+ */
+function filterMentionItems(items: ComposerPickItem[], query: string): ComposerMatchItem[] {
   const trimmed = query.trim();
 
-  // `file:` scopes the pool to files and ranks on the path remainder, so
-  // `@file:composer` finds `app/lib/chat/composer/client.ts`. Bare `@` keeps
-  // the full agents + files pool.
   const fileQuery = FILE_QUERY_PREFIX_RE.test(trimmed);
   const pool = fileQuery ? items.filter((item) => item.source === 'file') : items;
   const rankingQuery = fileQuery ? trimmed.replace(FILE_QUERY_PREFIX_RE, '').trim() : trimmed;
@@ -60,3 +65,12 @@ export function filterComposerItems(items: ComposerPickItem[], query: string): C
 
   return ranked.map((entry) => ({ ...pool[entry.index], match: entry.match }));
 }
+
+/** Dispatch on the trigger: mentions keep their own ranking, commands use omp's. */
+export function filterComposerItems(items: ComposerPickItem[], trigger: ComposerTrigger): ComposerMatchItem[] {
+  if (trigger.kind === 'mention') return filterMentionItems(items, trigger.query);
+  if (trigger.phase === 'args' && trigger.command) {
+    return commandArgumentItems(items, trigger.command, trigger.query);
+  }
+  return filterCommandItems(items, trigger.query, trigger.midPrompt === true);
+}

package/src/shared/lib/chat/composer/trigger.ts

@@ -3,32 +3,121 @@ import type { ComposerPickItem, ComposerTrigger } from '@/shared/types';
 /** Chars that may legally precede an `@` agent trigger (besides string start). */
 const AT_PRECEDING_RE = /[\s([{]/;
 
+/** oh-my-pi's `SKILL_NAMESPACE`: skills are addressed as `/skill:<name>`. */
+export const SKILL_NAMESPACE = 'skill:';
+
+/** The collapsed namespace row's token (no trailing space on accept). */
+export const SKILL_NAMESPACE_TOKEN = `/${SKILL_NAMESPACE}`;
+
+/**
+ * Index of a `/` that starts the draft, ignoring leading whitespace —
+ * oh-my-pi's `findLeadingSlashCommandStart`.
+ */
+function leadingSlashStart(text: string): number | null {
+  const trimmed = text.trimStart();
+  if (!trimmed.startsWith('/')) return null;
+  return text.length - trimmed.length;
+}
+
+/**
+ * Index of a `/` that opens the trailing token (`/(?:^|\s)\/([^\s/]*)$`) —
+ * oh-my-pi's `findTrailingSlashCommandStart`.
+ */
+function trailingSlashStart(text: string): number | null {
+  const match = /(?:^|\s)\/([^\s/]*)$/.exec(text);
+  if (!match || match.index === undefined) return null;
+  const slashOffset = match[0].indexOf('/');
+  return match.index + slashOffset;
+}
+
+/**
+ * Whether prose precedes the slash token: any earlier non-blank line, or
+ * non-whitespace before it on this line — oh-my-pi's
+ * `hasPromptTextBeforeSlash`. Such a token is a mid-prompt skill lookup,
+ * which only ever surfaces skills.
+ */
+function hasPromptTextBeforeSlash(lines: readonly string[], line: number, before: string, slashStart: number): boolean {
+  for (let i = 0; i < line; i += 1) {
+    if ((lines[i] ?? '').trim() !== '') return true;
+  }
+  return before.slice(0, slashStart).trim() !== '';
+}
+
 /**
  * Detect an `@`-mention (files + agents) or `/`-command trigger at the given
- * caret position.
+ * caret position, mirroring oh-my-pi's `CombinedAutocompleteProvider`:
  *
- * Scans backwards from `caret - 1`: a whitespace/newline before any trigger
- * char aborts the scan. `/` is only a trigger at index 0; `@` is a trigger at
- * index 0 or when preceded by whitespace, `(`, `[`, or `{`. The query is the
- * run of non-whitespace characters between the trigger char and the caret, so
- * `foo@bar` and `a/b` (query containing another trigger char) never match.
+ * - `/` starts a command at the draft start (leading whitespace allowed) or as
+ *   a trailing token after whitespace on the caret's line. A `/` in the middle
+ *   of a token (`a/b`) never matches.
+ * - Once `<command> ` is typed, the popup switches to the `args` phase, which
+ *   completes that command's declarative subcommands.
+ * - `@` is a trigger at index 0 or when preceded by whitespace, `(`, `[`, `{`.
+ *
+ * `lines` is the whole draft split on newlines and `line` the caret's line
+ * index, because the mid-prompt rule inspects earlier lines.
  */
 export function detectComposerTrigger(text: string, caret: number): ComposerTrigger | null {
   const end = Math.max(0, Math.min(caret, text.length));
+  const before = text.slice(0, end);
+  // Mid-prompt detection needs the earlier lines, and every rule below is
+  // scoped to the caret's own line.
+  const lines = text.split('\n');
+  const line = (before.match(/\n/g) ?? []).length;
+  const lineStart = before.lastIndexOf('\n') + 1;
+  const beforeOnLine = before.slice(lineStart);
 
-  for (let i = end - 1; i >= 0; i--) {
-    const ch = text[i];
+  const leadStart = leadingSlashStart(beforeOnLine);
+  const trailStart = trailingSlashStart(beforeOnLine);
+  const midPrompt = trailStart !== null && hasPromptTextBeforeSlash(lines, line, beforeOnLine, trailStart);
+  const leadIsMidPrompt = leadStart !== null && hasPromptTextBeforeSlash(lines, line, beforeOnLine, leadStart);
 
-    if (/\s/.test(ch)) return null;
+  const slashStart = midPrompt ? trailStart : leadIsMidPrompt ? null : leadStart;
 
-    if (ch === '/' || ch === '@') {
-      if (ch === '/') {
-        if (i !== 0) return null;
-        return { kind: 'command', query: text.slice(i + 1, end), start: i, end };
-      }
+  if (slashStart !== null) {
+    const commandText = beforeOnLine.slice(slashStart);
+    const spaceIndex = commandText.indexOf(' ');
+
+    if (spaceIndex === -1) {
+      return {
+        kind: 'command',
+        query: commandText.slice(1),
+        start: lineStart + slashStart,
+        end,
+        phase: 'name',
+        replaceFrom: lineStart + slashStart,
+        ...(midPrompt ? { midPrompt: true } : {}),
+      };
+    }
+
+    if (!midPrompt) {
+      // Argument phase: everything after `<command> ` completes that command's
+      // subcommands. oh-my-pi anchors the replacement on the argument text
+      // only, so earlier arguments survive acceptance.
+      const argStart = lineStart + slashStart + spaceIndex + 1;
+      return {
+        kind: 'command',
+        query: before.slice(argStart),
+        start: lineStart + slashStart,
+        end,
+        phase: 'args',
+        replaceFrom: argStart,
+        command: commandText.slice(1, spaceIndex),
+      };
+    }
+  }
+
+  // `@` mentions scan back to the token start; whitespace aborts the scan so
+  // `foo@bar` never triggers.
+  for (let i = beforeOnLine.length - 1; i >= 0; i--) {
+    const ch = beforeOnLine[i];
+
+    if (/\s/.test(ch)) return null;
 
-      if (i === 0 || AT_PRECEDING_RE.test(text[i - 1])) {
-        return { kind: 'mention', query: text.slice(i + 1, end), start: i, end };
+    if (ch === '@') {
+      if (i === 0 || AT_PRECEDING_RE.test(beforeOnLine[i - 1])) {
+        const at = lineStart + i;
+        return { kind: 'mention', query: before.slice(at + 1), start: at, end, phase: 'name', replaceFrom: at };
       }
       return null;
     }
@@ -37,9 +126,9 @@ export function detectComposerTrigger(text: string, caret: number): ComposerTrig
   return null;
 }
 
-/** Insertion text for an item: its token followed by a single trailing space. */
+/** Insertion text for an item: its token, plus a trailing space unless suppressed. */
 export function tokenForItem(item: ComposerPickItem): string {
-  return `${item.token} `;
+  return item.insertWithoutSpace ? item.token : `${item.token} `;
 }
 
 /** Splice `token` over the trigger span in `value`, returning the new value and caret. */
@@ -48,6 +137,6 @@ export function insertToken(
   trigger: ComposerTrigger,
   token: string,
 ): { value: string; caret: number } {
-  const next = value.slice(0, trigger.start) + token + value.slice(trigger.end);
-  return { value: next, caret: trigger.start + token.length };
+  const next = value.slice(0, trigger.replaceFrom) + token + value.slice(trigger.end);
+  return { value: next, caret: trigger.replaceFrom + token.length };
 }