@maudecode/talaria-web 1.20.0 → 1.22.0

package/dist/sessions/gateway-sessions.d.ts

@@ -1,5 +1,6 @@
-import { type ContextDetail } from '@maudecode/talaria-web-contracts';
+import { type CheckpointDiff, type SessionActivityPhase, type ContextDetail } from '@maudecode/talaria-web-contracts';
 /** One native-owner seam. Talaria observes its history and never settles it into a local Session. */
+import type { QueueAdmissionFence } from './admission.js';
 import type { StartupTiming } from '../startup-timing.js';
 import { type ExecutionModes, type GatewayCreateParams, type GatewaySessionParams, type GatewaySessionResult } from '@maudecode/talaria-web-contracts';
 import type { SidecarLike } from '../sidecar/client.js';
@@ -8,6 +9,12 @@ import type { SessionChannels, StreamRegistry } from './streams.js';
 import type { RunJournal } from './journal.js';
 import { SessionEventBus } from './events.js';
 type Row = Record<string, unknown>;
+interface Target {
+    sid: string;
+    profile: string;
+    home: string;
+    key: string;
+}
 /** The scope remains verifiable after a server restart, before a journal lookup or stream subscription. */
 export declare const gatewayStreamVisible: (stream: string, home: string) => boolean;
 export declare class GatewaySessions {
@@ -22,6 +29,7 @@ export declare class GatewaySessions {
     private rememberModelChange;
     private currentModelChange;
     constructor(deps: {
+        onWebCompletion?: (profile: string, sessionId: string, identity: string) => void;
         service: SessionService;
         sidecar: () => SidecarLike | null;
         registry: StreamRegistry;
@@ -39,6 +47,7 @@ export declare class GatewaySessions {
     private noticeState;
     private nativeNotices;
     private changed;
+    private nativeTodo;
     /** One shared connection, acquired by viewers and run projections, with no local Agent admission. */
     private transport;
     private lease;
@@ -49,7 +58,56 @@ export declare class GatewaySessions {
     } | null>;
     private target;
     contextDetail(sid: string, expectedKey: string): Promise<ContextDetail>;
+    private activityPhaseFor;
+    activityPhase(sid: string, profile: string): Promise<SessionActivityPhase | null | undefined>;
     isOwned(sid: string): Promise<boolean>;
+    /** Exact native receipt lookup for a durable queue step, never another submit. */
+    queueReceipt(sid: string, admissionId?: string): Promise<GatewaySessionResult | null>;
+    checkpointDiff(sid: string): Promise<CheckpointDiff | null>;
+    private terminalKey;
+    terminal(sid: string): Promise<{
+        target: Target;
+        snap: {
+            session_id: string;
+            stored_session_id: string;
+            messages: Record<string, unknown>[];
+            message_count: number;
+            running: boolean;
+            authority_epoch: number;
+            replay_epoch: string;
+            last_sequence: number;
+            subscription_id: string;
+            revision: number;
+            execution_generation: number;
+            pending: {
+                admission_id: string;
+                sequence: number;
+                status: "unknown" | "terminal" | "queued" | "started";
+                outcome: string | null;
+                authority_epoch: number;
+                execution_generation: number | null;
+                controls?: string[] | undefined;
+                steering?: boolean | undefined;
+                text?: string | undefined;
+                input_id?: string | undefined;
+            }[];
+            prompts: Record<string, unknown>[];
+            info: Record<string, unknown>;
+            plan_gauge?: {
+                id: string;
+                label: string;
+                used_bp: number;
+                resets_at_ms: number | null;
+            } | null | undefined;
+            reactions_supported?: boolean | undefined;
+            todo_state?: {
+                todos: Record<string, unknown>[];
+                revision?: number | undefined;
+            } | null | undefined;
+        };
+        key: string;
+    } | null>;
+    capturedCommand(sid: string, key: string, command: string): Promise<NonNullable<GatewaySessionResult['shell']>>;
     export(sid: string, format: NonNullable<GatewaySessionParams['format']>): Promise<NonNullable<GatewaySessionResult['export']> | null>;
     private createCall;
     /** TAL-1040: normal always runs; the bypass modes need an owner that freezes them before any Agent import. */
@@ -62,10 +120,11 @@ export declare class GatewaySessions {
     private call;
     private attachment;
     private contextDetailKey;
+    private reactionView;
     private view;
     project(base: Row, limit?: number | null, before?: number | null, withMessages?: boolean): Promise<Row>;
     /** Called before the direct-chat admission path, including for an already materialized foreign session. */
-    submit(sid: string, body: Row, timing?: StartupTiming): Promise<Row | null>;
+    submit(sid: string, body: Row, timing?: StartupTiming, fence?: QueueAdmissionFence): Promise<Row | null>;
     action(sid: string, params: Omit<GatewaySessionParams, 'session_id' | 'profile_home'>): Promise<GatewaySessionResult>;
     /** The display preview is redacted; an explicit retry returns the original text for review, like direct-chat retry. */
     retry(sid: string, admissionId: string, generation: number): Promise<string>;

package/dist/sessions/gateway-sessions.js

@@ -1,10 +1,13 @@
-import { unavailableContextDetail } from '@maudecode/talaria-web-contracts';
+import { applyPlanGauge } from './session.js';
+import { reasoningProjection } from './reasoning-display.js';
+import { CHECKPOINT_DIFF_MAX_BYTES, ReactionEmojiSchema, unavailableContextDetail } from '@maudecode/talaria-web-contracts';
+import { checkpointDiffFiles } from '../workspace/rollback.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { OWNER_EXPORT_MAX_BYTES, SessionNoticeSchema, GatewayClarifyBatchSchema, GatewaySessionResultSchema } from '@maudecode/talaria-web-contracts';
 import { redactNestedMessageContainers, publicToolFrame, redactString } from '../redact.js';
 import { str } from '../util.js';
 import { PendingPrompts } from './pending.js';
-import { wrapExportHtml } from './export.js';
+import { wrapExportHtml, renderSessionHtml, renderSessionMarkdown } from './export.js';
 import { clarifyReply } from './pending.js';
 import { HttpFailure } from './service.js';
 import { SessionNotices } from './notices.js';
@@ -14,6 +17,7 @@ import { pendingUserRow } from './merge.js';
 import { ReasoningTitleTracker, reasoningEventPayload } from './reasoning-titles.js';
 import { CANONICAL_READ_ONLY_REASON, WEB_DIAGNOSTIC_REQUEST_PREFIX } from './state-db.js';
 import { toolProgress } from './tool-display.js';
+import { deriveTodoState, normalizeTodoSnapshot } from './todo.js';
 const ownerStreamPrefix = (home) => `owner-${createHash('sha256').update(home).digest('hex').slice(0, 16)}-`;
 const ownerStateId = (identity) => `owner-${createHash('sha256').update(identity).digest('hex')}`;
 /** The scope remains verifiable after a server restart, before a journal lookup or stream subscription. */
@@ -36,8 +40,12 @@ function retryText(admission) {
 /** Steering belongs to the current turn; it must never replace that turn's transcript anchor. */
 const runningAdmission = (snapshot) => snapshot.pending.find((p) => p.status === 'started' && !p.steering);
 const sameExecution = (a, b) => a.authority_epoch === b.authority_epoch && a.replay_epoch === b.replay_epoch && a.execution_generation === b.execution_generation;
+/** Todo revisions belong to a single owner execution; sequence also fences explicit null clears. */
+const newerTodo = (a, b) => Object.hasOwn(a, 'todo_state') && sameExecution(a, b)
+    && (a.last_sequence > b.last_sequence || !Object.hasOwn(b, 'todo_state') || a.todo_state != null && b.todo_state != null && (a.todo_state.revision ?? 0) > (b.todo_state.revision ?? 0));
 /** Native counters and the owner's compact turn-end usage share one existing Web usage shape. */
-function ownerUsage(data) {
+function ownerUsage(payload, complete = false) {
+    const data = payload.usage && typeof payload.usage === 'object' ? { ...payload, ...payload.usage } : payload;
     const fields = {
         input_tokens: ['prompt_tokens', 'prompt', 'input_tokens', 'input'], output_tokens: ['completion_tokens', 'completion', 'output_tokens', 'output'],
         cache_read_tokens: ['cache_read_tokens'], cache_write_tokens: ['cache_write_tokens'],
@@ -45,6 +53,7 @@ function ownerUsage(data) {
         context_length: ['context_length', 'context_max'], cache_hit_percent: ['cache_hit_pct'], tps: ['tokens_per_s', 'avg_tps'],
     };
     const usage = {};
+    applyPlanGauge(usage, data, complete || typeof data.calls === 'number' || typeof data.api_calls === 'number');
     for (const [field, keys] of Object.entries(fields)) {
         const value = keys.map((key) => data[key]).find((value) => typeof value === 'number' && Number.isFinite(value) && value >= 0);
         if (value !== undefined)
@@ -121,20 +130,27 @@ export class GatewaySessions {
     changed(target) {
         this.deps.channels.emit(target.sid, 'session-updated', { session_id: target.sid, source: 'native_owner' }, target.profile);
     }
+    nativeTodo(target, snapshot) {
+        const observed = this.observations.get(target.key)?.snapshot;
+        const current = observed && (newerTodo(observed, snapshot) || observed.authority_epoch > snapshot.authority_epoch
+            || observed.authority_epoch === snapshot.authority_epoch && observed.replay_epoch === snapshot.replay_epoch && observed.execution_generation > snapshot.execution_generation) ? observed : snapshot;
+        return Object.hasOwn(current, 'todo_state')
+            ? normalizeTodoSnapshot(current.todo_state ?? { todos: [] }) : deriveTodoState(current.messages);
+    }
     /** One shared connection, acquired by viewers and run projections, with no local Agent admission. */
     transport(target, base, snapshot) {
         const prior = this.observations.get(target.key);
         if (prior && !prior.controller.signal.aborted)
             return prior;
-        const observation = { controller: new AbortController(), snapshot, replaying: true, completion: null, listeners: new Set(), leases: 0, ended: Promise.resolve({ state: 'unavailable', reason: 'owner_connection_lost', snapshot: null, receipt: null }) };
+        const observation = { controller: new AbortController(), snapshot, todoSequence: 0, replaying: true, completion: null, listeners: new Set(), leases: 0, ended: Promise.resolve({ state: 'unavailable', reason: 'owner_connection_lost', snapshot: null, receipt: null }) };
         this.observations.set(target.key, observation);
         this.noticeState(target, snapshot);
         observation.ended = (async () => {
-            const showReasoning = await this.deps.showReasoning(target.home).catch(() => false);
             const sidecar = this.deps.sidecar();
             if (!sidecar || observation.controller.signal.aborted)
                 return { state: 'unavailable', reason: 'sidecar_unavailable', snapshot: null, receipt: null };
-            return sidecar.call('gateway.session', { profile_home: target.home, session_id: target.sid, action: 'watch', show_reasoning: showReasoning }, {
+            // Keep reasoning available when Show changes during this observation; delivery applies the current preference.
+            return sidecar.call('gateway.session', { profile_home: target.home, session_id: target.sid, action: 'watch', show_reasoning: true }, {
                 signal: observation.controller.signal, timeoutMs: 0,
                 onStream: (frame) => {
                     if (observation.controller.signal.aborted || this.observations.get(target.key) !== observation)
@@ -143,10 +159,18 @@ export class GatewaySessions {
                         const result = GatewaySessionResultSchema.parse(frame.data);
                         if (result.snapshot?.session_id !== target.sid)
                             return;
+                        // Reaction readback invalidates display data only. Queued native turn events still own settlement.
+                        if (frame.data.reaction_only === true) {
+                            this.changed(target);
+                            return;
+                        }
                         const completed = observation.completion?.data;
                         if (result.replay_gap || completed && (completed.authority_epoch !== result.snapshot.authority_epoch || completed.replay_epoch !== result.snapshot.replay_epoch))
                             observation.completion = null;
-                        observation.snapshot = result.snapshot;
+                        const prior = observation.snapshot;
+                        if (!sameExecution(prior, result.snapshot))
+                            observation.todoSequence = 0;
+                        observation.snapshot = newerTodo(prior, result.snapshot) ? { ...result.snapshot, todo_state: prior.todo_state, last_sequence: prior.last_sequence } : result.snapshot;
                         observation.replaying = frame.data.replaying === true;
                         this.noticeState(target, result.snapshot, result.replay_gap === true);
                         if ((result.snapshot.running || result.snapshot.pending.some((p) => p.status === 'queued' || p.status === 'started')) && !this.watches.has(target.key))
@@ -159,7 +183,23 @@ export class GatewaySessions {
                     else if (frame.event === 'event') {
                         const event = frame.data;
                         const data = (event.payload ?? {});
-                        if (event.type === 'notification.show' || event.type === 'notification.clear') {
+                        if (event.type === 'todo.updated') {
+                            const snap = observation.snapshot;
+                            if (event.session_id !== target.sid || event.replay_epoch !== snap.replay_epoch
+                                || event.authority_epoch !== snap.authority_epoch || event.execution_generation !== snap.execution_generation
+                                || !Number.isSafeInteger(event.seq) || Number(event.seq) <= observation.todoSequence
+                                || !Array.isArray(data.todos) || !Number.isSafeInteger(data.revision) || Number(data.revision) < 0
+                                || snap.todo_state != null && Number(data.revision) <= (snap.todo_state.revision ?? -1))
+                                return;
+                            // A retained event may be newer than the transcript-derived plan in an attach snapshot.
+                            // Explicit null still fences all events at or before that snapshot's sequence.
+                            if (Number(event.seq) <= snap.last_sequence && snap.todo_state === null)
+                                return;
+                            observation.todoSequence = Number(event.seq);
+                            observation.snapshot = { ...snap, todo_state: { todos: data.todos, revision: Number(data.revision) }, last_sequence: Math.max(snap.last_sequence, Number(event.seq)) };
+                            this.changed(target);
+                        }
+                        else if (event.type === 'notification.show' || event.type === 'notification.clear') {
                             const snap = observation.snapshot;
                             const state = this.noticeState(target, snap);
                             if (event.session_id !== target.sid || event.replay_epoch !== snap.replay_epoch
@@ -180,7 +220,12 @@ export class GatewaySessions {
                         else if (event.type === 'session.info') {
                             if (data.authority_epoch !== observation.snapshot.authority_epoch || Number(data.execution_generation) < observation.snapshot.execution_generation)
                                 return;
-                            observation.snapshot = { ...observation.snapshot, ...data };
+                            const nextGeneration = Number(data.execution_generation) > observation.snapshot.execution_generation;
+                            if (nextGeneration)
+                                observation.todoSequence = 0;
+                            observation.snapshot = { ...observation.snapshot, ...data,
+                                ...(nextGeneration && observation.snapshot.todo_state ? { todo_state: { ...observation.snapshot.todo_state, revision: 0 } } : {}),
+                            };
                             if ((observation.snapshot.running || observation.snapshot.pending.some((p) => p.status === 'queued' || p.status === 'started')) && !this.watches.has(target.key))
                                 this.watch(target, base, observation.snapshot);
                             this.changed(target);
@@ -228,14 +273,20 @@ export class GatewaySessions {
         signal.addEventListener('abort', release, { once: true });
         return { release: () => { signal.removeEventListener('abort', release); release(); }, ended: observation.ended };
     }
-    async target(sid, profile = this.deps.activeProfile()) {
+    async target(sid, profile = this.deps.activeProfile(), requireKnownOwnership = false) {
         if (sid.length === 0 || sid !== sid.trim())
             return null;
-        const owner = (await this.deps.service.stateDbSources([sid], profile))?.get(sid);
+        const sources = await this.deps.service.stateDbSources([sid], profile);
+        if (requireKnownOwnership && !sources)
+            throw new HttpFailure(503, 'Agent session ownership could not be verified');
+        const owner = sources?.get(sid);
         if (typeof owner !== 'object')
             return null;
-        if (owner.reason)
+        if (owner.reason) {
+            if (requireKnownOwnership)
+                throw new HttpFailure(403, owner.reason);
             return null;
+        }
         const home = this.deps.profileHome(profile);
         return { sid, profile, home, key: JSON.stringify([home, sid]) };
     }
@@ -247,17 +298,87 @@ export class GatewaySessions {
         const result = await this.call(target, { action: 'context_detail' });
         return profile === this.deps.activeProfile() && result.state === 'attached' && this.contextDetailKey(target, result.snapshot) === expectedKey ? result.context_detail ?? unavailableContextDetail('unsupported') : unavailableContextDetail('changed');
     }
+    activityPhaseFor(result, target) {
+        if (result.state !== 'attached' || !result.snapshot)
+            return 'stale';
+        const pending = this.prompts(result.snapshot, target.sid, this.batch(target));
+        if (pending.approvalPending(target.sid).pending)
+            return 'waiting_for_approval';
+        if (pending.clarifyPending(target.sid).pending)
+            return 'waiting_for_input';
+        if (result.snapshot.running || result.snapshot.pending.some((entry) => entry.status === 'queued' || entry.status === 'started'))
+            return 'running';
+        return result.snapshot.pending.some((entry) => entry.status === 'unknown') ? 'stale' : null;
+    }
+    async activityPhase(sid, profile) {
+        const target = await this.target(sid, profile);
+        return target ? this.activityPhaseFor(await this.call(target, { action: 'snapshot' }), target) : undefined;
+    }
     async isOwned(sid) { return (await this.target(sid)) !== null; }
+    /** Exact native receipt lookup for a durable queue step, never another submit. */
+    async queueReceipt(sid, admissionId) {
+        const target = await this.target(sid);
+        return target ? this.call(target, admissionId ? { action: 'receipt', admission_id: admissionId } : { action: 'snapshot' }) : null;
+    }
+    async checkpointDiff(sid) {
+        const profile = this.deps.activeProfile();
+        const target = await this.target(sid, profile);
+        if (!target)
+            return null;
+        const result = await this.call(target, { action: 'checkpoint_diff' });
+        const read = profile === this.deps.activeProfile() && result.state === 'attached' ? result.checkpoint_diff : undefined;
+        const comparison = read ? { ...read.comparison } : { provenance: 'native_owner', baseline: 'earliest_retained_project_checkpoint', available: false, reason: 'owner_unavailable', truncated: false };
+        if (read && (Buffer.byteLength(JSON.stringify(read.diff), 'utf8') + Buffer.byteLength(JSON.stringify(read.stat), 'utf8') - 4 > CHECKPOINT_DIFF_MAX_BYTES)) {
+            comparison.available = false;
+            comparison.reason = 'payload_too_large';
+        }
+        const diff = comparison.available ? read?.diff ?? '' : '';
+        const files = checkpointDiffFiles(diff);
+        return { checkpoint: 'earliest-retained', workspace: '', diff: diff.trimEnd(), files_changed: files, total_changes: files.length, comparison };
+    }
+    terminalKey(target, snap) {
+        return ownerStateId(JSON.stringify([target.key, snap.session_id, snap.authority_epoch, snap.replay_epoch, snap.info.cwd]));
+    }
+    async terminal(sid) {
+        const target = await this.target(sid, this.deps.activeProfile(), true);
+        if (!target)
+            return null;
+        const result = await this.call(target, { action: 'terminal_info' });
+        const snap = result.snapshot;
+        if (target.profile !== this.deps.activeProfile() || result.state !== 'attached' || snap?.session_id !== sid)
+            throw new HttpFailure(409, 'The native owner cannot run captured commands. Reopen the terminal after checking the gateway.', { code: 'owner_shell_unavailable' });
+        return { target, snap, key: this.terminalKey(target, snap) };
+    }
+    async capturedCommand(sid, key, command) {
+        const selected = await this.terminal(sid);
+        if (key !== selected?.key)
+            throw new HttpFailure(409, 'The native owner changed. Reopen the terminal before running a command.');
+        const { target, snap } = selected;
+        const result = await this.call(target, { action: 'shell_exec', command, authority_epoch: snap.authority_epoch, replay_epoch: snap.replay_epoch });
+        if (result.state !== 'attached' || !result.shell) {
+            // Only allowlisted native policy refusals are safe to show. A transport failure may have executed.
+            const messages = {
+                unsupported_terminal_backend: 'Captured commands require the native owner’s local terminal backend.',
+                cwd_unavailable: 'The native workspace no longer exists.', dangerous_command: 'The native owner refused this command.',
+                permission_denied: 'The native owner denied this command.', command_timeout: 'The command timed out on the native owner.',
+                owner_changed: 'The native owner changed. Reopen the terminal.',
+            };
+            throw new HttpFailure(409, messages[result.reason ?? ''] ?? 'The command outcome is unknown. Check the native workspace before running it again.', { code: 'owner_shell_failed' });
+        }
+        return { stdout: redactString(result.shell.stdout, true), stderr: redactString(result.shell.stderr, true), code: result.shell.code };
+    }
     async export(sid, format) {
         const target = await this.target(sid);
         if (!target)
             return null;
         const redact = this.deps.redactEnabled();
-        const result = await this.call(target, { action: 'export', format, redact });
+        const show = await this.deps.showReasoning(target.home).catch(() => false);
+        const requestedFormat = show ? format : 'json';
+        const result = await this.call(target, { action: 'export', format: requestedFormat, redact });
         const value = result.export;
         if (result.reason === 'export_too_large')
             throw new HttpFailure(413, 'The owner transcript exceeds the export limit');
-        if (result.state !== 'attached' || value?.format !== format) {
+        if (result.state !== 'attached' || value?.format !== requestedFormat) {
             throw new HttpFailure(409, 'The Agent owner cannot export this chat. Check that its gateway is running and supports transcript export.', { code: 'owner_export_unavailable' });
         }
         if (Buffer.byteLength(value.content, 'utf8') > OWNER_EXPORT_MAX_BYTES)
@@ -265,16 +386,21 @@ export class GatewaySessions {
         let content;
         try {
             // The owner redacts HTML's structured transcript before rendering. A shell/text redactor corrupts its markup.
-            content = format === 'html' ? wrapExportHtml(value.content) : format === 'json'
-                ? JSON.stringify(redactNestedMessageContainers(JSON.parse(value.content), redact), null, 2)
-                : redactString(value.content, redact);
+            if (!show) {
+                const document = reasoningProjection(redactNestedMessageContainers(JSON.parse(value.content), redact), false);
+                content = format === 'html' ? renderSessionHtml(document) : format === 'markdown' ? renderSessionMarkdown(document) : JSON.stringify(document, null, 2);
+            }
+            else
+                content = format === 'html' ? wrapExportHtml(value.content) : format === 'json'
+                    ? JSON.stringify(redactNestedMessageContainers(JSON.parse(value.content), redact), null, 2)
+                    : redactString(value.content, redact);
         }
         catch {
             throw new HttpFailure(409, 'The Agent owner returned an invalid transcript export', { code: 'owner_export_invalid' });
         }
         if (Buffer.byteLength(content, 'utf8') > OWNER_EXPORT_MAX_BYTES)
             throw new HttpFailure(413, 'The owner transcript exceeds the export limit');
-        return { ...value, content };
+        return { ...value, format, content };
     }
     async createCall(params) {
         const sidecar = this.deps.sidecar();
@@ -292,7 +418,7 @@ export class GatewaySessions {
         const result = await this.createCall({ profile_home: this.deps.profileHome(profile), probe: true });
         const reason = result.state === 'attached' ? null : unavailableReason(result);
         // Owner chats take no file attachments (`submit` refuses them), so a fresh chat in either bypass mode cannot attach.
-        return { modes: [{ mode: 'normal', available: true, reason: null, can_attach: true }, ...['ignore_config', 'safe'].map((mode) => ({ mode, available: reason === null, reason, can_attach: false }))] };
+        return { modes: [{ mode: 'normal', available: true, reason: null, can_attach: true, can_reference: true }, ...['ignore_config', 'safe'].map((mode) => ({ mode, available: reason === null, reason, can_attach: false, can_reference: false }))] };
     }
     /**
      * TAL-1040: the owner mints a diagnostic chat, freezes its bypass in the creation receipt and runs each turn in a fresh
@@ -315,7 +441,7 @@ export class GatewaySessions {
         if (modelMutation)
             this.modelMutations.set(target.key, (this.modelMutations.get(target.key) ?? 0) + 1);
         try {
-            const result = await sidecar.call('gateway.session', { ...params, profile_home: target.home, session_id: target.sid }, { timeoutMs: params.action === 'mutate' ? 675_000 : 35_000, ...(signal ? { signal } : {}) });
+            const result = await sidecar.call('gateway.session', { ...params, profile_home: target.home, session_id: target.sid }, { timeoutMs: params.action === 'mutate' ? 675_000 : params.action === 'shell_exec' ? 40_000 : 35_000, ...(signal ? { signal } : {}) });
             if (params.action === 'mutate' && params.operation === 'model' && result.snapshot) {
                 const change = modelChange(result.receipt ?? {}, params.payload);
                 // The stream can resolve a deferred pick before its HTTP ACK returns. Keep the later observation.
@@ -362,13 +488,39 @@ export class GatewaySessions {
     contextDetailKey(target, snapshot) {
         return snapshot ? ownerStateId(JSON.stringify([target.key, snapshot.authority_epoch, snapshot.replay_epoch, snapshot.revision, snapshot.execution_generation, snapshot.info, snapshot.last_sequence])) : null;
     }
+    reactionView(row, allowed) {
+        if (!Number.isSafeInteger(row.row_id) || Number(row.row_id) <= 0 || !['user', 'assistant'].includes(str(row.role)))
+            return undefined;
+        const authors = new Map();
+        for (const raw of Array.isArray(row.reactions) ? row.reactions : []) {
+            const reaction = raw;
+            const emoji = ReactionEmojiSchema.safeParse(reaction?.emoji);
+            if (emoji.success && (reaction.author === 'user' || reaction.author === 'agent'))
+                authors.set(reaction.author, emoji.data);
+        }
+        const state = (selected) => {
+            const values = [authors.get('agent'), selected].filter((emoji) => emoji !== undefined && emoji !== null);
+            return { selected, items: ReactionEmojiSchema.options.flatMap((emoji) => {
+                    const count = values.filter((value) => value === emoji).length;
+                    return count ? [{ emoji, count, mine: selected === emoji }] : [];
+                }) };
+        };
+        const selected = authors.get('user') ?? null;
+        return { row_id: Number(row.row_id), state: state(selected), actions: allowed
+                ? [...ReactionEmojiSchema.options, ...(selected ? [null] : [])].map((emoji) => ({ emoji, result: state(emoji === selected ? null : emoji) })) : [] };
+    }
     async view(base, result, stream, target, limit = 120, before = null, withMessages = true) {
         const snapshot = result.snapshot;
-        const fields = { ...base, owner_attachment: this.attachment({ ...result, model_change: this.currentModelChange(target, snapshot) }), composer_state_key: ownerStateId(target.key), context_detail_key: this.contextDetailKey(target, snapshot), active_stream_id: stream, is_streaming: Boolean(stream) };
+        const showReasoning = await this.deps.service.deps.showReasoning?.(target.profile) ?? true;
+        const fields = { ...base, plan_gauge: snapshot?.plan_gauge ?? null, show_reasoning: showReasoning, owner_attachment: this.attachment({ ...result, model_change: this.currentModelChange(target, snapshot) }), composer_state_key: ownerStateId(target.key), context_detail_key: this.contextDetailKey(target, snapshot), active_stream_id: stream, is_streaming: Boolean(stream) };
         if (snapshot) {
             fields.notices = this.nativeNotices(target, snapshot);
+            fields.todo_state = this.nativeTodo(target, snapshot) ?? normalizeTodoSnapshot({ todos: [] });
             const observed = this.watches.get(target.key)?.snapshot;
-            const nativeRows = [...snapshot.messages];
+            const canReact = snapshot.reactions_supported === true && this.attachment(result).can_submit;
+            const nativeRows = snapshot.messages.map(({ reactions, ...row }) => ({ ...row,
+                reaction_view: this.reactionView({ ...row, reactions }, canReact),
+            }));
             const active = stream ? runningAdmission(snapshot) : null;
             let start = active ? nativeRows.findIndex((m) => m.role === 'user' && m.message_id === active.admission_id) : -1;
             if (active && stream && start < 0) {
@@ -376,7 +528,7 @@ export class GatewaySessions {
                 nativeRows.push({ ...pendingUserRow(active.text ?? '', [], null, str(snapshot.info.source) || 'gateway', stream), message_id: active.admission_id });
             }
             const messages = start < 0 ? nativeRows : nativeRows.map((row, index) => index >= start ? { ...row, _turn_id: stream } : row);
-            const projected = withMessages ? this.deps.service.foreignMessages(messages, base) : [];
+            const projected = withMessages ? this.deps.service.foreignMessages(messages, base, showReasoning) : [];
             const [rows, offset] = messageWindowForDisplay(projected, limit, before);
             const model = str(snapshot.info.model) || str(base.model) || null;
             const provider = Object.hasOwn(snapshot.info, 'provider')
@@ -411,7 +563,7 @@ export class GatewaySessions {
         return this.view(base, result, watch?.stream ?? null, target, limit, before, withMessages);
     }
     /** Called before the direct-chat admission path, including for an already materialized foreign session. */
-    async submit(sid, body, timing) {
+    async submit(sid, body, timing, fence) {
         const target = await this.target(sid);
         if (!target)
             return null;
@@ -431,6 +583,8 @@ export class GatewaySessions {
             throw new HttpFailure(400, 'File attachments are unavailable through this owner connection', { code: 'owner_attachments_unavailable' });
         // Resolve display state before admission; a failed post-ACK read must never turn accepted work into a refusal.
         const base = await (timing ? timing.measure('owner_detail', () => this.deps.service.detail(sid, {})) : this.deps.service.detail(sid, {}));
+        if (fence && (!this.deps.service.deps.profilesMatch(str(base.profile) || null, fence.profile) || (str(base.project_id) || null) !== fence.project_id || before.snapshot?.authority_epoch !== fence.authority_epoch || before.snapshot.running || before.snapshot.pending.some((p) => p.status !== 'terminal')))
+            throw new HttpFailure(409, 'Queue target changed or is busy');
         const closeSubmit = timing?.begin('owner_submit');
         const result = await this.call(target, { action: 'submit', request_id: body.submission_id, text });
         closeSubmit?.(result.receipt ? 'ok' : result.state === 'unavailable' ? 'unknown' : 'refused');
@@ -461,9 +615,24 @@ export class GatewaySessions {
                 throw new HttpFailure(400, 'The workspace must be trusted before selecting it');
             }
         }
-        const result = await this.call(target, params);
+        if (params.action === 'react') {
+            const current = await this.call(target, { action: 'snapshot' });
+            const row = current.snapshot?.messages.find((row) => row.row_id === params.row_id);
+            if (!row || current.snapshot?.reactions_supported !== true || !this.attachment(current).can_submit
+                || !['user', 'assistant'].includes(str(row.role)))
+                throw new HttpFailure(409, 'Reactions are unavailable for this message');
+        }
+        let result = await this.call(target, params);
+        if (params.action === 'react' && result.state === 'unavailable') {
+            // A toggle has no idempotency key. Read the owner after a lost ACK; never replay the write.
+            result = await this.call(target, { action: 'snapshot' });
+            if (result.state !== 'attached' || !result.snapshot)
+                throw new HttpFailure(503, 'Could not confirm the reaction. Reconnect to read its current value.', { outcome_unknown: true });
+        }
         if (result.state !== 'attached' || !result.snapshot)
             throw new HttpFailure(409, 'The owning Agent refused the action', { owner_attachment: this.attachment(result) });
+        if (params.action === 'react')
+            this.changed(target);
         this.deps.events.publish('owner_changed', { profile: target.profile, sessionId: sid });
         return result;
     }
@@ -600,6 +769,8 @@ export class GatewaySessions {
         const registry = this.deps.registry;
         const channel = registry.create(watch.stream, target.sid);
         registry.registerActiveRun({ stream_id: watch.stream, session_id: target.sid, phase: 'running', started_at: this.deps.now(), workspace: str(base.workspace), model: str(base.model) || null, provider: null, ephemeral: false, origin: 'user' });
+        // TAL-1564: the sidebar row turns streaming now, including for an idle observation whose owner just started a run.
+        this.deps.events.publish('owner_changed', { profile: target.profile, sessionId: target.sid });
         let chain = Promise.resolve();
         let terminal = false;
         let streamError = null;
@@ -615,9 +786,9 @@ export class GatewaySessions {
             const journalSession = ownerStateId(target.key);
             const writer = await this.deps.journal.writer(journalSession, watch.stream);
             closeWriter = writer;
-            const showReasoning = await this.deps.showReasoning(target.home).catch(() => false);
             let completion = null;
             let replaying = true;
+            let liveRunning = false;
             let usage = {};
             let reasoning = '';
             let titles = new ReasoningTitleTracker();
@@ -638,9 +809,9 @@ export class GatewaySessions {
                         await put('tool_progress', { id: call.tid, progress: null });
                 calls.length = 0;
             };
-            const resetProjection = async () => { await clearTools(); reasoning = ''; usage = {}; completion = null; titles = new ReasoningTitleTracker(); };
-            const meter = async (data) => {
-                usage = { ...usage, ...ownerUsage(data) };
+            const resetProjection = async () => { await clearTools(); liveRunning = false; reasoning = ''; usage = {}; completion = null; titles = new ReasoningTitleTracker(); };
+            const meter = async (data, complete = false) => {
+                usage = { ...usage, ...ownerUsage(data, complete) };
                 if (['input_tokens', 'output_tokens', 'cache_read_tokens', 'cache_write_tokens'].every((key) => typeof usage[key] === 'number'))
                     await put('metering', { session_id: target.sid, usage: { ...usage, estimated_cost: usage.estimated_cost ?? null }, tps: usage.tps ?? null, tps_available: usage.tps !== undefined, estimated: false });
             };
@@ -652,7 +823,7 @@ export class GatewaySessions {
                 // A new claim may arrive while this turn's receipt is being read. Give it its own projection immediately.
                 if (this.watches.get(target.key) === watch)
                     this.watches.delete(target.key);
-                registry.retire(watch.stream);
+                registry.activeRuns.delete(watch.stream);
                 await clearTools();
                 const current = await this.call(target, { action: 'snapshot' });
                 const rawReceipt = activeAdmission ? (await this.call(target, { action: 'receipt', admission_id: activeAdmission })).receipt : null;
@@ -666,11 +837,17 @@ export class GatewaySessions {
                 // A terminal frame for the previous generation must not overwrite the newer turn's state.
                 const session = current.snapshot && !sameExecution(current.snapshot, observation.snapshot)
                     ? undefined : { ...await this.view(base, current, null, target), ...usage };
+                if (session)
+                    session.activity_phase = await this.deps.service.deps.sessionActivity?.(target.sid, target.profile, { terminalPhase: cancelled ? 'cancelled' : failed ? 'failed' : 'completed' });
                 await put(cancelled ? 'cancel' : failed ? 'apperror' : 'done', { session_id: target.sid,
                     terminal_state: cancelled ? 'cancelled' : failed ? 'error' : 'completed',
                     ...(failed ? refusal ?? { message: 'The owning Agent could not complete this turn', type: current.reason ?? 'owner_turn_failed' } : {}),
                     ...(Object.keys(usage).length ? { usage } : {}),
                     ...(session ? { session } : {}) });
+                if (liveRunning && !cancelled && !failed && receipt?.admission_id === activeAdmission && receipt?.authority_epoch === watch.snapshot.authority_epoch
+                    && receipt.execution_generation === watch.snapshot.execution_generation) {
+                    this.deps.onWebCompletion?.(target.profile, target.sid, JSON.stringify(['owner', target.sid, watch.snapshot.authority_epoch, watch.snapshot.replay_epoch, watch.snapshot.execution_generation, receipt.admission_id]));
+                }
                 await put('stream_end', { session_id: target.sid });
                 watch.controller.abort();
             };
@@ -700,6 +877,7 @@ export class GatewaySessions {
                 enqueue(async () => {
                     if (frame.event === 'replay_complete') {
                         replaying = false;
+                        liveRunning ||= watch.snapshot.running;
                         if (!watch.snapshot.running && !watch.snapshot.pending.some((p) => p.status === 'queued' || p.status === 'started'))
                             await finish();
                         return;
@@ -719,12 +897,15 @@ export class GatewaySessions {
                     if (frame.event === 'snapshot') {
                         const result = GatewaySessionResultSchema.parse(frame.data);
                         replaying = frame.data.replaying === true;
+                        if (replaying)
+                            liveRunning = false;
                         if (!result.snapshot)
                             return;
                         if (result.replay_gap || !sameExecution(result.snapshot, watch.snapshot))
                             await resetProjection();
                         await put('session_snapshot', { session: await this.view(base, result, watch.stream, target), replay_gap: result.replay_gap === true });
                         await prompts(result.snapshot);
+                        liveRunning ||= !replaying && result.snapshot.running;
                         if (!result.snapshot.running && !result.snapshot.pending.some((p) => p.status === 'queued' || p.status === 'started'))
                             await finish();
                         return;
@@ -736,6 +917,10 @@ export class GatewaySessions {
                         await put('notices', { session_id: target.sid, notices: this.nativeNotices(target, observation.snapshot) });
                         return;
                     }
+                    if (kind === 'todo.updated') {
+                        await put('todo_state', { ...normalizeTodoSnapshot(data), session_id: target.sid, stream_id: watch.stream, source: 'live' });
+                        return;
+                    }
                     if (kind === 'request.cancel') {
                         // The owner withdraws a settled, timed-out or interrupted batch from every viewer.
                         if (!watch.batch || watch.batch.request_id !== data.id)
@@ -776,6 +961,7 @@ export class GatewaySessions {
                         if (firstClaim && claimed)
                             activeAdmission = claimed.admission_id;
                         ran ||= data.running === true;
+                        liveRunning ||= !replaying && data.running === true;
                         if (firstClaim)
                             await put('session_snapshot', { session: await this.view(base, { state: 'attached', reason: null, snapshot: watch.snapshot, receipt: null, restarting: watch.restarting }, watch.stream, target) });
                         if (data.running === false && (ran || !watch.snapshot.pending.some((p) => p.status === 'queued' || p.status === 'started')))
@@ -786,18 +972,20 @@ export class GatewaySessions {
                         return;
                     if (kind === 'message.delta') {
                         const stable = titles.stableSnapshot(reasoning);
-                        if (stable !== null)
+                        if (stable !== null && await this.deps.showReasoning(target.home).catch(() => false))
                             await put('reasoning', { text: '', titles: stable });
                         await put('token', { text: str(data.text || data.delta || data.content) });
                     }
-                    else if (kind === 'reasoning.delta' && showReasoning) {
+                    else if (kind === 'reasoning.delta') {
                         reasoning += str(data.text);
-                        await put('reasoning', titles.prepare(reasoningEventPayload(data.text, reasoning)));
+                        if (await this.deps.showReasoning(target.home).catch(() => false))
+                            await put('reasoning', titles.prepare(reasoningEventPayload(data.text, reasoning)));
                     }
                     else if (kind.startsWith('subagent.') && str(data.subagent_id)) {
                         // Reuse the delegate activity row; each child keeps one identity through progress and completion.
                         const complete = kind === 'subagent.complete';
-                        const preview = kind === 'subagent.thinking' && !showReasoning ? '' : str(data.summary || data.tool_preview || data.text);
+                        const visible = kind !== 'subagent.thinking' || await this.deps.showReasoning(target.home).catch(() => false);
+                        const preview = visible ? str(data.summary || data.tool_preview || data.text) : '';
                         await put(complete ? 'tool_complete' : 'tool', { id: `owner-subagent-${str(data.subagent_id)}`, name: 'subagent_progress',
                             args: { task: str(data.goal) }, preview: preview || null,
                             ...(complete ? { is_error: data.status !== 'completed', duration: data.duration_seconds } : {}) });
@@ -815,7 +1003,7 @@ export class GatewaySessions {
                             completion = { admission: activeAdmission, message: data.text, type: 'cron_session_read_only', code: 'cron_session_read_only', retryable: false };
                         }
                         if (data.usage && typeof data.usage === 'object')
-                            await meter(data.usage);
+                            await meter(data.usage, true);
                     }
                     else if (kind === 'tool.start' || kind === 'tool.progress' || kind === 'tool.complete') {
                         if (event.session_id !== target.sid || event.replay_epoch !== undefined && event.replay_epoch !== watch.snapshot.replay_epoch)