@chatcode/chatcode-cli 3.0.4-rc.1 → 3.0.4-rc.2

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/agent.js

@@ -163,6 +163,7 @@ export async function inspectApiSession(ctx, sessionId, signal) {
 /** Owns every operation that may create, resume, or configure a Web Agent. */
 export class ApiSessionAgentController {
     ctx;
+    owned = new Map();
     resumes = new Map();
     creations = new Map();
     selections = new WeakMap();
@@ -170,6 +171,20 @@ export class ApiSessionAgentController {
     /** @param ctx - Host context carrying Agent, model, persistence, and Typert services. */
     constructor(ctx) {
         this.ctx = ctx;
+        ctx.on('session/delete-release', async ({ sessionIds }) => {
+            for (const id of sessionIds) {
+                const handle = this.owned.get(id);
+                if (handle?.agent.status === 'idle')
+                    await handle.dispose();
+            }
+        });
+        ctx.on('agent/disposed', ({ agent }) => {
+            if (this.owned.get(agent.session.id)?.agent === agent)
+                this.owned.delete(agent.session.id);
+        });
+        ctx.effect(() => async () => {
+            await Promise.all([...this.owned.values()].map(handle => handle.dispose()));
+        }, 'api-session.ownedAgents');
         ctx.typert.lookups.configure('agent', async (sessionId) => {
             const found = await this.resolveAgent(sessionId);
             if ('error' in found)
@@ -307,6 +322,8 @@ export class ApiSessionAgentController {
         const defaultModel = this.ctx.agentDefaultModel;
         const selection = {
             get current() {
+                if (defaultModel.usesSharedPreference())
+                    return defaultModel.currentSelection();
                 if (picked !== undefined)
                     return picked;
                 const loggedHeader = agent.session.requestHeader();
@@ -445,11 +462,11 @@ export class ApiSessionAgentController {
         if (published !== undefined && hasApiSessionSubagentOwner(this.ctx, published, live)) {
             throw new ApiSessionSubagentOwnership(sessionId);
         }
-        return (await this.ctx.agents.resume({
+        return (await this.remember(this.ctx.agents.resume({
             resumeSessionId: sessionId,
             agentOptions: this.agentOptions(),
             setup: composition.setup,
-        })).agent;
+        }))).agent;
     }
     async createOrAdopt(sessionId, cwd, checkPersistedIdentity, presetId) {
         const attached = this.ctx.sessions.get(sessionId);
@@ -473,11 +490,11 @@ export class ApiSessionAgentController {
                     const storedPreset = this.presetForObservation(observation);
                     this.assertPresetUnchanged(sessionId, presetId, storedPreset);
                     const composition = await this.composeAgent(storedPreset);
-                    return (await this.ctx.agents.resume({
+                    return (await this.remember(this.ctx.agents.resume({
                         resumeSessionId: sessionId,
                         agentOptions: this.agentOptions(),
                         setup: composition.setup,
-                    })).agent;
+                    }))).agent;
                 }
                 catch (e_3) {
                     env_3.error = e_3;
@@ -500,7 +517,7 @@ export class ApiSessionAgentController {
             throw new Error(`failed to ensure project directory "${cwd}": ${String(error)}`, { cause: error });
         }
         const composition = await this.composeAgent(presetId);
-        return (await this.ctx.agents.create({
+        return (await this.remember(this.ctx.agents.create({
             sessionId,
             agentOptions: this.agentOptions(),
             meta: {
@@ -508,7 +525,20 @@ export class ApiSessionAgentController {
                 ...(composition.agentPreset === undefined ? {} : { agentPreset: composition.agentPreset }),
             },
             setup: composition.setup,
-        })).agent;
+        }))).agent;
+    }
+    /**
+     * Create a Web-owned Agent whose idle handle can be released before permanent deletion.
+     * @param options - Agent creation input shared by new Sessions and ordinary forks.
+     * @returns the owned Agent handle.
+     */
+    createOwned(options) {
+        return this.remember(this.ctx.agents.create(options));
+    }
+    async remember(pending) {
+        const handle = await pending;
+        this.owned.set(handle.agent.session.id, handle);
+        return handle;
     }
     agentOptions() {
         const { provider, model } = this.ctx.agentDefaultModel.currentSelection();

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/archived-session-gate.js

@@ -33,7 +33,7 @@ export const ArchivedSessionGate = {
  * @returns whether an archived Session owns the step.
  */
 export function underArchivedSession(ctx, agent) {
-    const archived = ctx.workspaceRegistry.archivedSessionIds;
+    const archived = [...ctx.workspaceRegistry.archivedSessionIds, ...ctx.workspaceRegistry.deletedSessionIds];
     let header = agent.session.header;
     const visited = new Set();
     while (!visited.has(header.id)) {

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/catalog.js

@@ -57,8 +57,11 @@ export async function buildModelCatalog(ctx, defaultSelection = ctx.agentDefault
     const groups = catalog.flatMap(item => item.kind === 'group' ? [item.group] : [])
         .filter(group => group.models.length > 0);
     const savedDisplayName = ctx.agentDefaultModel.sharedDisplayName();
+    const processSelection = ctx.agentDefaultModel.usesSharedPreference();
+    const selected = processSelection ? await ctx.agentDefaultModel.resolveSelection() : defaultSelection;
     return {
-        default: { ...defaultSelection },
+        default: { ...selected },
+        ...processSelection ? { selectionScope: 'process' } : {},
         ...savedDisplayName === undefined ? {} : { savedDisplayName },
         routableProviders: groups.map(group => group.id),
         groups,

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/client/sessions/service.d.ts

@@ -32,7 +32,7 @@ export interface SessionSummary {
      * summary, `sessionListMetadata`, and client acceptance/running observations.
      * New Session reuses a blank one targeting the same workspace. Filtering
      * stays with the consumer: the store carries every row, while the Workspace
-     * browser shows only the selected blank entry.
+     * browser separately hides Sessions without real user input.
      */
     blank: boolean;
     updatedAt: number;

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/commands.d.ts

@@ -20,9 +20,9 @@ export declare class SessionCommandController {
      */
     create(request: SessionCreateRequest): Promise<SessionCreateValue>;
     /**
-     * Validate and install one Session-local model selection; save the default in the background.
+     * Validate, persist the default, and install one model selection before acknowledging success.
      * @param request - Session identity and requested model selection.
-     * @returns the normalized selection installed for the Session, without waiting for default persistence.
+     * @returns the normalized selection after the shared save and Session selection succeed.
      */
     selectModel(request: SessionSelectModelRequest): Promise<SessionSelectModelValue>;
     /**

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/commands.js

@@ -138,9 +138,9 @@ export class SessionCommandController {
         return { sessionId, ...(agentPreset === undefined ? {} : { agentPreset }) };
     }
     /**
-     * Validate and install one Session-local model selection; save the default in the background.
+     * Validate, persist the default, and install one model selection before acknowledging success.
      * @param request - Session identity and requested model selection.
-     * @returns the normalized selection installed for the Session, without waiting for default persistence.
+     * @returns the normalized selection after the shared save and Session selection succeed.
      */
     async selectModel(request) {
         const agent = await this.resolveAgent(request.sessionId);
@@ -161,10 +161,20 @@ export class SessionCommandController {
                         ? {}
                         : { reasoningEffort: resolved.reasoningEffort }),
                 };
-                this.agents.selectForNextRequest(agent, selected);
-                void this.ctx.agentDefaultModel.saveSelection(selected).catch((error) => {
-                    this.ctx.logger.warn(`session-controller: model selection changed for the Session but the default was not saved: ${String(error)}`);
-                });
+                const info = await this.ctx.llm.resolveModelInfo(selected.provider, selected.model);
+                try {
+                    await this.ctx.agentDefaultModel.saveSelection(selected, info.name);
+                }
+                catch (error) {
+                    throw new RemoteError('session/model-save-failed', `model selection was not changed because the default could not be saved: ${String(error)}`, { provider: selected.provider, model: selected.model });
+                }
+                this.ctx.emit('api-session/model-updated');
+                try {
+                    this.agents.selectForNextRequest(agent, selected);
+                }
+                catch (error) {
+                    throw new RemoteError('session/model-install-failed', `the default model was saved, but the Session selection could not be recorded: ${String(error)}`, { provider: selected.provider, model: selected.model });
+                }
                 return { selected: { ...selected } };
             }
             catch (error) {
@@ -245,7 +255,7 @@ export class SessionCommandController {
             const composition = await this.agents.composeAgent(this.agents.presetForObservation(source));
             try {
                 const { provider, model } = this.ctx.agentDefaultModel.currentSelection();
-                await this.ctx.agents.create({
+                await this.agents.createOwned({
                     sessionId: childId,
                     seed,
                     inheritedEventCount: SessionLogOffset(boundary + 1),
@@ -310,6 +320,11 @@ export class SessionCommandController {
             try {
                 const env_2 = { stack: [], error: void 0, hasError: false };
                 try {
+                    if (this.ctx.agentDefaultModel.usesSharedPreference()) {
+                        const route = await this.ctx.agentDefaultModel.resolveSelection();
+                        if (route.provider === '' || route.model === '')
+                            throw new RemoteError('session/model-unavailable', 'the selected model is unavailable; select a model before sending a message', { provider: route.provider, model: route.model });
+                    }
                     if (hasImage) {
                         const current = this.agents.selectionFor(agent).current;
                         const model = await this.ctx.llm.resolveModelInfo(current.provider, current.model);
@@ -348,7 +363,8 @@ export class SessionCommandController {
             }
             return { accepted: true };
         };
-        return hasImage ? this.agents.serializeImageAdmission(agent, admit) : admit();
+        return hasImage || this.ctx.agentDefaultModel.usesSharedPreference()
+            ? this.agents.serializeImageAdmission(agent, admit) : admit();
     }
     async requireModel(selection) {
         if (!await modelAvailable(this.ctx, selection)) {

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/index.d.ts

@@ -92,13 +92,13 @@ export declare class SessionController extends TypertRemoteService {
      */
     create(request: SessionCreateRequest): Promise<SessionCreateValue>;
     /**
-     * Select one Session-local model after explicitly resuming the Session; save the default in the background.
+     * Select a model after explicitly resuming the Session and awaiting default persistence.
      * @param request - Session identity and requested model selection.
-     * @returns the normalized selection installed for the Session, without waiting for default persistence.
+     * @returns the normalized selection after the shared save and Session selection succeed.
      */
     selectModel(request: SessionSelectModelRequest): Promise<SessionSelectModelValue>;
     /**
-     * Select the first available account model after login when no provider API key is configured.
+     * Initialize legacy account deployments without changing a product process's cached selection.
      * @returns after saving the first available model or retaining the existing default.
      */
     initializeDefaultModel(): Promise<void>;
@@ -194,6 +194,7 @@ export declare class SessionController extends TypertRemoteService {
      *   frames and optional cursorless assistant-stream frames.
      */
     follow(request: SessionFollowRequest, signal: AbortSignal): AsyncIterable<SessionFollowFrame>;
+    private assertNotDeleted;
     /**
      * Read all registered projections without activating an Agent.
      * @param request - Session whose current values are required.

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/index.js

@@ -236,6 +236,10 @@ let SessionController = (() => {
             // until it is restored; what it still runs is stopped by the owners that
             // answer the Workspace registry's archive-admission events.
             ctx.plugin(ArchivedSessionGate);
+            ctx.on('session/deleted', (ids) => {
+                for (const id of ids)
+                    ctx.emit('api-session/removed', id);
+            });
             ctx.on('session/created', (session) => {
                 ctx.emit('api-session/added', this.listState.summaryFor(session));
             });
@@ -338,22 +342,26 @@ let SessionController = (() => {
          * @param request - requested identity, location, and Agent preset.
          * @returns the Session identity and resolved preset when configured.
          */
-        create(request) {
+        async create(request) {
+            if (request.sessionId !== undefined)
+                await this.assertNotDeleted(request.sessionId);
             return this.commands.create(request);
         }
         /**
-         * Select one Session-local model after explicitly resuming the Session; save the default in the background.
+         * Select a model after explicitly resuming the Session and awaiting default persistence.
          * @param request - Session identity and requested model selection.
-         * @returns the normalized selection installed for the Session, without waiting for default persistence.
+         * @returns the normalized selection after the shared save and Session selection succeed.
          */
         selectModel(request) {
-            return this.commands.selectModel(request);
+            return this.assertNotDeleted(request.sessionId).then(() => this.commands.selectModel(request));
         }
         /**
-         * Select the first available account model after login when no provider API key is configured.
+         * Initialize legacy account deployments without changing a product process's cached selection.
          * @returns after saving the first available model or retaining the existing default.
          */
         async initializeDefaultModel() {
+            if (this.ctx.agentDefaultModel.usesSharedPreference())
+                return;
             const provider = 'deepseek-account';
             if (await hasProviderApiKey(this.ctx))
                 return;
@@ -364,7 +372,8 @@ let SessionController = (() => {
             const selection = { provider, model: model.id,
                 ...model.reasoning?.defaultEffort === undefined ? {} : { reasoningEffort: ReasoningEffortId(model.reasoning.defaultEffort) },
             };
-            await this.ctx.agentDefaultModel.saveSelection(selection);
+            await this.ctx.agentDefaultModel.saveSelection(selection, model.name);
+            this.ctx.emit('api-session/model-updated');
         }
         /**
          * Describe every currently routable model for Host-generation selectors.
@@ -455,7 +464,7 @@ let SessionController = (() => {
          * @returns the accepted title and durable event sequence.
          */
         rename(request) {
-            return this.commands.rename(request);
+            return this.assertNotDeleted(request.sessionId).then(() => this.commands.rename(request));
         }
         /**
          * Fork one cold-readable exact event prefix into a new Session. An omitted
@@ -465,7 +474,7 @@ let SessionController = (() => {
          * @returns the new Session identity.
          */
         fork(request) {
-            return this.commands.fork(request);
+            return this.assertNotDeleted(request.sessionId).then(() => this.commands.fork(request));
         }
         /**
          * Admit one prompt after explicitly resuming its Session.
@@ -475,7 +484,7 @@ let SessionController = (() => {
          */
         prompt(request, signal) {
             signal.throwIfAborted();
-            return this.commands.prompt(request);
+            return this.assertNotDeleted(request.sessionId).then(() => this.commands.prompt(request));
         }
         /**
          * Read one image proven reachable from the addressed Session log.
@@ -483,7 +492,7 @@ let SessionController = (() => {
          * @returns the durable attachment reference and base64-encoded bytes.
          */
         attachment(request) {
-            return this.commands.attachment(request);
+            return this.assertNotDeleted(request.sessionId).then(() => this.commands.attachment(request));
         }
         /**
          * Mutate one still-pending queue occurrence, resuming a cold Agent first.
@@ -491,7 +500,7 @@ let SessionController = (() => {
          * @returns acknowledgement that the queue mutation was applied.
          */
         updateQueue(request) {
-            return this.commands.updateQueue(request);
+            return this.assertNotDeleted(request.sessionId).then(() => this.commands.updateQueue(request));
         }
         /**
          * Cancel one active Agent turn without dropping its pending inbox.
@@ -508,7 +517,7 @@ let SessionController = (() => {
          * @returns one chronological page.
          */
         page(request, signal) {
-            return this.history.page(request, signal);
+            return this.assertNotDeleted(request.address.kind === 'session' ? request.address.sessionId : request.address.childSessionId).then(() => this.history.page(request, signal));
         }
         /**
          * Follow one Session log from its opening or resume cursor.
@@ -517,8 +526,15 @@ let SessionController = (() => {
          * @returns a complete opening snapshot followed by gap-free durable event
          *   frames and optional cursorless assistant-stream frames.
          */
-        follow(request, signal) {
-            return this.history.follow(request, signal);
+        async *follow(request, signal) {
+            await this.assertNotDeleted(request.address.kind === 'session' ? request.address.sessionId : request.address.childSessionId);
+            yield* this.history.follow(request, signal);
+        }
+        async assertNotDeleted(sessionId) {
+            await this.ctx.workspaceRegistry.refresh();
+            if (this.ctx.workspaceRegistry.deletedSessionIds.includes(sessionId)) {
+                throw new RemoteError('session/not-found', 'Session has been permanently deleted', { sessionId });
+            }
         }
         /**
          * Read all registered projections without activating an Agent.
@@ -531,6 +547,7 @@ let SessionController = (() => {
             if (sessionId.length === 0) {
                 throw new RemoteError('gateway/bad-request', 'sessionId must not be empty', {});
             }
+            await this.assertNotDeleted(sessionId);
             try {
                 const env_2 = { stack: [], error: void 0, hasError: false };
                 try {

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/list.d.ts

@@ -19,6 +19,10 @@ export declare function truncateUnicodeCodePoints(value: string, maximum: number
 /** Owns list projection registration, bounded cold summaries, and authorized search. */
 export declare class ApiSessionList {
     private readonly ctx;
+    private readonly backfillAbort;
+    private readonly backfills;
+    private readonly checkedRevisions;
+    private backfill;
     /** @param ctx - Host context carrying Session, query, persistence, and projection services. */
     constructor(ctx: Context);
     /**
@@ -34,6 +38,8 @@ export declare class ApiSessionList {
      */
     list(signal?: AbortSignal): Promise<SessionSummary[]>;
     private summarizeCold;
+    /** Serialize missing summaries outside list latency; unreadable history stays unknown. */
+    private backfillCold;
     /**
      * Search current visible message content without activating any matching Session.
      * @param query - literal message-content query.

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/list.js

@@ -1,4 +1,5 @@
 /** Cold-safe Session list and search projection. */
+import { SessionLogOffset } from '@deepseek-ai/dsh-session';
 import { SessionQueryError } from '@deepseek-ai/dsh-session-query';
 import { RemoteError } from '@deepseek-ai/dsh-typert-protocol';
 import { z } from 'zod';
@@ -7,6 +8,7 @@ const SEARCH_PROVIDER_CALL_LIMIT = 100;
 const SESSION_SEARCH_QUERY_MAX_CHARS = 500;
 const MESSAGE_TYPES = new Set(['user/message', 'assistant/message']);
 const sessionListMetadataSchema = z.object({
+    hasUserPrompt: z.boolean().default(false),
     blank: z.boolean(),
     lastPromptAt: z.number().nullable(),
 });
@@ -26,12 +28,20 @@ const imageLimitsSchema = z.object({
  */
 export function applySessionListMetadata(state, event) {
     const blank = state.blank && event.type !== 'turn/start';
+    const hasUserPrompt = state.hasUserPrompt === true || hasHumanInput(event);
     const lastPromptAt = event.type === 'user/message' && event.data.source.kind === 'user'
         ? event.time
         : state.lastPromptAt;
-    return blank === state.blank && lastPromptAt === state.lastPromptAt
+    return blank === state.blank && lastPromptAt === state.lastPromptAt && hasUserPrompt === state.hasUserPrompt
         ? state
-        : { blank, lastPromptAt };
+        : { blank, lastPromptAt, hasUserPrompt };
+}
+/** User-origin text or media is conversation input; injected context is not. */
+function hasHumanInput(event) {
+    const messages = event.type === 'user/message' ? [{ ...event.data, role: 'user' }]
+        : event.type === 'agent/inbox/spliced' ? event.data.inserted : [];
+    return messages.some(message => message.role === 'user' && message.source.kind === 'user'
+        && message.content.some(block => block.type !== 'text' || block.text.trim() !== ''));
 }
 /**
  * Return the longest prefix containing at most `maximum` Unicode code points.
@@ -53,16 +63,28 @@ export function truncateUnicodeCodePoints(value, maximum) {
 /** Owns list projection registration, bounded cold summaries, and authorized search. */
 export class ApiSessionList {
     ctx;
+    backfillAbort = new AbortController();
+    backfills = new Set();
+    checkedRevisions = new Map();
+    backfill = Promise.resolve();
     /** @param ctx - Host context carrying Session, query, persistence, and projection services. */
     constructor(ctx) {
         this.ctx = ctx;
         ctx.sessionProjections.register({
             key: 'sessionListMetadata',
             stateSchema: sessionListMetadataSchema,
-            init: () => ({ blank: true, lastPromptAt: null }),
+            init: () => ({ blank: true, lastPromptAt: null, hasUserPrompt: false }),
             apply: applySessionListMetadata,
             wire: { viewSchema: sessionListMetadataSchema, view: state => state },
-            stateVersion: 1,
+            stateVersion: 2,
+        });
+        ctx.effect(() => async () => {
+            this.backfillAbort.abort();
+            await this.backfill;
+        }, 'session-list: stop summary backfill');
+        ctx.on('session/event', (session, event) => {
+            if (hasHumanInput(event))
+                ctx.emit('api-session/added', this.summaryFor(session));
         });
         ctx.inject(['attachments'], (attachmentCtx) => {
             ctx.sessionProjections.register({
@@ -104,6 +126,11 @@ export class ApiSessionList {
     async list(signal) {
         signal?.throwIfAborted();
         const records = await this.ctx.sessionQuery.listSessions(signal);
+        const listedIds = new Set(records.map(record => record.header.id));
+        for (const id of this.checkedRevisions.keys()) {
+            if (!listedIds.has(id))
+                this.checkedRevisions.delete(id);
+        }
         signal?.throwIfAborted();
         const items = [];
         const cold = [];
@@ -128,6 +155,8 @@ export class ApiSessionList {
     async summarizeCold(header) {
         const projections = await this.projectionsFor(header, undefined);
         const metadata = projections?.values.sessionListMetadata;
+        if (metadata?.hasUserPrompt !== true)
+            this.backfillCold(header.id);
         return {
             sessionId: header.id,
             updatedAt: updatedAt(header, metadata),
@@ -139,6 +168,62 @@ export class ApiSessionList {
             ...(projections === undefined ? {} : { projections }),
         };
     }
+    /** Serialize missing summaries outside list latency; unreadable history stays unknown. */
+    backfillCold(sessionId) {
+        if (this.backfillAbort.signal.aborted || this.backfills.has(sessionId))
+            return;
+        const persistence = this.ctx.get('sessionPersistence');
+        const cache = this.ctx.get('sessionProjectionCache');
+        if (persistence === undefined || cache === undefined)
+            return;
+        this.backfills.add(sessionId);
+        this.backfill = this.backfill.then(async () => {
+            const signal = this.backfillAbort.signal;
+            signal.throwIfAborted();
+            const live = this.ctx.sessions.get(sessionId);
+            if (live !== undefined) {
+                this.ctx.emit('api-session/added', this.summaryFor(live));
+                return;
+            }
+            const before = await persistence.stat(sessionId, { signal });
+            if (before === undefined || before.revision === this.checkedRevisions.get(sessionId))
+                return;
+            const handle = await persistence.open(sessionId, 'read', { signal });
+            let snapshot;
+            try {
+                const read = await handle.read(SessionLogOffset(0), undefined, { signal });
+                signal.throwIfAborted();
+                const after = await persistence.stat(sessionId, { signal });
+                if (after?.revision !== before.revision || after.header.createdAt !== handle.header.createdAt)
+                    return;
+                snapshot = await cache.coldSnapshot(handle.header, handle.inheritedEventCount, read.events);
+                this.checkedRevisions.set(sessionId, before.revision);
+            }
+            finally {
+                await handle.close();
+            }
+            signal.throwIfAborted();
+            const attached = this.ctx.sessions.get(sessionId);
+            if (attached !== undefined) {
+                this.ctx.emit('api-session/added', this.summaryFor(attached));
+                return;
+            }
+            const stat = await persistence.stat(sessionId, { signal });
+            if (stat?.revision !== before.revision)
+                return;
+            const projections = hintsOf('cached', snapshot);
+            this.ctx.emit('api-session/added', {
+                sessionId, updatedAt: updatedAt(handle.header, snapshot.values.sessionListMetadata),
+                agentAvailable: false, running: false,
+                blank: snapshot.values.sessionListMetadata?.blank ?? false,
+                ...listFields(handle.header), ...projections === undefined ? {} : { projections },
+            });
+        }).catch((error) => {
+            if (!this.backfillAbort.signal.aborted) {
+                this.ctx.logger.warn(`api-session.list: summary backfill for "${sessionId}" failed: ${String(error)}`);
+            }
+        }).finally(() => { this.backfills.delete(sessionId); });
+    }
     /**
      * Search current visible message content without activating any matching Session.
      * @param query - literal message-content query.

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/remote-events.d.ts

@@ -1,5 +1,5 @@
 /** Session Controller events available to a Remote Event assembly. */
-type SessionControllerRemoteEvent = 'api-session/activity' | 'api-session/added' | 'api-session/error' | 'api-session/removed' | 'api-session/status';
+type SessionControllerRemoteEvent = 'api-session/activity' | 'api-session/added' | 'api-session/error' | 'api-session/model-updated' | 'api-session/removed' | 'api-session/status';
 declare module '@deepseek-ai/dsh-typert-protocol' {
     interface TypertRemoteEventSelection extends Record<SessionControllerRemoteEvent, true> {
     }

package/runtime/node_modules/@deepseek-ai/dsh-api-session-controller/lib/types/types.d.ts

@@ -37,6 +37,8 @@ declare module '@deepseek-ai/dsh-session/types' {
 }
 /** Persisted hints used to summarize a cold Session. */
 export interface SessionListMetadata {
+    /** Real user input exists in this prefix; absent in older cached views. */
+    readonly hasUserPrompt?: boolean;
     /** Whether the folded prefix contains no turn. */
     readonly blank: boolean;
     /** Latest human-authored prompt time in the folded prefix. */
@@ -144,7 +146,9 @@ export interface ModelCatalogFailure {
 /** Host-generation model catalog and the default used by unconfigured Sessions. */
 export interface ModelCatalog {
     readonly default: ModelSelection;
-    /** Latest shared display name; presentation may use it only for the exact provider/model pair. */
+    /** Product profiles use the Host process cache rather than a Session's historical route. */
+    readonly selectionScope?: 'process';
+    /** Process-cached display name; presentation may use it only for the exact provider/model pair. */
     readonly savedDisplayName?: {
         readonly provider: string;
         readonly model: string;
@@ -197,6 +201,14 @@ declare module '@deepseek-ai/dsh-typert-protocol' {
             readonly provider: string;
             readonly model: string;
         };
+        'session/model-save-failed': {
+            readonly provider: string;
+            readonly model: string;
+        };
+        'session/model-install-failed': {
+            readonly provider: string;
+            readonly model: string;
+        };
         'session/conflict': {
             readonly sessionId: SessionId;
             readonly requestedCwd: string;
@@ -555,6 +567,11 @@ export type SessionControlFrame = {
 } & SessionProjectionUpdate);
 declare module '@deepseek-ai/cordis' {
     interface Events {
+        /**
+         * The Host process committed a user-selected default; browser catalogs must reload from that process.
+         * @mode emit
+         */
+        'api-session/model-updated'(): void;
         /**
          * A Session became visible or its Agent was created or disposed.
          * Consumers upsert the summary and replace its current running and availability state.

package/runtime/node_modules/@deepseek-ai/dsh-api-workspace-controller/lib/client.js

@@ -153,6 +153,26 @@ window.__ModuleLoader__.load({
 				return result;
 			}
 			/**
+			* Request the Host's deletion scope for an archived root.
+			* @param sessionId - archived root to preview.
+			* @returns the Host deletion preview.
+			*/
+			sessionDeletionScope(sessionId) {
+				return this.remote.sessionDeletionScope({ sessionId });
+			}
+			/**
+			* Request permanent deletion of exactly the confirmed Session scope.
+			* @param sessionId - archived root.
+			* @param expectedSessionIds - exact scope confirmed by the user.
+			* @returns the Host deletion result.
+			*/
+			deleteSession(sessionId, expectedSessionIds) {
+				return this.remote.deleteSession({
+					sessionId,
+					expectedSessionIds
+				});
+			}
+			/**
 			* Pin one Session and install the returned complete pin set.
 			* A reply superseded by a later pin request or a pushed set installs nothing.
 			* @param sessionId - Session to pin.
@@ -421,6 +441,16 @@ window.__ModuleLoader__.load({
 				const result = await this.model.unarchiveSession(sessionId);
 				if (!result.ok) throw commandError("session unarchive", result.error);
 			}
+			async sessionDeletionScope(sessionId) {
+				const result = await this.model.sessionDeletionScope(sessionId);
+				if (!result.ok) throw new WorkspaceArchiveError(result.error);
+				return result.value.sessionIds;
+			}
+			async deleteSession(sessionId, expectedSessionIds) {
+				const result = await this.model.deleteSession(sessionId, expectedSessionIds);
+				if (!result.ok) throw new WorkspaceArchiveError(result.error);
+				return result.value.sessionIds;
+			}
 			async pinSession(sessionId) {
 				const result = await this.model.pinSession(sessionId);
 				if (!result.ok) throw commandError("session pin", result.error);