cli-jaw 2.17.62 → 2.17.63

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

@@ -6,10 +6,11 @@ import type { CodeControllerModel, CodeControllerOptions, CodeSessionFilter, Cod
 import { CodeClientError, codeBaseOrigin, createCodeSessionClient, type CodeGitInfo } from './code-session-client';
 import { emptyCodeSession, reduceCodeSession, codeSessionBusy, type CodeSessionState } from './code-session-state';
 import {
-    acknowledgeCodeSend, catalogSelection, codeDraftBook, createCodeDraft, persistCodeDraftBook, sessionSelection,
+    acknowledgeCodeSend, acknowledgeCodeSteer, catalogSelection, codeDraftBook, createCodeDraft, persistCodeDraftBook, sessionSelection,
     type CodeDraft, type CodeDraftBook,
 } from './code-controller-drafts';
 import { withPendingUserItem } from './pending-user-item';
+import { codeCanResume, codeCanRollback, codeResendCopy, type CodeResendReason } from './code-types';
 
 const MAX_DETAILS = 6;
 const MAX_INDEX = 1000;
@@ -18,6 +19,14 @@ const MAX_CATCHUP_PAGES = 32;
 const INDEX_DEBOUNCE_MS = 150;
 const message = (error: unknown) => error instanceof CodeClientError ? error.message : 'Connection lost. Refresh to check the current state.';
 const rejected = (error: unknown) => error instanceof CodeClientError && error.status >= 400 && error.status < 500;
+// A lost response may still be committed, so its message can arrive; a `steer_outcome_unknown` answer
+// means the server could not record it, so it never will.
+const FOLLOW_UP_UNCONFIRMED = 'Follow-up delivery not confirmed. It was not resent; it appears in the conversation if Claude received it.';
+const FOLLOW_UP_UNRECORDED = 'Follow-up delivery not confirmed. Claude may have received it, but it will not appear in the conversation. It was not resent.';
+// A rollback posts the revision and epoch the user chose the row at; PATCH's settings copy does not fit its conflict.
+const ROLLBACK_CONFLICT = 'The conversation changed since you chose this point. Review it and try again.';
+// A rollback seen from elsewhere, for a send whose key nothing ties to a removed turn.
+const ROLLED_BACK_ELSEWHERE = 'The conversation was rolled back elsewhere; this message was not sent.';
 const newer = (incoming: CodeSessionInfo, current?: CodeSessionInfo | null) => !current
     || incoming.epoch > current.epoch || (incoming.epoch === current.epoch && (incoming.sequence > current.sequence
         || (incoming.sequence === current.sequence && incoming.revision >= current.revision)));
@@ -89,6 +98,7 @@ export class CodeController {
     private gitError: string | null = null;
     private gitGeneration = 0;
     private pickerGeneration = 0;
+    private workspacePicking = false;
     private indexGeneration = 0;
     private catalogGeneration = 0;
     private lifetime = 0;
@@ -213,7 +223,14 @@ export class CodeController {
     }
     private accept(incoming: CodeSessionInfo): void {
         if (!this.active) return;
-        if (!newer(incoming, this.info(incoming.sessionId))) return;
+        const before = this.info(incoming.sessionId);
+        if (!newer(incoming, before)) return;
+        // A turn that finishes while its session is open was seen: receipt it so the
+        // sidebar does not mark it unread. The receipt's own echo leaves the clock alone.
+        if (incoming.sessionId === this.book.selectedId && before
+            && (incoming.lastTurnCompletedAt ?? 0) > (before.lastTurnCompletedAt ?? 0)) {
+            void this.markVisited(incoming.sessionId);
+        }
         // The ranked record carries identity and lifecycle only. Attached fields are
         // dropped by copy, never by mutation: readIndex hands the same row to
         // observe(), and update() hands over details.session, which the reducer may
@@ -225,6 +242,8 @@ export class CodeController {
             if (victim) { this.summaries.delete(victim); this.attention.delete(victim); }
         }
         const draft = this.book.sessions.get(session.sessionId);
+        // Once the server reports the turn, its own status carries the working state.
+        if (draft?.awaitingTurn && codeSessionBusy(session)) draft.awaitingTurn = null;
         if (draft?.stopTarget && (session.turnId !== draft.stopTarget.turnId || session.epoch !== draft.stopTarget.epoch
             || !codeSessionBusy(session))) {
             draft.stopTarget = null;
@@ -253,13 +272,36 @@ export class CodeController {
         }
     }
     private update(id: string, state: CodeSessionState): void {
+        // A trimmed or reloaded detail holds no session of its own; the index copy, read before
+        // accept() below can replace it, is then the last generation this page saw.
+        const before = this.details.get(id)?.session ?? this.summaries.get(id);
         this.details.set(id, state);
         if (state.session) this.accept(state.session);
         const draft = this.book.sessions.get(id);
+        if (draft && state.session && state.hydrated && !state.needsSnapshot) {
+            const generation = state.session.historyGeneration ?? 0;
+            if (before && generation > (before.historyGeneration ?? 0)) this.rolledBack(draft, state);
+            // Also without that copy: once any rollback happened, a follow-up whose turn is gone
+            // can no longer appear, so its unconfirmed notice goes.
+            const steer = draft.steer;
+            if (generation > 0 && steer?.state === 'unknown' && !state.items.some(item => item.turnId === steer.turnId)) draft.steer = null;
+        }
         if (draft?.retry && state.items.some(item => item.kind === 'user_message' && item.clientTurnKey === draft.retry!.key)) {
             if (deadSend(state, draft.retry.key)) this.requireNewKey(draft);
             else acknowledgeCodeSend(draft, draft.retry.key);
         }
+        if (draft?.steer && state.items.some(item => item.kind === 'user_message' && item.clientTurnKey === draft.steer!.key)) {
+            acknowledgeCodeSteer(draft, draft.steer.key);
+        }
+        if (draft?.awaitingTurn) {
+            // Only this send's own turn ending clears the marker: a stale read receipt or
+            // an older sequence must not switch a fresh send's spinner off.
+            const turnId = state.items.find(item => item.kind === 'user_message' && item.clientTurnKey === draft.awaitingTurn)?.turnId;
+            if (turnId && state.items.some(item => item.turnId === turnId
+                && (item.kind === 'turn_completed' || item.kind === 'turn_failed' || item.kind === 'turn_cancelled'))) {
+                draft.awaitingTurn = null;
+            }
+        }
         if (draft && state.synced) {
             const current = new Set(state.permissions.map(p => p.permissionId));
             for (const key of Object.keys(draft.permissionOperations)) {
@@ -276,10 +318,40 @@ export class CodeController {
      * can actually be admitted, and it also stops the settled turn's own
      * `user_message` from matching, so this fires once rather than on every read.
      */
-    private requireNewKey(draft: CodeDraft): void {
+    private requireNewKey(draft: CodeDraft, reason?: CodeResendReason): void {
         if (!draft.retry) return;
-        draft.retry = { ...draft.retry, key: crypto.randomUUID(), resend: true };
-        draft.operation = { kind: 'unknown-send', error: 'The original attempt ended on the server without running. The message was not resent; Retry will submit it as a new message.' };
+        const { resendReason: _previous, ...retry } = draft.retry;
+        draft.retry = { ...retry, key: crypto.randomUUID(), resend: true, ...(reason ? { resendReason: reason } : {}) };
+        draft.operation = { kind: 'unknown-send', error: codeResendCopy(reason).error };
+    }
+    /**
+     * A rollback removed turns, possibly the one this draft is waiting on. A send whose own
+     * row is gone no longer has a turn to wait for. An unconfirmed send keeps its key: seeing
+     * its row would have settled it, so nothing here ties the key to a removed turn. A same-key
+     * retry is then admitted once, or answers `cancelled` and submit() names the rollback. A
+     * key already retired says it was not sent. (An unconfirmed follow-up of a removed turn is
+     * dropped by update(); one still in flight settles on its own answer.)
+     */
+    private rolledBack(draft: CodeDraft, state: CodeSessionState): void {
+        const kept = (key: string) => state.items.some(item => item.kind === 'user_message' && item.clientTurnKey === key);
+        if (draft.awaitingTurn && !kept(draft.awaitingTurn)) draft.awaitingTurn = null;
+        if (draft.retry && !draft.retry.resend && !kept(draft.retry.key)
+            && (draft.operation.kind === 'idle' || draft.operation.kind === 'unknown-send')) {
+            draft.operation = { kind: 'unknown-send', error: ROLLED_BACK_ELSEWHERE };
+        }
+    }
+    /**
+     * A spent key answers `cancelled` both for a turn that was stopped and for one a rollback
+     * removed. Every turn this detail has read past (its cursor is at or after the receipt), in
+     * a window that reaches back to it, still has items unless a rollback deleted them, so the
+     * turn's absence there says which. The HTTP receipt is all a reloaded page has: the
+     * transcript that held the turn is gone with the rollback.
+     */
+    private removedByRollback(id: string, receipt: CodePromptReceipt): boolean {
+        const state = this.details.get(id);
+        return receipt.status === 'cancelled' && !!state?.hydrated && (state.session?.historyGeneration ?? 0) > 0
+            && receipt.sequence <= state.cursor && (!state.hasOlder || (state.beforeSequence ?? Infinity) <= receipt.sequence)
+            && !state.items.some(item => item.turnId === receipt.turnId);
     }
     private makeModel(): CodeControllerModel {
         const id = this.book.selectedId;
@@ -295,28 +367,39 @@ export class CodeController {
         const session = canonical ? publish(canonical, detail) : canonical;
         const operation = draft.operation;
         const persistenceWarning = this.book.storageWarning ?? this.book.recoveryWarning;
-        const pending = ['creating', 'sending', 'stopping', 'resuming', 'patching'].includes(operation.kind) && !operation.error;
+        const pending = ['creating', 'sending', 'stopping', 'resuming', 'patching', 'rolling-back'].includes(operation.kind) && !operation.error;
         const synced = id === null ? !!this.catalog : !!detail?.synced && (!session || session.sequence <= detail.cursor) && draft.requiredSequence <= (detail?.cursor ?? 0);
+        const followUp = !!session && synced && session.provider === 'claude' && session.status === 'streaming'
+            && !!session.turnId && session.archivedAt === null;
+        // The turn's one follow-up is already in the transcript.
+        const followUpSent = followUp && !!session && (detail?.items ?? []).some(item => item.kind === 'user_message'
+            && 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 => {
                 const row = this.info(id), detail = this.details.get(id);
                 return row ? publish(row, detail) : row;
             }).filter((row): row is CodeSessionInfo => !!row),
             selectedId: id, session, items: withPendingUserItem(draft, detail?.items ?? []),
+            hasUnsentDraft: !!this.book.fresh.input.trim() || this.book.fresh.createUnknown || !!this.book.fresh.retry,
             permissions: detail?.permissions ?? [],
             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), synced, transport: this.transport,
-            error: [operation.error ?? detail?.error ?? this.indexError ?? this.catalogError ?? this.gitError ?? session?.error?.message, persistenceWarning].filter(Boolean).join(' ') || null,
+            pending, busy: codeSessionBusy(session), working: !!draft.awaitingTurn || codeSessionBusy(session),
+            workingIds: new Set(this.rows.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,
+            error: [operation.error ?? unconfirmed ?? detail?.error ?? this.indexError ?? this.catalogError ?? this.gitError ?? session?.error?.message, persistenceWarning].filter(Boolean).join(' ') || null,
             operation: { ...operation, error: operation.error && persistenceWarning ? `${operation.error} ${persistenceWarning}` : operation.error }, retryText: draft.retry?.text ?? null,
             canRetrySameSend: !!id && operation.kind === 'unknown-send' && !!draft.retry && synced && session?.archivedAt === null,
-            resendRequired: !!draft.retry?.resend,
+            resendRequired: !!draft.retry?.resend, resendReason: draft.retry?.resend ? draft.retry.resendReason ?? null : null,
             permissionOperations: { ...draft.permissionOperations }, hasMoreSessions: this.moreSessions,
             hasOlderHistory: detail?.hasOlder ?? false, filter: this.filter,
             creationUnknown: id === null && draft.createUnknown, startAnotherSession: this.startAnotherSession,
             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, rename: this.rename,
+            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,
             loadOlderHistory: this.loadOlderHistory, setFilter: this.setFilter, clearError: this.clearError,
         };
@@ -445,6 +528,10 @@ export class CodeController {
         if (event.session?.sessionId === event.sessionId) this.accept(event.session);
         if (event.event === 'code_session' || event.item?.kind === 'permission_request' || event.update?.status) this.scheduleIndex();
         const draft = this.book.sessions.get(event.sessionId);
+        if (event.item?.kind === 'user_message' && event.item.clientTurnKey && draft?.steer?.key === event.item.clientTurnKey) {
+            draft.requiredSequence = Math.max(draft.requiredSequence, event.sequence);
+            acknowledgeCodeSteer(draft, event.item.clientTurnKey);
+        }
         if (event.item?.kind === 'user_message' && event.item.clientTurnKey && draft?.retry?.key === event.item.clientTurnKey) {
             draft.requiredSequence = Math.max(draft.requiredSequence, event.sequence);
             if (deadSend(this.details.get(event.sessionId), event.item.clientTurnKey)) this.requireNewKey(draft);
@@ -492,12 +579,21 @@ export class CodeController {
         this.gitInfo = null;
         this.notify();
         await this.sync(id, true);
+        if (this.book.selectedId === id) void this.markVisited(id);
         if (this.book.selectedId === id) await this.readGit();
     };
+    /** Read receipt for the unread marker. A failure only leaves the marker on; selection never waits for it. */
+    private async markVisited(id: string): Promise<void> {
+        try {
+            this.accept(await this.client.visitSession(id));
+            this.notify();
+        } catch { /* the next open retries */ }
+    }
     setInput = (text: string): void => { const draft = this.draft(); draft.input = text; draft.edit++; this.notify(); };
     clearError = (): void => {
         const draft = this.draft();
         if (draft.operation.kind === 'idle') draft.operation = { kind: 'idle', error: null };
+        if (draft.steer?.state === 'unknown') draft.steer = null;
         this.indexError = null;
         this.book.recoveryWarning = null;
         this.notify();
@@ -521,8 +617,10 @@ export class CodeController {
     }
     pickWorkspace = async (): Promise<void> => {
         const draft = this.book.fresh;
-        if (this.book.selectedId !== null || draft.operation.kind !== 'idle' || draft.createUnknown) return;
+        if (this.book.selectedId !== null || draft.operation.kind !== 'idle' || draft.createUnknown || this.workspacePicking) return;
         const navigation = this.book.navigation, selectionEdit = draft.selectionEdit, generation = ++this.pickerGeneration;
+        this.workspacePicking = true;
+        this.notify();
         try {
             const result = await this.client.pickWorkspace();
             if (!this.active || generation !== this.pickerGeneration || navigation !== this.book.navigation
@@ -534,6 +632,9 @@ export class CodeController {
         } catch (error) {
             if (this.active && generation === this.pickerGeneration && navigation === this.book.navigation
                 && selectionEdit === draft.selectionEdit && draft === this.book.fresh && draft.operation.kind === 'idle') { draft.operation.error = message(error); this.notify(); }
+        } finally {
+            this.workspacePicking = false;
+            this.notify();
         }
     };
     setSelection = async (patch: Partial<CodeCreateSessionRequest>): Promise<void> => {
@@ -557,7 +658,8 @@ export class CodeController {
             }
             await this.patch(id, { model: patch.model ?? session.model,
                 effort: patch.effort === undefined ? session.effort : patch.effort,
-                permissionMode: patch.permissionMode ?? session.permissionMode });
+                permissionMode: patch.permissionMode ?? session.permissionMode,
+                ...(session.provider === 'claude' ? { thinking: patch.thinking ?? session.thinking ?? true } : {}) });
             return;
         }
         if (id) return;
@@ -605,8 +707,24 @@ export class CodeController {
     send = async (): Promise<void> => {
         let id = this.book.selectedId;
         let draft = this.draft(id);
-        if (draft.operation.kind !== 'idle' || draft.createUnknown || !draft.input.trim()) return;
-        const session = this.info(id);
+        if (draft.operation.kind !== 'idle' || draft.createUnknown || !draft.input.trim() || draft.steer?.state === 'sending') return;
+        let session = this.info(id);
+        // A running Claude turn takes the text as its follow-up; an idle session starts a new turn.
+        if (id && session && this.model.followUp) {
+            if (!this.model.followUpSent) await this.steer(id, draft, session);
+            return;
+        }
+        if (draft.steer?.state === 'unknown') draft.steer = null;
+        // t3code continues a session on the next send; a suspended (or recoverably
+        // failed) session attaches first instead of asking for a separate Resume.
+        if (id && session && codeCanResume(session) && this.model.synced) {
+            draft.operation = { kind: 'resuming', error: null }; this.notify();
+            try { this.accept(await this.client.attachSession(id)); draft.operation = { kind: 'idle', error: null }; }
+            catch (error) { draft.operation = { kind: 'idle', error: message(error) }; this.notify(); this.scheduleIndex(); return; }
+            this.notify(); this.scheduleIndex();
+            if (this.active) await this.sync(id, true);
+            session = this.info(id);
+        }
         if (id && (!session || session.status !== 'idle' || session.archivedAt !== null || !this.model.synced)) {
             draft.operation.error = 'Wait for the session to be idle and synchronized before sending.'; this.notify(); return;
         }
@@ -648,7 +766,9 @@ export class CodeController {
     private async submit(id: string, draft: CodeDraft): Promise<void> {
         const attempt = draft.retry;
         if (!attempt) return;
-        draft.operation = { kind: 'sending', error: null }; this.notify();
+        draft.operation = { kind: 'sending', error: null };
+        draft.awaitingTurn = attempt.key;
+        this.notify();
         try {
             const receipt = await this.client.sendPrompt(id, { text: attempt.text, clientTurnKey: attempt.key });
             if (receipt.clientTurnKey !== attempt.key) throw new Error('Mismatched prompt receipt');
@@ -657,14 +777,51 @@ export class CodeController {
             if (state) this.details.set(id, reduceCodeSession(state, { type: 'stale' }));
             // A duplicate receipt for a spent key is a report about a turn that is
             // already over, not an admission of this one.
-            if (spent(receipt.status)) this.requireNewKey(draft);
+            if (spent(receipt.status)) {
+                this.requireNewKey(draft, this.removedByRollback(id, receipt) ? 'rolled-back' : undefined);
+                draft.awaitingTurn = null;
+            }
             else acknowledgeCodeSend(draft, attempt.key);
         } catch (error) {
             // The committed user event may already have acknowledged a lost HTTP response.
             if (draft.retry?.key === attempt.key) {
                 draft.operation = { kind: rejected(error) ? 'idle' : 'unknown-send', error: rejected(error) ? message(error)
                     : 'Message acceptance is unknown. Refresh, or explicitly retry the original message with the same key.' };
-                if (rejected(error)) draft.retry = null;
+                if (rejected(error)) { draft.retry = null; draft.awaitingTurn = null; }
+            }
+        }
+        this.notify(); this.scheduleIndex();
+        if (this.active) await this.sync(id, true);
+    }
+    /**
+     * Post one follow-up for the captured turn. Only a matching receipt or the follow-up's own
+     * `user_message` clears the input; a refusal keeps it; an unconfirmed outcome is never resent.
+     * The send's operation is left alone, so a Stop in progress keeps its state.
+     */
+    private async steer(id: string, draft: CodeDraft, session: CodeSessionInfo): Promise<void> {
+        if (!session.turnId || (draft.stopTarget && draft.stopTarget.outcome !== 'retryable')) return;
+        const attempt: NonNullable<CodeDraft['steer']> = { key: crypto.randomUUID(), text: draft.input, edit: draft.edit,
+            turnId: session.turnId, epoch: session.epoch, state: 'sending' };
+        draft.steer = attempt;
+        if (draft.operation.error) draft.operation = { ...draft.operation, error: null };
+        this.notify();
+        try {
+            const receipt = await this.client.steerSession(id, { text: attempt.text, clientTurnKey: attempt.key,
+                turnId: attempt.turnId, epoch: attempt.epoch });
+            if (receipt.clientTurnKey !== attempt.key) throw new Error('Mismatched follow-up receipt');
+            draft.requiredSequence = Math.max(draft.requiredSequence, receipt.sequence);
+            const state = this.details.get(id);
+            if (state) this.details.set(id, reduceCodeSession(state, { type: 'stale' }));
+            acknowledgeCodeSteer(draft, attempt.key);
+        } catch (error) {
+            if (draft.steer === attempt) {
+                if (!rejected(error)) {
+                    attempt.state = 'unknown';
+                    attempt.unrecorded = error instanceof CodeClientError && error.code === 'steer_outcome_unknown';
+                } else {
+                    draft.steer = null;
+                    if (draft.operation.kind === 'idle') draft.operation = { kind: 'idle', error: message(error) };
+                }
             }
         }
         this.notify(); this.scheduleIndex();
@@ -729,6 +886,21 @@ export class CodeController {
         this.notify(); this.scheduleIndex();
         if (this.active) await this.sync(id, true);
     };
+    rollbackSession = async (itemId: string): Promise<void> => {
+        const id = this.book.selectedId, session = this.info(id), draft = this.draft(id);
+        // A follow-up still in flight settles first: its answer may name the turn this would remove.
+        if (!id || !session || !codeCanRollback(session, this.model.synced, draft.operation.kind === 'idle' && draft.steer?.state !== 'sending')) return;
+        draft.operation = { kind: 'rolling-back', error: null }; this.notify();
+        try {
+            this.accept(await this.client.rollbackSession(id, { expectedRevision: session.revision, expectedEpoch: session.epoch, upToItemId: itemId }));
+            draft.operation = { kind: 'idle', error: null };
+        } catch (error) {
+            if (error instanceof CodeClientError && error.session?.sessionId === id) { this.observe(error.session); this.accept(error.session); }
+            draft.operation = { kind: 'idle', error: error instanceof CodeClientError && error.code === 'revision_conflict' ? ROLLBACK_CONFLICT : message(error) };
+        }
+        this.notify(); this.scheduleIndex();
+        if (this.active) await this.sync(id, true);
+    };
     answer = async (permission: CodePermissionRequest, optionId: string): Promise<void> => {
         const id = permission.sessionId;
         const state = this.details.get(id), session = this.info(id), draft = this.draft(id);

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

@@ -2,10 +2,11 @@ import type {
     CodeCreateSessionRequest, CodeItem, CodeModelCatalog, CodePermissionRequest, CodeSessionInfo,
 } from '../../../../src/code-mode/wire';
 import type { CodeGitInfo } from './code-session-client';
+import type { CodeResendReason } from './code-types';
 
 export type CodeTransportState = 'connected' | 'reconnecting' | 'disconnected';
 export type CodeSessionFilter = { scope: 'all' | 'cwd'; archived: boolean };
-export type CodeOperationKind = 'idle' | 'creating' | 'sending' | 'stopping' | 'resuming' | 'patching' | 'unknown-send';
+export type CodeOperationKind = 'idle' | 'creating' | 'sending' | 'stopping' | 'resuming' | 'patching' | 'rolling-back' | 'unknown-send';
 export interface CodeControllerOptions { port: number; workingDir: string }
 
 export interface CodeControllerModel {
@@ -16,11 +17,24 @@ export interface CodeControllerModel {
     items: CodeItem[];
     permissions: CodePermissionRequest[];
     input: string;
+    /** The fresh (un-sent) draft holds content or an unreconciled attempt. */
+    hasUnsentDraft: boolean;
     selection: CodeCreateSessionRequest;
     gitInfo: CodeGitInfo | null;
     loading: boolean;
     pending: boolean;
     busy: boolean;
+    /** The selected session is working: a send awaiting its turn, or a busy runtime. */
+    working: boolean;
+    /** Rows that are working, by session id. */
+    workingIds: ReadonlySet<string>;
+    /** The selected, synchronized Claude session is streaming a turn that takes a follow-up. */
+    followUp: boolean;
+    /** That turn's one follow-up is already in the transcript, so Send follow-up stays closed. */
+    followUpSent: boolean;
+    /** A follow-up for the selected session is in flight. */
+    steering: boolean;
+    workspacePicking: boolean;
     synced: boolean;
     error: string | null;
     transport: CodeTransportState;
@@ -29,6 +43,8 @@ export interface CodeControllerModel {
     canRetrySameSend: boolean;
     /** The previous key is spent: Retry sends a new message rather than reusing it. */
     resendRequired?: boolean;
+    /** Why the key was spent, when a rollback removed its turn rather than the server settling it. */
+    resendReason?: CodeResendReason | null;
     permissionOperations: Record<string, { pending: boolean; error: string | null }>;
     hasMoreSessions: boolean;
     hasOlderHistory: boolean;
@@ -44,6 +60,8 @@ export interface CodeControllerModel {
     retrySameSend(): Promise<void>;
     stop(): Promise<void>;
     resume(): Promise<void>;
+    /** Claude only: remove the turns after this `${turnId}:user` row. Files are not reverted and nothing is sent. */
+    rollbackSession(itemId: string): Promise<void>;
     rename(id: string, title: string): Promise<void>;
     archive(id: string, archived: boolean): Promise<void>;
     answer(permission: CodePermissionRequest, optionId: string): Promise<void>;

package/public/manager/src/code/code-recent-workspaces.ts

@@ -0,0 +1,25 @@
+import type { CodeSessionInfo } from '../../../../src/code-mode/wire';
+
+/**
+ * Which workspaces the draft empty state offers, kept apart from rendering so
+ * the rule can be tested on its own.
+ *
+ * "Recent" is last use, not creation: a session created months ago and used
+ * this morning is a more useful suggestion than one created yesterday and
+ * abandoned. Uniqueness is on the directory — the workspace, not the session —
+ * so the list never offers the same folder twice.
+ */
+export function recentCodeWorkspaces(sessions: readonly CodeSessionInfo[], max = 5): string[] {
+    const seen = new Set<string>();
+    const out: string[] = [];
+    const ordered = [...sessions].sort((left, right) => right.lastUsedAt - left.lastUsedAt
+        || right.createdAt - left.createdAt || left.sessionId.localeCompare(right.sessionId));
+    for (const session of ordered) {
+        const cwd = session.cwd;
+        if (!cwd.trim() || seen.has(cwd)) continue;
+        seen.add(cwd);
+        out.push(cwd);
+        if (out.length >= max) break;
+    }
+    return out;
+}

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

@@ -1,7 +1,7 @@
 import type {
     CodeCancelRequest, CodeCreateSessionRequest, CodeEventsPage, CodeHistoryPage, CodeModelCatalog,
     CodePatchSessionRequest, CodePermissionAnswer, CodePromptReceipt, CodePromptRequest,
-    CodeSessionInfo, CodeSessionPage, CodeSnapshot,
+    CodeRollbackRequest, CodeSessionInfo, CodeSessionPage, CodeSnapshot, CodeSteerRequest,
 } from '../../../../src/code-mode/wire';
 
 export interface CodeGitInfo {
@@ -40,8 +40,12 @@ export interface CodeSessionClient {
     createSession(input: CodeCreateSessionRequest): Promise<CodeSessionInfo>;
     patchSession(id: string, input: CodePatchSessionRequest): Promise<CodeSessionInfo>;
     sendPrompt(id: string, input: CodePromptRequest): Promise<CodePromptReceipt>;
+    /** A Claude follow-up for the captured running turn; never retried. */
+    steerSession(id: string, input: CodeSteerRequest): Promise<CodePromptReceipt>;
     cancelPrompt(id: string, input: CodeCancelRequest): Promise<CodeSessionInfo>;
     attachSession(id: string): Promise<CodeSessionInfo>;
+    rollbackSession(id: string, input: CodeRollbackRequest): Promise<CodeSessionInfo>;
+    visitSession(id: string): Promise<CodeSessionInfo>;
     answerPermission(id: string, input: CodePermissionAnswer): Promise<void>;
     getGitInfo(cwd: string, signal?: AbortSignal): Promise<CodeGitInfo>;
     pickWorkspace(): Promise<{ ok: boolean; path?: string; cancelled?: boolean }>;
@@ -61,7 +65,18 @@ const ERROR_COPY: Record<string, string> = {
     unsupported_effort: 'This effort is not supported by the selected runtime.',
     unsupported_policy: 'This permission mode is not supported by the selected runtime.',
     unsupported_capability: 'This runtime does not support this action.',
+    session_not_steerable: 'This turn cannot take a follow-up right now. Your text is kept.',
+    steer_queue_full: 'This turn already has its follow-up. Send this after the turn finishes.',
+    steer_in_flight: 'This follow-up is still being delivered.',
+    steer_key_spent: 'This follow-up was not delivered. Your text is kept; send it again when ready.',
+    steer_outcome_unknown: 'Follow-up delivery not confirmed. It was not resent.',
+    steer_command_unsupported: 'A slash command cannot be sent as a follow-up. Send it after this turn finishes.',
     session_not_found: 'This session is no longer available. Its local draft is retained.',
+    rollback_unavailable: 'Rollback is unavailable after this conversation was compacted, or while its history cannot be read.',
+    rollback_boundary_unavailable: "This turn can't be a rollback point: it or a later turn never reached Claude, or the conversation was compacted.",
+    rollback_noop: 'This is already the latest turn, so there is nothing to roll back.',
+    rollback_target_not_found: 'This message is no longer in the conversation. Refreshing the session.',
+    cleanup_pending: 'The previous runtime is still closing. Try again in a moment.',
     unauthorized: 'Authentication is required to access this instance.',
 };
 
@@ -106,8 +121,11 @@ export function createCodeSessionClient(port: number): CodeSessionClient {
         createSession: input => sessionRequest('POST', '/sessions', input),
         patchSession: (id, input) => sessionRequest('PATCH', sessionPath(id), input),
         sendPrompt: (id, input) => request('POST', `${sessionPath(id)}/prompt`, input),
+        steerSession: (id, input) => request('POST', `${sessionPath(id)}/steer`, input),
         cancelPrompt: (id, input) => sessionRequest('POST', `${sessionPath(id)}/cancel`, input),
         attachSession: id => sessionRequest('POST', `${sessionPath(id)}/attach`, {}),
+        rollbackSession: (id, input) => sessionRequest('POST', `${sessionPath(id)}/rollback`, input),
+        visitSession: id => sessionRequest('POST', `${sessionPath(id)}/visit`, {}),
         async answerPermission(id, input) { await request('POST', `/permissions/${encodeURIComponent(id)}`, input); },
         getGitInfo: (cwd, signal) => request('GET', `/git-info?cwd=${encodeURIComponent(cwd)}`, undefined, signal),
         pickWorkspace: () => request('POST', '/workspace/pick'),

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

@@ -0,0 +1,38 @@
+/* Code sidebar: Projects/Activity header, bell toggle, unread markers. */
+.code-session-list-header { display: flex; align-items: center; justify-content: space-between; gap: 6px; }
+.code-session-header-actions { display: inline-flex; align-items: center; gap: 2px; }
+.code-session-header-btn {
+    position: relative; display: inline-flex; align-items: center; justify-content: center;
+    width: 24px; height: 24px; min-height: 24px; padding: 0; border: none; border-radius: 6px;
+    background: transparent; color: var(--text-dim); cursor: pointer;
+}
+.code-session-header-btn:hover { background: var(--bg-raised); color: var(--text-primary); }
+.code-session-header-btn.active { color: var(--accent); background: var(--accent-soft); }
+.code-session-header-btn:focus-visible { outline: 2px solid var(--ring); outline-offset: 1px; }
+.code-session-search-row { display: flex; align-items: center; gap: 6px; margin: 0 8px 6px; }
+.code-session-search-row .code-session-search { flex: 1 1 auto; width: auto; min-width: 0; margin: 0; }
+.code-session-archived-btn {
+    flex: none; padding: 3px 8px; min-height: 24px; border: 1px solid var(--border-subtle); border-radius: 4px;
+    background: transparent; color: var(--text-dim); font-size: 11px; cursor: pointer;
+}
+.code-session-archived-btn.active { color: var(--accent); border-color: var(--accent); background: var(--accent-soft); }
+.code-session-archived-btn:focus-visible { outline: 2px solid var(--ring); outline-offset: 1px; }
+.code-session-bell .code-session-unread-dot { position: absolute; top: 3px; right: 3px; margin: 0; }
+.code-session-unread-dot {
+    display: inline-block; flex: none; width: 7px; height: 7px; margin-right: 6px;
+    border-radius: 50%; background: var(--accent); vertical-align: 1px;
+}
+
+/* Working indicator: sidebar rows and the transcript tail, from Send until the turn ends. */
+.code-session-spinner {
+    display: inline-block; flex: none; width: 9px; height: 9px; margin-right: 4px; vertical-align: -1px;
+    border: 1.5px solid currentColor; border-right-color: transparent; border-radius: 50%;
+}
+@media (prefers-reduced-motion: no-preference) {
+    .code-session-spinner { animation: code-session-spin 0.8s linear infinite; }
+}
+@keyframes code-session-spin { to { transform: rotate(360deg); } }
+.code-transcript-working {
+    display: flex; align-items: center; gap: 6px; padding: 8px 12px 12px;
+    color: var(--text-dim); font-size: 12px;
+}

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

@@ -61,6 +61,8 @@ function apply(state: CodeSessionState, event: CodeWireEvent): CodeSessionState
     let { items, session, permissions } = state;
     if (event.event === 'code_session') {
         if (!event.session || event.session.sessionId !== state.sessionId) return { ...state, needsSnapshot: true, synced: false };
+        // A rollback removed items this state still holds; only a new snapshot drops them.
+        if ((event.session.historyGeneration ?? 0) > (state.session?.historyGeneration ?? 0)) return { ...state, needsSnapshot: true, synced: false };
         // Usage is attached at read time, so a stored session event does not
         // carry it. Replacing the record wholesale would blank the meter on
         // every unrelated session change; the last figure stands until a

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

@@ -5,11 +5,16 @@ export const CODE_RUNTIME_LABELS: Record<CodeProviderId, string> = {
 };
 export const CODE_POLICY_LABELS: Record<CodePermissionMode, string> = {
     ask: 'Ask first', auto: 'Auto (YOLO)', 'read-only': 'Read only',
+    plan: 'Plan', 'accept-edits': 'Accept edits', 'dont-ask': "Don't ask", 'auto-review': 'Auto review',
 };
 export const CODE_POLICY_DETAILS: Record<CodePermissionMode, string> = {
     ask: 'Review native permission requests before allowing actions.',
     auto: 'The native runtime may execute actions without asking for approval.',
     'read-only': 'The native runtime restricts actions to read-only access.',
+    plan: 'Claude plans without applying edits.',
+    'accept-edits': 'File edits proceed; other actions still ask.',
+    'dont-ask': 'Actions not already allowed for this session are denied without asking.',
+    'auto-review': 'A classifier approves or denies each action; unsure calls still ask.',
 };
 export const CODE_SESSION_LABELS: Record<CodeSessionStatus, string> = {
     idle: 'Ready', starting: 'Starting', streaming: 'Running', stopping: 'Stopping', suspended: 'Suspended', failed: 'Runtime failed',
@@ -17,10 +22,52 @@ export const CODE_SESSION_LABELS: Record<CodeSessionStatus, string> = {
 export function codeSessionBusy(session: CodeSessionInfo): boolean {
     return session.status === 'starting' || session.status === 'streaming' || session.status === 'stopping';
 }
+/** Why a send's key was retired: the server spent it without running, or a rollback removed its turn. */
+export type CodeResendReason = 'rolled-back';
+/** What the composer says about a retired send: `error` in the alert, `heading`/`detail` in its recovery strip. */
+export function codeResendCopy(reason: CodeResendReason | undefined): { heading: string; detail: string; error: string } {
+    return reason === 'rolled-back' ? {
+        heading: 'Turn rolled back',
+        detail: "This message's turn was removed by a rollback. Files it changed were not reverted. Retry sends it as a new message.",
+        error: "This message's turn was removed by a rollback. The message was not resent; Retry will submit it as a new message.",
+    } : {
+        heading: 'Send did not start',
+        detail: 'The original attempt ended on the server without running. Retry sends this as a new message.',
+        error: 'The original attempt ended on the server without running. The message was not resent; Retry will submit it as a new message.',
+    };
+}
 export function codeCanResume(session: CodeSessionInfo): boolean {
     return session.archivedAt === null && session.capabilities.resume && session.resume.available
         && (session.status === 'suspended' || (session.status === 'failed' && session.error?.recoverable === true));
 }
+/**
+ * Whether the open session may roll its conversation back right now. An older server
+ * without the `rollback` field reads as unavailable.
+ */
+export function codeCanRollback(session: CodeSessionInfo | null, synced: boolean, idleOperation: boolean): boolean {
+    return !!session && session.rollback?.available === true && session.archivedAt === null && synced && idleOperation
+        && (session.status === 'idle' || session.status === 'failed');
+}
+
+/**
+ * User rows a rollback may target: a settled turn's own `${turnId}:user` row (never the
+ * unsent row or a follow-up), at or after the first recorded boundary, with a later turn.
+ */
+export function codeRollbackRows(items: readonly CodeItem[], sinceSequence: number | null | undefined): ReadonlySet<string> {
+    const rows = new Set<string>();
+    if (sinceSequence == null) return rows;
+    const settled = new Set(items.filter(item => item.kind === 'turn_completed' || item.kind === 'turn_failed'
+        || item.kind === 'turn_cancelled').map(item => item.turnId));
+    const turns = items.filter(item => item.kind === 'user_message' && item.turnId !== null
+        && item.itemId === `${item.turnId}:user` && item.firstSequence !== undefined);
+    // One row per turn, so a later turn exists exactly when the row is not the newest one.
+    const newest = Math.max(...turns.map(row => row.firstSequence!));
+    for (const row of turns) {
+        if (row.firstSequence! >= sinceSequence && row.firstSequence! < newest && settled.has(row.turnId)) rows.add(row.itemId);
+    }
+    return rows;
+}
+
 export function codeItemStatus(item: CodeItem): string {
     if (item.kind === 'turn_cancelled' || item.status === 'cancelled') return 'Stopped';
     if (item.kind === 'turn_failed' || item.status === 'error') return 'Failed';