ompchamber 0.8.0 → 1.1.0

package/src/shared/lib/chat/omp/agent-events.test.ts

@@ -25,10 +25,14 @@ const ABORTED_TURN = {
 function makeDeps() {
   const ended: ChatMessageData[] = [];
   const activity: string[] = [];
+  const commandOutputs: string[] = [];
+  let settledCount = 0;
   let state: OmpAgentState = { isGenerating: false, connected: true, error: null };
   const callbacks: OmpAgentCallbacks = {
     onMessageEnd: (msg) => ended.push(msg),
     onActivity: (verb) => activity.push(verb),
+    onPromptSettled: () => { settledCount += 1; },
+    onCommandOutput: (text) => commandOutputs.push(text),
   };
   const deps: OmpAgentFoldDeps = {
     sessionId: 's1',
@@ -43,7 +47,7 @@ function makeDeps() {
     currentThinkingLevelRef: { current: undefined },
     fileMutatingCallsRef: { current: new Set<string>() },
   };
-  return { deps, ended, activity };
+  return { deps, ended, activity, commandOutputs, settled: () => settledCount, state: () => state };
 }
 
 describe('toChatMessage error derivation', () => {
@@ -60,6 +64,38 @@ describe('toChatMessage error derivation', () => {
   });
 });
 
+describe('foldAgentEvent prompt_result (builtin slash commands)', () => {
+  test('agentInvoked:false settles generating state and fires onPromptSettled', () => {
+    const { deps, state, settled } = makeDeps();
+    foldAgentEvent({ type: 'agent_start' }, deps);
+    expect(state().isGenerating).toBe(true);
+    foldAgentEvent({ type: 'prompt_result', agentInvoked: false }, deps);
+    expect(state().isGenerating).toBe(false);
+    expect(settled()).toBe(1);
+  });
+
+  test('prompt_result with agentInvoked:true does not settle (a run follows)', () => {
+    const { deps, settled } = makeDeps();
+    foldAgentEvent({ type: 'prompt_result', agentInvoked: true }, deps);
+    expect(settled()).toBe(0);
+  });
+});
+
+describe('foldAgentEvent command_output (builtin slash output)', () => {
+  test('forwards trimmed text to onCommandOutput', () => {
+    const { deps, commandOutputs } = makeDeps();
+    foldAgentEvent({ type: 'command_output', text: 'Usage\nInput tokens: 0\n' }, deps);
+    expect(commandOutputs).toEqual(['Usage\nInput tokens: 0']);
+  });
+
+  test('drops empty output frames', () => {
+    const { deps, commandOutputs } = makeDeps();
+    foldAgentEvent({ type: 'command_output', text: '   ' }, deps);
+    foldAgentEvent({ type: 'command_output' }, deps);
+    expect(commandOutputs).toEqual([]);
+  });
+});
+
 describe('foldAgentEvent activity phrases', () => {
   test('names the tool being executed, not a generic reasoning verb', () => {
     const { deps, activity } = makeDeps();

package/src/shared/lib/chat/omp/agent-events.ts

@@ -165,6 +165,11 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
       callbacks?.onAgentStart?.();
       break;
 
+    case 'turn_start':
+      setActivity(PHASE_VERBS.thinking, deps);
+      callbacks?.onTurnStart?.();
+      break;
+
     case 'message_start':
     case 'message_update': {
       const msg = data.message as Record<string, unknown> | undefined;
@@ -177,6 +182,10 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
       // Assistant phases (thinking / prose / tool-call assembly) name the
       // action directly — a tool that never starts still shows its phrase.
       setActivity(describeAssistantPhase(data.assistantMessageEvent), deps);
+      // The first message frame of a turn is another proof the run is live —
+      // re-signal so the sidebar can restore a lost `stream` status row.
+      // message_update frames arrive per delta and must stay silent here.
+      if (data.type === 'message_start') callbacks?.onTurnStart?.();
       // Steering (abort_and_prompt) and follow-up deliveries create no
       // optimistic bubble — the user turn only exists on the stream. Convert
       // it here so the bubble renders live instead of after a JSONL reload.
@@ -298,6 +307,27 @@ export function foldAgentEvent(data: OmpAgentEvent, deps: OmpAgentFoldDeps): voi
       break;
     }
 
+    // omp's prompt ack ran a built-in slash command instead of an agent turn
+    // (`agentInvoked:false`, mirrored server-side as this frame): there will be
+    // no agent_start/agent_end pair. Clear the optimistic generating state —
+    // the callbacks drop the AI placeholder and keep the user's message row.
+    case 'prompt_result': {
+      if (data.agentInvoked === false) {
+        deps.setState((prev) => ({ ...prev, isGenerating: false }));
+        deps.activityRef.current = '';
+        callbacks?.onPromptSettled?.();
+      }
+      break;
+    }
+
+    // Built-in slash command output (/usage, /compact result, …). Rendered as
+    // a notice row — see the callback type note: this frame is the ONLY copy.
+    case 'command_output': {
+      const text = typeof data.text === 'string' ? data.text.trim() : '';
+      if (text) callbacks?.onCommandOutput?.(text);
+      break;
+    }
+
     case 'notice': {
       callbacks?.onNotice?.(
         typeof data.level === 'string' ? data.level : 'info',

package/src/shared/lib/chat/timeline/omp-callbacks.test.ts

@@ -63,7 +63,6 @@ describe('createOmpAgentCallbacks first-assistant sidebar signal', () => {
 
   function makeCallbacks(): OmpAgentCallbacks {
     const deps: OmpAgentCallbacksDeps = {
-      removeDeliveredFromQueue: () => {},
       setGenerating: () => {},
       setGeneratingVerb: () => {},
       scrollToBottom: () => {},
@@ -133,6 +132,15 @@ describe('createOmpAgentCallbacks first-assistant sidebar signal', () => {
     expect(signals).toHaveLength(2);
   });
 
+  test('onTurnStart signals the sidebar on every turn of the run', () => {
+    const callbacks = makeCallbacks();
+
+    callbacks.onTurnStart?.();
+    callbacks.onTurnStart?.();
+    expect(signals).toHaveLength(2);
+    expect(signals.every(s => s.name === 'omp:session-updated' && s.sessionId === 'sess-1')).toBe(true);
+  });
+
   test('never signals from user turns or notice rows alone', () => {
     const callbacks = makeCallbacks();
 

package/src/shared/lib/chat/timeline/omp-callbacks.ts

@@ -47,7 +47,6 @@ export function cancelStreamingCoalescer(): void {
 }
 
 export interface OmpAgentCallbacksDeps {
-  removeDeliveredFromQueue: (text: string) => void;
   setGenerating: (v: boolean) => void;
   setGeneratingVerb: (v: string) => void;
   scrollToBottom: (behavior?: ScrollBehavior) => void;
@@ -73,7 +72,6 @@ export interface OmpAgentCallbacksDeps {
 
 export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCallbacks {
   const {
-    removeDeliveredFromQueue,
     setGenerating,
     setGeneratingVerb,
     scrollToBottom,
@@ -97,12 +95,6 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
   scrollAfterFlush = () => scrollToBottom('smooth');
 
   return {
-    // A queued steer/follow-up text was picked up by the agent (user turn
-    // arrived) — drop it from whichever queue mirrors it so the panel stays
-    // truthful without a chat bubble for every delivery.
-    onQueuedMessageDelivered: (text) => {
-      removeDeliveredFromQueue(text);
-    },
     onAgentStart: () => {
       setGenerating(true);
       setGeneratingVerb(PHASE_VERBS.thinking);
@@ -122,6 +114,15 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
         }
       }
     },
+    onTurnStart: () => {
+      // Every turn inside the run re-signals the sidebar: the throttle makes
+      // this cheap, and it recovers the `stream` status row if a previous
+      // dispatch raced with the status write (or the row was healed away).
+      const sid = adoptedSessionIdRef.current ?? sessionIdRef.current;
+      if (sid && typeof window !== 'undefined') {
+        window.dispatchEvent(new CustomEvent('omp:session-updated', { detail: { sessionId: sid } }));
+      }
+    },
     // Reload recovery: the omp process kept running server-side, so the event
     // stream is reattached and the generating UI must resume (the timeline
     // fetch already loaded the committed messages; live updates continue).
@@ -308,6 +309,42 @@ export function createOmpAgentCallbacks(deps: OmpAgentCallbacksDeps): OmpAgentCa
       abortControllerRef.current = null;
       console.error('OMP prompt error:', errorMessage);
     },
+    // The prompt ran a built-in slash command (omp answered on the command
+    // path, no agent run): drop the optimistic AI placeholder and settle the
+    // optimistic user row — it stays as the record of what the user invoked.
+    onPromptSettled: () => {
+      disposeStreamingCoalescer();
+      setGenerating(false);
+      abortControllerRef.current = null;
+      optimisticUserIdRef.current = null;
+      const placeholderId = aiPlaceholderIdRef.current;
+      aiPlaceholderIdRef.current = null;
+      if (placeholderId) {
+        setLocalMessages(prev => {
+          if (!prev.some(m => m.id === placeholderId)) return prev;
+          return prev.filter(m => m.id !== placeholderId);
+        });
+      }
+    },
+    // Built-in slash command output only rides the live stream — append it as
+    // a notice row before any active placeholder, exactly like omp notices.
+    onCommandOutput: (text) => {
+      const row: ChatMessageData = {
+        id: `cmdout-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+        role: 'ai',
+        content: '',
+        notice: text,
+      };
+      setLocalMessages(prev => {
+        const placeholderId = aiPlaceholderIdRef.current;
+        if (placeholderId) {
+          const pIdx = prev.findIndex(m => m.id === placeholderId);
+          if (pIdx !== -1) return [...prev.slice(0, pIdx), row, ...prev.slice(pIdx)];
+        }
+        if (prev.some(m => m.notice === text)) return prev;
+        return [...prev, row];
+      });
+    },
     onNotice: (_level, message) => {
       console.info('OMP notice:', message);
     },

package/src/shared/lib/models/preferences.test.ts

@@ -0,0 +1,131 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The preference rules are shared verbatim by the server (which persists the
+ * arrays) and the picker (which applies them optimistically), so these lock the
+ * behaviour both sides read back: composite keys, most-recent-first order, and
+ * the five-entry cap.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import {
+  EMPTY_MODEL_PREFERENCES,
+  RECENT_MODELS_LIMIT,
+  applyModelPreferences,
+  filterKnownKeys,
+  readModelPreferences,
+  recordRecentKey,
+  toggleFavoriteKey,
+} from '@/shared/lib/models/preferences';
+import type { AIModelOption } from '@/shared/types';
+
+describe('toggleFavoriteKey', () => {
+  test('adds an unknown key at the end and removes a known one', () => {
+    expect(toggleFavoriteKey(['a:1'], 'b:2')).toEqual(['a:1', 'b:2']);
+    expect(toggleFavoriteKey(['a:1', 'b:2'], 'a:1')).toEqual(['b:2']);
+  });
+
+  test('keys on provider + id, so the same id under another provider is a separate favorite', () => {
+    // The registry serves `deepseek-v4-pro` from both `deepseek` and `kenari`.
+    // An id-only list would unstar both rows when either is clicked.
+    const favorites = toggleFavoriteKey([], 'deepseek:deepseek-v4-pro');
+    expect(toggleFavoriteKey(favorites, 'kenari:deepseek-v4-pro')).toEqual([
+      'deepseek:deepseek-v4-pro',
+      'kenari:deepseek-v4-pro',
+    ]);
+  });
+});
+
+describe('recordRecentKey', () => {
+  test('moves a re-picked model to the front instead of duplicating it', () => {
+    expect(recordRecentKey(['a:1', 'b:2', 'c:3'], 'b:2')).toEqual(['b:2', 'a:1', 'c:3']);
+  });
+
+  test('caps the list at five, evicting the oldest entry', () => {
+    const full = ['a:1', 'b:2', 'c:3', 'd:4', 'e:5'];
+    const next = recordRecentKey(full, 'f:6');
+
+    expect(next).toHaveLength(RECENT_MODELS_LIMIT);
+    expect(next[0]).toBe('f:6');
+    expect(next).not.toContain('e:5');
+  });
+
+  test('re-picking inside a full list keeps the other four', () => {
+    const full = ['a:1', 'b:2', 'c:3', 'd:4', 'e:5'];
+    expect(recordRecentKey(full, 'c:3')).toEqual(['c:3', 'a:1', 'b:2', 'd:4', 'e:5']);
+  });
+});
+
+describe('readModelPreferences', () => {
+  test('reads a well-formed pair', () => {
+    expect(readModelPreferences({ favorites: ['a:1'], recentKeys: ['b:2'] }))
+      .toEqual({ favorites: ['a:1'], recentKeys: ['b:2'] });
+  });
+
+  test('drops non-string entries and caps an over-long recent list', () => {
+    const raw = {
+      favorites: ['a:1', 7, null, ''],
+      recentKeys: ['a:1', 'b:2', 'c:3', 'd:4', 'e:5', 'f:6', 'g:7'],
+    };
+
+    expect(readModelPreferences(raw)).toEqual({
+      favorites: ['a:1'],
+      recentKeys: ['a:1', 'b:2', 'c:3', 'd:4', 'e:5'],
+    });
+  });
+
+  test('an absent or malformed row yields empty rails', () => {
+    expect(readModelPreferences(null)).toEqual(EMPTY_MODEL_PREFERENCES);
+    expect(readModelPreferences('nonsense')).toEqual(EMPTY_MODEL_PREFERENCES);
+    expect(readModelPreferences({ favorites: 'not-a-list' })).toEqual(EMPTY_MODEL_PREFERENCES);
+  });
+});
+
+describe('filterKnownKeys', () => {
+  test('drops keys the registry no longer serves', () => {
+    // A model removed from models.yml, or every model of a disconnected
+    // provider, must not hold a slot in the five-entry rail.
+    const known = new Set(['a:1', 'c:3']);
+    expect(filterKnownKeys(['a:1', 'gone:9', 'c:3'], known)).toEqual(['a:1', 'c:3']);
+  });
+
+  test('pruning before a write frees the slot instead of merely hiding it', () => {
+    // The rail reads at most five entries. A stale key left in the stored array
+    // occupies one of them across every reload, so the user sees four models
+    // and the fifth pick appears to do nothing.
+    const stored = ['gone:9', 'a:1', 'b:2', 'c:3', 'd:4'];
+    const pruned = recordRecentKey(filterKnownKeys(stored, new Set(['a:1', 'b:2', 'c:3', 'd:4', 'e:5'])), 'e:5');
+
+    expect(pruned).toEqual(['e:5', 'a:1', 'b:2', 'c:3', 'd:4']);
+    expect(pruned).toHaveLength(RECENT_MODELS_LIMIT);
+  });
+});
+
+describe('applyModelPreferences', () => {
+  const rows: AIModelOption[] = [
+    { id: '1', name: 'One', provider: 'a' },
+    { id: '2', name: 'Two', provider: 'a', isFavorite: true },
+    { id: '3', name: 'Three', provider: 'b' },
+  ];
+
+  test('lights only the rows named by the stored key list', () => {
+    const applied = applyModelPreferences(rows, { favorites: ['b:3'], recentKeys: [] });
+
+    // Truthiness is the contract the star reads: a registry row has no
+    // `isFavorite` field at all, so `false` and `undefined` both mean "unlit".
+    expect(applied.map((m) => Boolean(m.isFavorite))).toEqual([false, false, true]);
+  });
+
+  test('leaves already-correct rows identical so only the changed row re-renders', () => {
+    const applied = applyModelPreferences(rows, { favorites: [], recentKeys: [] });
+
+    expect(applied[0]).toBe(rows[0]);
+    expect(applied[2]).toBe(rows[2]);
+    expect(applied[1]).not.toBe(rows[1]);
+    expect(applied[1].isFavorite).toBe(false);
+  });
+});

package/src/shared/lib/models/preferences.ts

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Favorite + recent model preferences, keyed by the composite `provider:id`
+ * identity (`modelKey`). A model id alone is not unique — the omp registry
+ * serves the same id from several providers — so an id-keyed favorite list
+ * lights up every provider's row and records the wrong "recent".
+ *
+ * Pure list operations only: the server persists the arrays (one
+ * `app_settings` row) and the picker applies them optimistically, so both
+ * sides MUST agree on the ordering and the cap. Keeping the rules here is what
+ * makes them agree — a second copy in the route or the hook would drift.
+ */
+
+import type { AIModelOption, ModelPreferences } from '@/shared/types';
+import { modelKey } from '@/shared/lib/models/identity';
+
+/** How many last-used models the RECENT rail holds. */
+export const RECENT_MODELS_LIMIT = 5;
+
+/** Used before the first write, and when a payload carries no preferences. */
+export const EMPTY_MODEL_PREFERENCES: ModelPreferences = { favorites: [], recentKeys: [] };
+
+/** Add or remove one key; the relative order of the survivors is untouched. */
+export function toggleFavoriteKey(favorites: readonly string[], key: string): string[] {
+  return favorites.includes(key)
+    ? favorites.filter((entry) => entry !== key)
+    : [...favorites, key];
+}
+
+/**
+ * Move a key to the front of the recents, de-duplicated and capped. Re-picking
+ * a model must not leave a second copy behind — the rail would then show the
+ * same model twice and the cap would evict a genuinely older entry.
+ */
+export function recordRecentKey(
+  recentKeys: readonly string[],
+  key: string,
+  limit: number = RECENT_MODELS_LIMIT,
+): string[] {
+  return [key, ...recentKeys.filter((entry) => entry !== key)].slice(0, Math.max(1, limit));
+}
+
+/**
+ * Drop keys the live registry no longer offers — a model removed from
+ * models.yml, or every model of a provider the user disconnected. Without this
+ * a stale key holds one of the five recent slots forever, so a rail that looks
+ * empty is hiding real entries behind keys nothing can render.
+ */
+export function filterKnownKeys(keys: readonly string[], known: ReadonlySet<string>): string[] {
+  return keys.filter((key) => known.has(key));
+}
+
+/** Parse a persisted preferences row without trusting the JSON shape. */
+export function readModelPreferences(value: unknown): ModelPreferences {
+  const source = typeof value === 'object' && value !== null ? value as Record<string, unknown> : {};
+  const strings = (input: unknown): string[] =>
+    Array.isArray(input) ? input.filter((entry): entry is string => typeof entry === 'string' && entry.length > 0) : [];
+  return {
+    favorites: strings(source.favorites),
+    recentKeys: strings(source.recentKeys).slice(0, RECENT_MODELS_LIMIT),
+  };
+}
+
+/**
+ * Stamp the favorite flag onto a catalog list. The registry carries no
+ * favorites of its own — it is a read-only view of omp's config — so the picker
+ * learns which rows are starred from the preference store, never from the
+ * catalog's own `isFavorite` (that is MOCK seed data).
+ *
+ * The comparison is by truthiness, not identity: a registry row has no
+ * `isFavorite` field at all, so an `undefined !== false` test would rebuild
+ * every row on every load and re-render the whole panel. Rows whose star state
+ * already reads correctly are returned untouched.
+ */
+export function applyModelPreferences(
+  models: AIModelOption[],
+  preferences: ModelPreferences,
+): AIModelOption[] {
+  const favorites = new Set(preferences.favorites);
+  return models.map((model) => {
+    const isFavorite = favorites.has(modelKey(model));
+    return Boolean(model.isFavorite) === isFavorite ? model : { ...model, isFavorite };
+  });
+}

package/src/shared/lib/models/provider-models.ts

@@ -63,6 +63,14 @@ export function mergeProviderModels(
   return { merged: [...existing, ...added], added, addedCount: added.length };
 }
 
+/**
+ * Register newly added provider models on the chamber's catalog.
+ *
+ * `isFavorite` is deliberately NOT sent: the picker derives favorites from the
+ * stored preference keys, so a catalog flag would be a second, silently
+ * ignored source of truth for the FAVORITES rail. A new provider's models are
+ * starred by the user, not by this sync.
+ */
 export async function syncProviderModelsToCatalog(
   providerName: string,
   models: ProviderModel[],
@@ -81,7 +89,6 @@ export async function syncProviderModelsToCatalog(
               provider: providerName,
               contextWindow: model.contextWindow?.split(' ')[0] || '128K',
               thinkingLevel: 'Default',
-              isFavorite: true,
               capabilities: ['Tool calling', 'Reasoning'],
               inputFormats: ['text'],
               outputFormats: ['text'],

package/src/shared/lib/omp/session/stream-state.server.ts

@@ -11,7 +11,6 @@
  *   stream  — a run is in flight (prompt dispatch → agent_start)
  *   finish  — the run ended normally (agent_end), not yet seen
  *   abort   — the user stopped it, not yet seen
- *   error   — the run failed (prompt_error / process exit), not yet seen
  *
  * A terminal status is a one-shot badge: opening the session acknowledges it
  * (`markStreamSeen` deletes the row), which is exactly the "check appears
@@ -25,7 +24,7 @@
 
 import { getDb } from '@/server/db.server';
 
-export type SessionStreamStatus = 'stream' | 'finish' | 'abort' | 'error';
+export type SessionStreamStatus = 'stream' | 'finish' | 'abort';
 
 export async function markStreamStatus(sessionId: string, status: SessionStreamStatus): Promise<void> {
   try {
@@ -87,7 +86,7 @@ export async function loadStreamStatuses(): Promise<Record<string, SessionStream
     }[];
     const map: Record<string, SessionStreamStatus> = {};
     for (const row of rows) {
-      if (row.status === 'stream' || row.status === 'finish' || row.status === 'abort' || row.status === 'error') {
+      if (row.status === 'stream' || row.status === 'finish' || row.status === 'abort') {
         map[row.session_id] = row.status;
       }
     }

package/src/shared/lib/omp/subagent/label.test.ts

@@ -0,0 +1,94 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Covers the boundaries of the subagent label derivation: the Target-section
+ * scan (heading level, colon variant, section end) and the two identity shapes.
+ *
+ * These are the cases where the label is derived from prompt text the caller
+ * controls, so a wrong boundary silently renders template boilerplate or a
+ * section name where the assignment's headline belongs.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { assignmentTarget, subagentHeaderTitle, subagentRowLabel } from '@/shared/lib/omp/subagent/label';
+import type { SubagentInfo } from '@/shared/types/omp/subagent';
+
+/** Minimal roster entry — only the fields the label helpers read. */
+function makeSubagent(overrides: Partial<SubagentInfo> = {}): SubagentInfo {
+  return { id: 'Scout', agent: 'task', status: 'completed', index: 0, ...overrides };
+}
+
+describe('assignmentTarget', () => {
+  test('reads the headline under the task template Target section', () => {
+    const task = 'Complete assignment thoroughly:\n\n# Target\nCount .tsx files under src/.\n\n# Change\nNone.\n\n# Acceptance\nReport the integer.';
+    expect(assignmentTarget(task)).toBe('Count .tsx files under src/.');
+  });
+
+  test('stops at the next heading so Change prose never becomes the headline', () => {
+    const task = '# Target\nMap the panel data model.\n\n# Change\nDo the thing';
+    expect(assignmentTarget(task)).toBe('Map the panel data model.');
+  });
+
+  test('accepts any heading level and a trailing colon', () => {
+    expect(assignmentTarget('## Target:\nHeadline here')).toBe('Headline here');
+    expect(assignmentTarget('### Target\nHeadline here')).toBe('Headline here');
+  });
+
+  test('skips an empty Target section instead of promoting the next section', () => {
+    expect(assignmentTarget('# Target\n\n# Change\nDo the thing')).toBe('Do the thing');
+  });
+
+  test('falls back to the first prose line when no Target section exists', () => {
+    expect(assignmentTarget('Fix the sidebar expand bug')).toBe('Fix the sidebar expand bug');
+    expect(assignmentTarget('# Scope\nNot a target section')).toBe('Not a target section');
+  });
+
+  test('never returns the template lead-in or a bare heading', () => {
+    expect(assignmentTarget('Complete assignment thoroughly:')).toBeUndefined();
+    expect(assignmentTarget('# Target')).toBeUndefined();
+  });
+
+  test('returns undefined for absent or empty text', () => {
+    expect(assignmentTarget(undefined)).toBeUndefined();
+    expect(assignmentTarget('   \n\n  ')).toBeUndefined();
+  });
+});
+
+describe('subagentHeaderTitle', () => {
+  test('appends the model role recorded on a history entry', () => {
+    expect(subagentHeaderTitle(makeSubagent({ modelRole: 'smol' }))).toBe('Scout (task:smol)');
+  });
+
+  test('falls back to the role carried by a live progress frame', () => {
+    expect(subagentHeaderTitle(makeSubagent({ progress: { modelRole: 'task' } }))).toBe('Scout (task:task)');
+  });
+
+  test('omits the role when the run recorded none', () => {
+    expect(subagentHeaderTitle(makeSubagent())).toBe('Scout (task)');
+  });
+});
+
+describe('subagentRowLabel', () => {
+  test('appends the assignment headline to the identity', () => {
+    const subagent = makeSubagent({ task: 'Complete assignment thoroughly:\n\n# Target\nHeadline here.\n\n# Change\nx' });
+    expect(subagentRowLabel(subagent)).toBe('Scout (task): Headline here.');
+  });
+
+  test('reads the assignment field when the task template is absent', () => {
+    expect(subagentRowLabel(makeSubagent({ assignment: '# Target\nFrom the assignment field.' })))
+      .toBe('Scout (task): From the assignment field.');
+  });
+
+  test('falls back to the description, then to the bare identity', () => {
+    expect(subagentRowLabel(makeSubagent({ description: 'fallback description' }))).toBe('Scout (task): fallback description');
+    expect(subagentRowLabel(makeSubagent())).toBe('Scout (task)');
+  });
+
+  test('keeps the identity when the assignment has no usable headline', () => {
+    expect(subagentRowLabel(makeSubagent({ task: '# Target' }))).toBe('Scout (task)');
+  });
+});

package/src/shared/lib/omp/subagent/label.ts

@@ -0,0 +1,84 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * One-line labels for a subagent roster entry.
+ *
+ * A delegated assignment is a task prompt, not a sentence. The wire carries it
+ * twice: `assignment` is the document the caller wrote, and `task` is that same
+ * document wrapped by the task tool's template ("Complete assignment
+ * thoroughly:" followed by `# Target` / `# Change` / `# Acceptance` sections).
+ * Rendering either verbatim in a 268px sidebar row would spend the whole row on
+ * the template's lead-in, so a row shows the Target section's headline — the
+ * one line that says what the agent is for.
+ *
+ * The two surfaces differ only in what they append to the identity:
+ *   roster row  →  `id (agent): target`
+ *   banner      →  `id (agent:modelRole)`
+ */
+
+import type { SubagentInfo } from '@/shared/types/omp/subagent';
+
+/** Any markdown heading — the boundary between prompt sections. */
+const HEADING_RE = /^#{1,6}\s+\S/;
+/** The section the task prompt template mandates as the assignment's summary. */
+const TARGET_HEADING_RE = /^#{1,6}\s+target\s*:?\s*$/i;
+/** The task template's own lead-in; it says nothing about the assignment. */
+const LEAD_IN_RE = /^complete (the )?assignment\b/i;
+
+/** First line of `lines` that has content, trimmed. */
+function firstLine(lines: string[]): string | undefined {
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed) return trimmed;
+  }
+  return undefined;
+}
+
+/**
+ * The headline of a delegated assignment: the first line of its `# Target`
+ * section, falling back to the prompt's own first prose line when there is no
+ * such section (or it is empty).
+ */
+export function assignmentTarget(text: string | undefined): string | undefined {
+  if (!text) return undefined;
+  const lines = text.split('\n');
+  const headingAt = lines.findIndex((line) => TARGET_HEADING_RE.test(line.trim()));
+  if (headingAt !== -1) {
+    // Bounded by the next heading: an empty Target section must not promote the
+    // Change/Acceptance prose that follows it into the headline.
+    const body = lines.slice(headingAt + 1);
+    const nextHeading = body.findIndex((line) => HEADING_RE.test(line.trim()));
+    const headline = firstLine(nextHeading === -1 ? body : body.slice(0, nextHeading));
+    if (headline) return headline;
+  }
+  // No Target section, or an empty one: the prompt's first prose line. Headings
+  // are skipped because a section name is not a summary of the assignment.
+  return firstLine(lines.filter((line) => {
+    const trimmed = line.trim();
+    return !HEADING_RE.test(trimmed) && !LEAD_IN_RE.test(trimmed);
+  }));
+}
+
+/** `id (agent:modelRole)`, or `id (agent)` when no role was recorded. Live
+ *  snapshots carry the role on `progress`; history entries carry it top-level,
+ *  because the on-disk fold records it from the parent's task toolResult rather
+ *  than from a progress frame. */
+export function subagentHeaderTitle(subagent: SubagentInfo): string {
+  const role = subagent.modelRole ?? subagent.progress?.modelRole;
+  return role
+    ? `${subagent.id} (${subagent.agent}:${role})`
+    : `${subagent.id} (${subagent.agent})`;
+}
+
+/** `id (agent): target` — the roster row's one-line label. The description is
+ *  the fallback for entries whose assignment text never reached the roster. */
+export function subagentRowLabel(subagent: SubagentInfo): string {
+  const target = assignmentTarget(subagent.task)
+    ?? assignmentTarget(subagent.assignment)
+    ?? subagent.description;
+  const identity = `${subagent.id} (${subagent.agent})`;
+  return target ? `${identity}: ${target}` : identity;
+}