cli-jaw 2.17.63 → 2.17.64

package/public/manager/src/App.tsx

@@ -21,7 +21,7 @@ import { type ScheduleGroup } from './dashboard-schedule/DashboardScheduleSideba
 import { normalizeSidebarModeForBuild, REMINDERS_WORKSPACE_ENABLED } from './dashboard-features';
 import { readInitialSelectedPort, readInitialSidebarMode, readTrayRemindersMode } from './dashboard-url-state';
 import { TrayRemindersApp } from './dashboard-reminders/TrayRemindersApp';
-import { useDashboardRegistry } from './hooks/useDashboardRegistry';
+import { useDashboardRegistry, useFavoriteToggle } from './hooks/useDashboardRegistry';
 import { useDashboardView, hydrateInstanceSettings, createInstanceSettingsNavigation, useSettingsDirtyState } from './hooks/useDashboardView';
 import { useActivityUnread } from './hooks/useActivityUnread';
 import { useTheme } from './hooks/useTheme';
@@ -470,7 +470,7 @@ export function App() { if (readTrayRemindersMode(window.location.search) && REM
             setTransitionAction(null);
         }
     }
-
+    const toggleFavorite = useFavoriteToggle({ save: registry.save, reload: load });
     const instanceListContent = (
         <InstanceListContent error={error} loading={loading} instances={instances} filtered={filtered}
             selectedInstance={selectedInstance} data={data} lifecycleBusyPort={lifecycleBusyPort}
@@ -481,7 +481,7 @@ export function App() { if (readTrayRemindersMode(window.location.search) && REM
             showSelectedRowActions={view.showSelectedRowActions} profiles={profiles} getLabel={instanceLabel}
             formatUptime={formatUptime} onSelect={handleSelectInstance} onPreview={(instance) => handlePreview(instance, true)}
             onMarkActivitySeen={activityUnread.markPortSeen} onInstanceLabelSave={labelEditor.saveInstanceLabel}
-            onLifecycle={(action, instance) => void handleLifecycle(action, instance)} />
+            onLifecycle={(action, instance) => void handleLifecycle(action, instance)} onToggleFavorite={toggleFavorite} />
     );
     const dashboardSettingsUi = dashboardSettingsUiFromView(view, theme.theme), titleSupport = summarizeActivityTitleSupport(messageActivity.titleSupportByPort);
     const profileChipStrip = (chipProfiles: DashboardProfile[]) => chipProfiles.length > 0 ? <div className="profile-chip-strip drawer-chip-strip" aria-label="Profile filters">{chipProfiles.map(profile => <ProfileChip key={profile.profileId} profile={profile} active={activeProfileIds.includes(profile.profileId)} count={profileCounts[profile.profileId] || 0} onToggle={toggleProfile} />)}</div> : null;

package/public/manager/src/AppChrome.tsx

@@ -129,7 +129,7 @@ export function AppChrome(props: AppChromeProps) {
             <PanelLayoutProvider initialPanelState={props.panelInitialState} onStateChange={props.onPanelStateChange}>
             <ManagerShell
                 sidebarCollapsed={props.view.sidebarCollapsed}
-                commandBar={<CommandBar query={props.query} loading={props.loading} onQueryChange={props.setQuery} onRefresh={() => void props.load()} onOpenDrawer={() => props.view.setDrawerOpen(true)} theme={props.theme.theme} onThemeChange={props.theme.setTheme} onOpenPalette={props.palette.toggle} />}
+                commandBar={<CommandBar query={props.query} loading={props.loading} onQueryChange={props.setQuery} onRefresh={() => void props.load()} onOpenDrawer={() => props.view.setDrawerOpen(true)} theme={props.theme.theme} onThemeChange={props.theme.setTheme} />}
                 workspace={(
                     <SidebarRailRouter sidebarCollapsed={props.view.sidebarCollapsed} activityDockCollapsed={props.view.activityDockCollapsed}
                         activityDockHeight={props.view.activityDockHeight} drawerOpen={props.view.drawerOpen} onCloseDrawer={() => props.view.setDrawerOpen(false)}

package/public/manager/src/background-tasks/BackgroundTaskMonitorPanel.tsx

@@ -1,4 +1,6 @@
 import { useMemo, useState } from 'react';
+import { ContextMenu, useContextMenu, type ContextMenuEntry } from '../components/context-menu/ContextMenu';
+import { CopyGlyph, EyeGlyph, RestartGlyph, StopGlyph } from '../components/context-menu/icons';
 import type { BackgroundTaskRow, BackgroundTaskStatus } from './background-task-client';
 import { countBackgroundTasksByStatus, useBackgroundTasks } from './useBackgroundTasks';
 
@@ -71,23 +73,54 @@ type BackgroundTaskRowProps = {
 };
 
 function BackgroundTaskItem({ task, expanded, busy, onCancel, onCopy, onRetry, onToggle }: BackgroundTaskRowProps) {
+    const menu = useContextMenu();
     const preview = resultPreview(task);
     const isRunning = task.status === 'running';
     const canRetry = task.status !== 'running';
     const note = recoveryNote(task);
+    const menuEntries: ContextMenuEntry[] = [
+        { id: 'details', label: expanded ? 'Hide details' : 'Show details', icon: <EyeGlyph />, onSelect: () => onToggle(task.id) },
+        { kind: 'separator', id: 'sep-actions' },
+        { id: 'retry', label: 'Retry', icon: <RestartGlyph />, disabled: !canRetry || busy, onSelect: () => onRetry(task) },
+        { id: 'cancel', label: 'Cancel', icon: <StopGlyph />, disabled: !isRunning || busy, onSelect: () => onCancel(task.id) },
+        { kind: 'separator', id: 'sep-copy' },
+        { id: 'copy-result', label: 'Copy result', icon: <CopyGlyph />, disabled: !task.result || busy, onSelect: () => onCopy(task) },
+    ];
     return (
-        <li className={`code-bg-task-item is-${task.status}`}>
-            <button type="button" className="code-bg-task-main" onClick={() => onToggle(task.id)} aria-expanded={expanded}>
+        <li className={`code-bg-task-item is-${task.status}`} onContextMenu={menu.openAt}>
+            <button
+                type="button"
+                className="code-bg-task-main"
+                onClick={() => onToggle(task.id)}
+                aria-expanded={expanded}
+                onKeyDown={event => {
+                    if (event.key === 'ContextMenu' || (event.shiftKey && event.key === 'F10')) menu.openAt(event);
+                }}
+            >
                 <span className={`code-bg-task-status is-${task.status}`}>{STATUS_LABEL[task.status]}</span>
                 <span className="code-bg-task-title">{task.id}</span>
                 <span className="code-bg-task-meta">{taskSubtitle(task)}</span>
             </button>
-            <div className="code-bg-task-actions">
-                <button type="button" onClick={() => onRetry(task)} disabled={!canRetry || busy} title="Run this background task spec again">
-                    Retry
+            <div className="code-bg-task-actions jaw-row-hover-actions">
+                <button
+                    type="button"
+                    className="jaw-row-icon-btn"
+                    onClick={() => onRetry(task)}
+                    disabled={!canRetry || busy}
+                    title="Run this background task spec again"
+                    aria-label={`Retry ${task.id}`}
+                >
+                    <RestartGlyph />
                 </button>
-                <button type="button" onClick={() => onCancel(task.id)} disabled={!isRunning || busy} title="Cancel running background task">
-                    Cancel
+                <button
+                    type="button"
+                    className="jaw-row-icon-btn"
+                    onClick={() => onCancel(task.id)}
+                    disabled={!isRunning || busy}
+                    title="Cancel running background task"
+                    aria-label={`Cancel ${task.id}`}
+                >
+                    <StopGlyph />
                 </button>
             </div>
             {expanded && (
@@ -122,6 +155,7 @@ function BackgroundTaskItem({ task, expanded, busy, onCancel, onCopy, onRetry, o
                     ) : null}
                 </div>
             )}
+            <ContextMenu state={menu.state} entries={menuEntries} label={`Background task ${task.id}`} onClose={menu.close} />
         </li>
     );
 }

package/public/manager/src/background-tasks/background-task-monitor.css

@@ -60,7 +60,6 @@
 }
 
 .code-bg-task-refresh,
-.code-bg-task-actions button,
 .code-bg-task-result-head button {
     min-height: 24px;
     padding: 0 8px;
@@ -75,7 +74,6 @@
 }
 
 .code-bg-task-refresh:disabled,
-.code-bg-task-actions button:disabled,
 .code-bg-task-result-head button:disabled {
     opacity: 0.45;
     cursor: not-allowed;
@@ -176,8 +174,7 @@
 }
 
 .code-bg-task-actions {
-    display: flex;
-    gap: 5px;
+    justify-content: flex-end;
 }
 
 .code-bg-task-detail {

package/public/manager/src/code/CodeSessionList.tsx

@@ -1,12 +1,16 @@
 import { useEffect, useId, useRef, useState } from 'react';
+import type { KeyboardEvent as ReactKeyboardEvent } from 'react';
 import type { CodeSessionInfo } from '../../../../src/code-mode/wire';
 import type { CodeControllerModel } from './code-controller-types';
 import { CODE_RUNTIME_LABELS, CODE_SESSION_LABELS, codeCanResume, codeSessionBusy } from './code-types';
 import {
     CODE_ACTIVITY_BUCKET_LABELS, codeSessionAttention, codeSessionAttentionLabel, codeSessionUnread, codeWorkspaceName,
-    groupCodeSessions, groupCodeSessionsByActivity, groupCodeSessionsByWorkspace,
+    comparePinnedCodeSessions, groupCodeSessions, groupCodeSessionsByActivity, groupCodeSessionsByWorkspace,
 } from './session-order';
 import { DEFAULT_MANAGER_SHORTCUT_KEYMAP, formatShortcut } from '../manager-shortcuts';
+import { ContextMenu, useContextMenu, type ContextMenuEntry } from '../components/context-menu/ContextMenu';
+import { ArchiveGlyph, CopyGlyph, EyeGlyph, PencilGlyph, PinGlyph, PlayGlyph } from '../components/context-menu/icons';
+import { copyText } from '../clipboard/copy-text';
 
 const NEW_SESSION_SHORTCUT = DEFAULT_MANAGER_SHORTCUT_KEYMAP.newCodeSession;
 
@@ -43,16 +47,22 @@ function SessionRow({ session: s, controller: c, view }: { session: CodeSessionI
     const [title, setTitle] = useState(s.title ?? '');
     const [pending, setPending] = useState(false);
     const [error, setError] = useState<string | null>(null);
+    const menu = useContextMenu();
     const guard = useRef(false);
     const selectButton = useRef<HTMLButtonElement>(null);
     const errorId = useId();
     const active = c.selectedId === s.sessionId;
     const busy = codeSessionBusy(s);
+    const archived = s.archivedAt !== null;
+    const pinned = s.pinnedAt !== null;
     const count = active && c.synced ? c.permissions.length : s.pendingPermissionCount;
     const attention = codeSessionAttention(count);
-    const unread = !active && codeSessionUnread(s);
+    // An archived row never lights the completion-based unread rule, but an
+    // explicit mark still counts so it can be toggled back off.
+    const unread = !active && (s.markedUnread || codeSessionUnread(s));
     const working = c.workingIds?.has(s.sessionId) ?? false;
     const waiting = working && s.status === 'idle';
+    const name = s.title || 'Untitled session';
     async function action(run: () => Promise<void>, after?: () => void) {
         if (guard.current) return;
         guard.current = true; setPending(true); setError(null);
@@ -61,27 +71,85 @@ function SessionRow({ session: s, controller: c, view }: { session: CodeSessionI
         finally { guard.current = false; setPending(false); }
     }
     function finishRename() { setRenaming(false); selectButton.current?.focus(); }
-    return <li className="code-session-row">
-        <button ref={selectButton} type="button" className={`code-session-item${active ? ' active' : ''}`}
-            aria-current={active ? 'true' : undefined} onClick={() => void action(() => c.selectSession(s.sessionId))}>
-            <span className="code-session-cwd">
-                {unread && <span className="code-session-unread-dot" role="img" aria-label="Unread" />}
-                {s.title || 'Untitled session'}
+    async function copy(value: string) {
+        const result = await copyText(value);
+        if (!result.ok) throw new Error(result.error ?? 'Copy failed.');
+    }
+    const entries: ContextMenuEntry[] = [
+        { id: 'rename', label: 'Rename', icon: <PencilGlyph />, disabled: pending || busy,
+            ...(busy ? { title: 'Stop before renaming' } : {}),
+            onSelect: () => { setTitle(s.title ?? ''); setRenaming(true); } },
+        { id: 'pin', label: pinned ? 'Unpin' : 'Pin', icon: <PinGlyph />, disabled: pending,
+            onSelect: () => void action(() => c.pin(s.sessionId, !pinned)) },
+        { id: 'unread', label: unread ? 'Mark as read' : 'Mark as unread', icon: <EyeGlyph />, disabled: pending || active,
+            ...(active ? { title: 'The open session is already read' } : {}),
+            onSelect: () => void action(() => c.markUnread(s.sessionId, !unread)) },
+        { id: 'archive', label: archived ? 'Restore' : 'Archive', icon: <ArchiveGlyph />, disabled: pending || busy,
+            ...(busy ? { title: 'Stop before archiving' } : {}),
+            onSelect: () => void action(() => c.archive(s.sessionId, !archived)) },
+        ...(codeCanResume(s) ? [
+            { kind: 'separator', id: 'resume-sep' } as const,
+            { id: 'resume', label: 'Resume', icon: <PlayGlyph />, disabled: pending || !active || !c.synced || c.pending,
+                title: !active ? 'Select this session to resume it' : 'Resume without resending a prompt',
+                onSelect: () => void action(c.resume) },
+        ] : []),
+        { kind: 'separator', id: 'copy-sep' },
+        { id: 'copy-id', label: 'Copy session ID', icon: <CopyGlyph />,
+            onSelect: () => void action(() => copy(s.sessionId)) },
+        { id: 'copy-cwd', label: 'Copy working directory', icon: <CopyGlyph />,
+            onSelect: () => void action(() => copy(s.cwd)) },
+    ];
+    function openMenuFromKey(event: ReactKeyboardEvent<HTMLElement>) {
+        if (event.key === 'ContextMenu' || (event.shiftKey && event.key === 'F10')) menu.openAt(event);
+    }
+    return <li className="code-session-row" onContextMenu={event => {
+        if ((event.target as Element).closest('.code-session-rename')) return;
+        menu.openAt(event);
+    }}>
+        <div className="code-session-item-wrap" onKeyDown={openMenuFromKey}>
+            <button ref={selectButton} type="button" className={`code-session-item${active ? ' active' : ''}`}
+                aria-current={active ? 'true' : undefined}
+                onClick={() => void action(() => c.selectSession(s.sessionId))}>
+                <span className="code-session-cwd">
+                    {unread && <span className="code-session-unread-dot" role="img" aria-label="Unread" />}
+                    {name}
+                </span>
+                {/* Projects view already names the workspace in the group heading. */}
+                <span className="code-session-meta" title={s.cwd}>{view === 'activity'
+                    ? `${codeWorkspaceName(s.cwd)} · ${CODE_RUNTIME_LABELS[s.provider]}` : CODE_RUNTIME_LABELS[s.provider]}</span>
+                {/* Ready is the common case and stays silent. A status on every row
+                    is a status on no row, and it costs the one session that is
+                    actually doing something its visibility. */}
+                <span className={`code-session-status code-session-status-${waiting ? 'starting' : s.status}`}
+                    data-quiet={s.status === 'idle' && !working ? 'true' : undefined}>
+                    {working && <span className="code-session-spinner" aria-hidden="true" />}
+                    {waiting ? CODE_SESSION_LABELS.starting : CODE_SESSION_LABELS[s.status]}</span>
+                <span className={`code-session-attention code-session-attention-${attention.kind}`}
+                    data-quiet={attention.kind === 'none' ? 'true' : undefined}>{codeSessionAttentionLabel(attention)}</span>
+            </button>
+            {/* Row actions replace the status text on hover or keyboard focus,
+                Codex-style; opacity keeps them tabbable instead of display:none. */}
+            <span className="code-session-hover-actions">
+                <button type="button" className={`code-session-hover-btn${pinned ? ' is-on' : ''}`}
+                    aria-label={pinned ? `Unpin ${name}` : `Pin ${name}`} aria-pressed={pinned}
+                    title={pinned ? 'Unpin' : 'Pin'} disabled={pending}
+                    onClick={event => { event.stopPropagation(); void action(() => c.pin(s.sessionId, !pinned)); }}>
+                    <PinGlyph />
+                </button>
+                <button type="button" className="code-session-hover-btn"
+                    aria-label={archived ? `Restore ${name}` : `Archive ${name}`}
+                    title={busy ? 'Stop before archiving' : archived ? 'Restore' : 'Archive'} disabled={pending || busy}
+                    onClick={event => { event.stopPropagation(); void action(() => c.archive(s.sessionId, !archived)); }}>
+                    <ArchiveGlyph />
+                </button>
+                <button type="button" className="code-session-hover-btn"
+                    aria-label={`More actions for ${name}`} aria-haspopup="menu" title="More actions"
+                    onClick={event => { event.stopPropagation(); menu.openAtElement(event.currentTarget); }}>
+                    <span aria-hidden="true">⋯</span>
+                </button>
             </span>
-            {/* Projects view already names the workspace in the group heading. */}
-            <span className="code-session-meta" title={s.cwd}>{view === 'activity'
-                ? `${codeWorkspaceName(s.cwd)} · ${CODE_RUNTIME_LABELS[s.provider]}` : CODE_RUNTIME_LABELS[s.provider]}</span>
-            {/* Ready is the common case and stays silent. A status on every row
-                is a status on no row, and it costs the one session that is
-                actually doing something its visibility. */}
-            <span className={`code-session-status code-session-status-${waiting ? 'starting' : s.status}`}
-                data-quiet={s.status === 'idle' && !working ? 'true' : undefined}>
-                {working && <span className="code-session-spinner" aria-hidden="true" />}
-                {waiting ? CODE_SESSION_LABELS.starting : CODE_SESSION_LABELS[s.status]}</span>
-            <span className={`code-session-attention code-session-attention-${attention.kind}`}
-                data-quiet={attention.kind === 'none' ? 'true' : undefined}>{codeSessionAttentionLabel(attention)}</span>
-        </button>
-        {renaming ? <form className="code-session-rename" onSubmit={event => {
+        </div>
+        {renaming && <form className="code-session-rename" onSubmit={event => {
             event.preventDefault(); if (title.trim()) void action(() => c.rename(s.sessionId, title.trim()), finishRename);
         }}>
             <input autoFocus aria-label="Session title" aria-describedby={error ? errorId : undefined} value={title} disabled={pending}
@@ -90,18 +158,8 @@ function SessionRow({ session: s, controller: c, view }: { session: CodeSessionI
                 }} />
             <button type="submit" disabled={pending || !title.trim()}>Save</button>
             <button type="button" disabled={pending} onClick={finishRename}>Cancel</button>
-        </form> : <details className="code-session-actions" key={`${c.selectedId}:${s.sessionId}`}>
-            <summary aria-label={`Actions for ${s.title || 'Untitled session'}`}>Actions</summary>
-            <div>
-                <button type="button" disabled={pending || busy} onClick={() => { setTitle(s.title ?? ''); setRenaming(true); }}>Rename</button>
-                <button type="button" disabled={pending || busy} title={busy ? 'Stop before archiving' : undefined}
-                    onClick={() => void action(() => c.archive(s.sessionId, s.archivedAt === null))}>{s.archivedAt === null ? 'Archive' : 'Restore'}</button>
-                {codeCanResume(s) && <button type="button" disabled={pending || !active || !c.synced || c.pending}
-                    title={!active ? 'Select this session to resume it' : 'Resume without resending a prompt'}
-                    onClick={() => void action(c.resume)}>Resume</button>}
-                {busy && <small>Stop before changing session metadata.</small>}
-            </div>
-        </details>}
+        </form>}
+        <ContextMenu state={menu.state} entries={entries} label={`Actions for ${name}`} onClose={menu.close} />
         {pending && <span className="code-session-view-hint" role="status">Updating session…</span>}
         {error && <div id={errorId} className="code-session-list-error" role="alert">{error}</div>}
     </li>;
@@ -131,12 +189,14 @@ export function CodeSessionList({ controller: c, newSessionShortcut = NEW_SESSIO
     // answering a prompt never moves a row under the reader's cursor. Activity is the
     // reader's explicit choice: unread first, then last activity by day.
     const anyUnread = c.sessions.some(row => row.sessionId !== c.selectedId && codeSessionUnread(row));
-    const live = visible.filter(row => row.archivedAt === null);
+    const pinned = visible.filter(row => row.archivedAt === null && row.pinnedAt !== null).sort(comparePinnedCodeSessions);
+    const live = visible.filter(row => row.archivedAt === null && row.pinnedAt === null);
     const archived = visible.filter(row => row.archivedAt !== null);
     const groups: { key: string; title: string; cwd: string | null; sessions: CodeSessionInfo[] }[] = view === 'activity'
         ? groupCodeSessionsByActivity(live, Date.now(), c.selectedId).map(group => ({
             key: group.bucket, title: CODE_ACTIVITY_BUCKET_LABELS[group.bucket], cwd: null, sessions: group.sessions }))
         : groupCodeSessionsByWorkspace(live).map(group => ({ key: group.cwd, title: group.cwd, cwd: group.cwd, sessions: group.sessions }));
+    if (pinned.length) groups.unshift({ key: 'pinned', title: 'Pinned', cwd: null, sessions: pinned });
     if (archived.length) groups.push({ key: 'archived', title: 'Archived', cwd: null, sessions: groupCodeSessions(archived).flatMap(group => group.sessions) });
     // The chord resolves through the manager shortcut system (rebindable in
     // Settings); the runner re-broadcasts it here so Code mode can be absent

package/public/manager/src/code/code-controller-runtime.ts

@@ -87,6 +87,7 @@ export class CodeController {
     private book: CodeDraftBook;
     private details = new Map<string, CodeSessionState>();
     private summaries = new Map<string, CodeSessionInfo>();
+    private pinnedOverlay: CodeSessionInfo[] = [];
     private attention = new Map<string, CodeSessionAttention>();
     private rows: string[] = [];
     private catalog: CodeModelCatalog | null = null;
@@ -162,6 +163,7 @@ export class CodeController {
             this.book.listeners.delete(this.changed);
             this.details.clear();
             this.summaries.clear();
+            this.pinnedOverlay = [];
             this.attention.clear();
             this.rows = [];
             this.cursor = null;
@@ -196,7 +198,9 @@ export class CodeController {
         if (!id) return null;
         const detail = this.details.get(id)?.session;
         const summary = this.summaries.get(id);
-        return summary && newer(summary, detail) ? summary : detail ?? summary ?? null;
+        const overlay = this.pinnedOverlay.find(row => row.sessionId === id);
+        return [detail, summary, overlay].reduce<CodeSessionInfo | null>((best, row) =>
+            row && newer(row, best) ? row : best, null);
     }
     /**
      * Record what an owning read saw. Call this BEFORE accept() on the same object:
@@ -236,9 +240,15 @@ export class CodeController {
         // observe(), and update() hands over details.session, which the reducer may
         // still be holding (code-session-state.ts snapshot replace).
         const { contextUsage: _usage, pendingPermissionCount: _count, ...session } = incoming;
+        const overlayIndex = this.pinnedOverlay.findIndex(row => row.sessionId === session.sessionId);
+        if (overlayIndex !== -1) {
+            if (session.pinnedAt === null || session.archivedAt !== null) this.pinnedOverlay.splice(overlayIndex, 1);
+            else this.pinnedOverlay[overlayIndex] = session;
+        }
         this.summaries.set(session.sessionId, session);
         if (this.summaries.size > MAX_INDEX + MAX_DETAILS) {
-            const victim = [...this.summaries.keys()].find(id => id !== this.book.selectedId && !this.details.has(id) && !this.rows.includes(id));
+            const victim = [...this.summaries.keys()].find(id => id !== this.book.selectedId && !this.details.has(id)
+                && !this.rows.includes(id) && !this.pinnedOverlay.some(row => row.sessionId === id));
             if (victim) { this.summaries.delete(victim); this.attention.delete(victim); }
         }
         const draft = this.book.sessions.get(session.sessionId);
@@ -376,7 +386,7 @@ export class CodeController {
             && item.itemId.startsWith(`${session.turnId}:steer:`));
         const unconfirmed = draft.steer?.state !== 'unknown' ? null : draft.steer.unrecorded ? FOLLOW_UP_UNRECORDED : FOLLOW_UP_UNCONFIRMED;
         return {
-            catalog: this.catalog, sessions: this.rows.map(id => {
+            catalog: this.catalog, sessions: [...this.rows, ...this.pinnedOverlay.map(row => row.sessionId).filter(id => !this.rows.includes(id))].map(id => {
                 const row = this.info(id), detail = this.details.get(id);
                 return row ? publish(row, detail) : row;
             }).filter((row): row is CodeSessionInfo => !!row),
@@ -386,7 +396,7 @@ export class CodeController {
             input: draft.input, selection: session ? sessionSelection(session) : draft.selection,
             gitInfo: this.gitInfo, loading: this.indexLoading || !!detail?.hydrating || (!!id && !detail?.hydrated && !detail?.error),
             pending, busy: codeSessionBusy(session), working: !!draft.awaitingTurn || codeSessionBusy(session),
-            workingIds: new Set(this.rows.filter(rowId => {
+            workingIds: new Set([...this.rows, ...this.pinnedOverlay.map(row => row.sessionId)].filter(rowId => {
                 const row = this.info(rowId);
                 return !!this.book.sessions.get(rowId)?.awaitingTurn || (!!row && codeSessionBusy(row));
             })), followUp, followUpSent, steering: draft.steer?.state === 'sending', synced, transport: this.transport, workspacePicking: this.workspacePicking,
@@ -400,7 +410,7 @@ export class CodeController {
             newSession: this.newSession, selectSession: this.selectSession, setInput: this.setInput,
             setSelection: this.setSelection, pickWorkspace: this.pickWorkspace, send: this.send,
             retrySameSend: this.retrySameSend, stop: this.stop, resume: this.resume, rollbackSession: this.rollbackSession, rename: this.rename,
-            archive: this.archive, answer: this.answer, refresh: this.refresh, loadMoreSessions: this.loadMoreSessions,
+            archive: this.archive, pin: this.pin, markUnread: this.markUnread, answer: this.answer, refresh: this.refresh, loadMoreSessions: this.loadMoreSessions,
             loadOlderHistory: this.loadOlderHistory, setFilter: this.setFilter, clearError: this.clearError,
         };
     }
@@ -434,7 +444,13 @@ export class CodeController {
             const page = await this.client.listSessions({ ...this.filter, limit,
                 ...(cursor === null ? {} : { cursor }),
                 ...(this.filter.scope === 'cwd' ? { cwd: this.workingDir } : {}) }, this.abort.signal);
+            const overlay = more || this.filter.archived ? null : await this.client.listSessions({
+                ...(this.filter.scope === 'cwd' ? { cwd: this.workingDir } : {}),
+                archived: false, pinned: true, limit: MAX_INDEX,
+            }, this.abort.signal).catch(() => null);
             if (!this.active || life !== this.lifetime || generation !== this.indexGeneration) return;
+            if (!more && !overlay) this.pinnedOverlay = [];
+            this.rows = [...new Set([...(more ? this.rows : []), ...page.sessions.map(row => row.sessionId)])].slice(0, MAX_INDEX);
             for (const session of page.sessions) {
                 // A listing is one of the two reads that can see the live runtime.
                 this.observe(session);
@@ -445,12 +461,23 @@ export class CodeController {
                     void this.sync(session.sessionId);
                 }
             }
-            this.rows = [...new Set([...(more ? this.rows : []), ...page.sessions.map(row => row.sessionId)])].slice(0, MAX_INDEX);
+            if (overlay) {
+                const retained: CodeSessionInfo[] = [];
+                for (const remote of overlay.sessions) {
+                    const local = this.info(remote.sessionId);
+                    const session = local && !newer(remote, local) ? local : remote;
+                    if (session.pinnedAt === null || session.archivedAt !== null) continue;
+                    retained.push(session);
+                    if (session === remote) { this.observe(session); this.accept(session); }
+                }
+                this.pinnedOverlay = retained;
+            }
             this.cursor = page.nextCursor;
             this.fetched = (more ? this.fetched : 0) + page.sessions.length;
             this.moreSessions = page.hasMore && this.rows.length < MAX_INDEX;
             this.indexError = null;
-            const retained = new Set([...this.rows, ...this.details.keys(), ...(this.book.selectedId ? [this.book.selectedId] : [])]);
+            const retained = new Set([...this.rows, ...this.pinnedOverlay.map(row => row.sessionId),
+                ...this.details.keys(), ...(this.book.selectedId ? [this.book.selectedId] : [])]);
             for (const id of this.summaries.keys()) if (!retained.has(id)) { this.summaries.delete(id); this.attention.delete(id); }
         } catch (error) {
             if (this.active && life === this.lifetime && generation === this.indexGeneration) this.indexError = message(error);
@@ -557,7 +584,7 @@ export class CodeController {
         await Promise.all([this.readCatalog(), this.readIndex(), id ? this.sync(id, true) : Promise.resolve(), this.readGit()]);
     };
     loadMoreSessions = async (): Promise<void> => { if (this.moreSessions && !this.indexLoading) await this.readIndex(true); };
-    setFilter = (filter: CodeSessionFilter): void => { this.filter = { ...filter }; this.cursor = null; this.fetched = 0; this.rows = []; this.moreSessions = false; this.notify(); void this.readIndex(); };
+    setFilter = (filter: CodeSessionFilter): void => { this.filter = { ...filter }; this.cursor = null; this.fetched = 0; this.rows = []; this.pinnedOverlay = []; this.moreSessions = false; this.notify(); void this.readIndex(); };
     // Explicitly abandon only the local uncertain attempt. The server session may exist.
     startAnotherSession = (): void => {
         const previous = this.book.fresh;
@@ -704,6 +731,37 @@ export class CodeController {
     // Other actions report handled failures through the controller model.
     rename = async (id: string, title: string): Promise<void> => { await this.patch(id, { title }, true); };
     archive = async (id: string, archived: boolean): Promise<void> => { await this.patch(id, { archived }, true); };
+    // Sidebar metadata is allowed while a session is busy, but it still shares
+    // the per-session operation slot: two PATCHes would race on the same
+    // expectedRevision and one would lose.
+    private async sidebarPatch(id: string, input: { pinned?: boolean; unread?: boolean }): Promise<void> {
+        const draft = this.draft(id);
+        const session = this.info(id);
+        if (!session || draft.operation.kind !== 'idle') {
+            const error = new Error(!session ? 'Refresh this session before changing it.'
+                : 'Wait for the current session action to finish before changing it.');
+            draft.operation.error = error.message; this.notify();
+            throw error;
+        }
+        let failure: Error | null = null;
+        draft.operation = { kind: 'patching', error: null }; this.notify();
+        try {
+            this.accept(await this.client.patchSession(id, { ...input, expectedRevision: session.revision }));
+            draft.operation = { kind: 'idle', error: null };
+        } catch (error) {
+            if (error instanceof CodeClientError && error.session?.sessionId === id) {
+                // A revision conflict answers with the snapshot session, overlay included.
+                this.observe(error.session);
+                this.accept(error.session);
+            }
+            failure = error instanceof CodeClientError ? error : new Error(message(error));
+            draft.operation = { kind: 'idle', error: failure.message };
+        }
+        this.notify(); this.scheduleIndex();
+        if (failure) throw failure;
+    }
+    pin = async (id: string, pinned: boolean): Promise<void> => { await this.sidebarPatch(id, { pinned }); };
+    markUnread = async (id: string, unread: boolean): Promise<void> => { await this.sidebarPatch(id, { unread }); };
     send = async (): Promise<void> => {
         let id = this.book.selectedId;
         let draft = this.draft(id);

package/public/manager/src/code/code-controller-types.ts

@@ -64,6 +64,10 @@ export interface CodeControllerModel {
     rollbackSession(itemId: string): Promise<void>;
     rename(id: string, title: string): Promise<void>;
     archive(id: string, archived: boolean): Promise<void>;
+    /** Sidebar pin/unpin; allowed while the session is busy. */
+    pin(id: string, pinned: boolean): Promise<void>;
+    /** Sidebar mark unread/read; allowed while the session is busy. */
+    markUnread(id: string, unread: boolean): Promise<void>;
     answer(permission: CodePermissionRequest, optionId: string): Promise<void>;
     refresh(): Promise<void>;
     loadMoreSessions(): Promise<void>;

package/public/manager/src/code/code-session-client.ts

@@ -29,7 +29,7 @@ export interface CodeGitInfo {
 }
 
 export interface CodeListOptions {
-    scope?: 'all' | 'cwd'; cwd?: string; archived?: boolean; cursor?: string; limit?: number;
+    scope?: 'all' | 'cwd'; cwd?: string; archived?: boolean; pinned?: boolean; cursor?: string; limit?: number;
 }
 export interface CodeSessionClient {
     listSessions(options?: CodeListOptions, signal?: AbortSignal): Promise<CodeSessionPage>;

package/public/manager/src/code/code-session-sidebar.css

@@ -36,3 +36,35 @@
     display: flex; align-items: center; gap: 6px; padding: 8px 12px 12px;
     color: var(--text-dim); font-size: 12px;
 }
+
+/* Row hover actions: pin + archive replace the status text at the right edge,
+   Codex-style. Opacity (not display) keeps them in the tab order. */
+.code-session-item-wrap { position: relative; }
+.code-session-hover-actions {
+    position: absolute; top: 50%; right: 6px; transform: translateY(-50%);
+    display: inline-flex; align-items: center; gap: 2px;
+    opacity: 0; pointer-events: none;
+}
+.code-session-row:hover .code-session-hover-actions,
+.code-session-row:focus-within .code-session-hover-actions { opacity: 1; pointer-events: auto; }
+@media (hover: none) {
+    .code-session-hover-actions { opacity: 1; pointer-events: auto; }
+}
+.code-session-hover-btn {
+    display: inline-flex; align-items: center; justify-content: center;
+    width: 22px; height: 22px; min-height: 22px; padding: 0;
+    border: none; border-radius: 5px;
+    background: transparent; color: var(--text-dim); cursor: pointer;
+}
+.code-session-hover-btn:hover:not(:disabled) { background: var(--accent-soft); color: var(--accent); }
+.code-session-hover-btn.is-on { color: var(--accent); }
+.code-session-row:hover .code-session-item,
+.code-session-row:focus-within .code-session-item { padding-right: 78px; }
+@media (hover: none) {
+    .code-session-item { padding-right: 78px; }
+    .code-session-status { visibility: hidden; }
+}
+/* Only the status text yields to the hover icons; a pending-approval marker
+   stays on screen — hovering to pin must not hide the thing asking for input. */
+.code-session-row:hover .code-session-status,
+.code-session-row:focus-within .code-session-status { visibility: hidden; }

package/public/manager/src/code/code.css

@@ -775,9 +775,7 @@
     white-space: nowrap;
 }
 .code-session-row { margin-bottom: 6px; }
-.code-session-actions { font-size: 11px; color: var(--text-secondary); margin: 0 8px; }
-.code-session-actions summary { cursor: pointer; min-height: 24px; }
-.code-session-actions > div, .code-session-rename { display: flex; flex-wrap: wrap; gap: 6px; padding: 4px 0; }
+.code-session-rename { display: flex; flex-wrap: wrap; gap: 6px; padding: 4px 0; }
 .code-session-rename input { min-width: 0; width: 100%; padding: 5px; border: 1px solid var(--border-subtle); border-radius: var(--radius-sm); background: var(--bg-base); color: var(--text-primary); font: inherit; }
 .code-session-archive-filter { display: flex; align-items: center; gap: 5px; margin: 4px 8px 8px; color: var(--text-secondary); font-size: 11px; }
 .code-session-search { box-sizing: border-box; }
@@ -792,7 +790,7 @@
 .code-message-text { overflow-wrap: anywhere; }
 .code-transcript-controls { display: flex; flex-wrap: wrap; gap: 8px; padding: 4px 16px; }
 .code-transcript-controls:empty { display: none; }
-.code-transcript-controls button, .code-inline-action, .code-session-actions button,
+.code-transcript-controls button, .code-inline-action,
 .code-session-rename button, .code-input-recovery button, .code-transport-status button,
 .code-recovery-strip button { min-height: 26px; padding: 3px 8px; border: 1px solid var(--border-subtle); border-radius: var(--radius-sm); background: var(--bg-panel); color: var(--text-primary); font: inherit; font-size: 11px; cursor: pointer; }
 .code-canvas button:disabled, .code-session-list button:disabled { opacity: .6; cursor: not-allowed; }

package/public/manager/src/code/session-order.ts

@@ -24,6 +24,14 @@ export function compareCodeSessions(left: CodeSessionInfo, right: CodeSessionInf
     return right.createdAt - left.createdAt || left.sessionId.localeCompare(right.sessionId);
 }
 
+/**
+ * Pinned rows leave their workspace or activity group and sit together on top,
+ * most recently pinned first. `null` sorts below any real pin.
+ */
+export function comparePinnedCodeSessions(left: CodeSessionInfo, right: CodeSessionInfo): number {
+    return (right.pinnedAt ?? 0) - (left.pinnedAt ?? 0) || compareCodeSessions(left, right);
+}
+
 export type CodeSessionGroup = {
     section: CodeSessionSection;
     sessions: CodeSessionInfo[];
@@ -77,6 +85,7 @@ export function codeSessionAttentionLabel(attention: CodeSessionAttention): stri
  */
 export function codeSessionUnread(session: CodeSessionInfo): boolean {
     if (session.archivedAt !== null) return false;
+    if (session.markedUnread) return true;
     const completed = session.lastTurnCompletedAt;
     const visited = session.lastVisitedAt;
     if (completed === null || visited === null) return false;

package/public/manager/src/components/CommandBar.tsx

@@ -12,7 +12,6 @@ type CommandBarProps = {
     onRefresh: () => void;
     onOpenDrawer: () => void;
     onThemeChange: (next: DashboardUiTheme) => void;
-    onOpenPalette: () => void;
 };
 
 export function CommandBar(props: CommandBarProps) {
@@ -47,15 +46,6 @@ export function CommandBar(props: CommandBarProps) {
                 <div className="command-actions-group">
                     <DesktopPanelControls />
                     <DesktopLink />
-                    <button
-                        type="button"
-                        className="command-palette-trigger"
-                        onClick={props.onOpenPalette}
-                        aria-label="Open command palette"
-                        title="Open command palette (⌘K / Ctrl+K)"
-                    >
-                        <span aria-hidden="true">⌘K</span>
-                    </button>
                     <ThemeSwitch theme={props.theme} onChange={props.onThemeChange} />
                     <button
                         type="button"

package/public/manager/src/components/InstanceGroups.tsx

@@ -43,6 +43,7 @@ type InstanceGroupsProps = {
     onPreview: (instance: DashboardInstance) => void;
     onMarkActivitySeen: (port: number) => void;
     onInstanceLabelSave: (port: number, label: string | null) => Promise<void>;
+    onToggleFavorite?: (instance: DashboardInstance) => void;
     onLifecycle: (action: DashboardLifecycleAction, instance: DashboardInstance) => void;
 };
 
@@ -139,6 +140,7 @@ function renderInstanceRow(
             onPreview={props.onPreview}
             onMarkActivitySeen={props.onMarkActivitySeen}
             onInstanceLabelSave={props.onInstanceLabelSave}
+            {...(props.onToggleFavorite !== undefined ? { onToggleFavorite: props.onToggleFavorite } : {})}
             onLifecycle={props.onLifecycle}
             jumpHint={jumpHint ?? null}
         />