@crazx/dsh-api-session-controller 0.1.5-alpha.1.zw.1 → 0.1.5-alpha.1.zw.3

package/lib/client.js

@@ -2179,6 +2179,87 @@ window.__ModuleLoader__.load({
 			return refs;
 		}
 		//#endregion
+		//#region lib/types/client/sessions/selection-history.js
+		function sameSelection(left, right) {
+			return left.sessionId === right.sessionId && left.address?.parentSessionId === right.address?.parentSessionId && left.address?.childSessionId === right.address?.childSessionId;
+		}
+		/**
+		* Bounded LIFO-with-cursor history. Recording a selection made outside
+		* navigation collapses consecutive repeats, truncates the forward tail after
+		* a backtrack, and drops the oldest entry past the bound. Pruning removes
+		* deleted sessions wherever they sit and re-points the cursor onto the same
+		* logical position.
+		*/
+		var SelectionHistory = class {
+			limit;
+			/** Oldest-first; the cursor sits ON the current entry (-1 while empty). */
+			#entries = [];
+			#cursor = -1;
+			constructor(limit = 50) {
+				this.limit = limit;
+			}
+			get entries() {
+				return this.#entries;
+			}
+			get cursor() {
+				return this.#cursor;
+			}
+			/** Whether an older entry exists to go back to. */
+			canBack() {
+				return this.#cursor > 0;
+			}
+			/** Whether a newer entry exists to go forward to. */
+			canForward() {
+				return this.#cursor < this.#entries.length - 1;
+			}
+			/**
+			* Record one selection made outside history navigation.
+			* @param entry - the selection (session, addressed subagent, or clear).
+			*/
+			record(entry) {
+				const current = this.#entries[this.#cursor];
+				if (current !== void 0 && sameSelection(current, entry)) return;
+				this.#entries.length = this.#cursor + 1;
+				this.#entries.push(entry);
+				if (this.#entries.length > this.limit) this.#entries.shift();
+				this.#cursor = this.#entries.length - 1;
+			}
+			/**
+			* Step one entry back.
+			* @returns the entry to replay, or undefined at the oldest bound.
+			*/
+			back() {
+				if (!this.canBack()) return void 0;
+				this.#cursor -= 1;
+				return this.#entries[this.#cursor];
+			}
+			/**
+			* Step one entry forward.
+			* @returns the entry to replay, or undefined at the newest bound.
+			*/
+			forward() {
+				if (!this.canForward()) return void 0;
+				this.#cursor += 1;
+				return this.#entries[this.#cursor];
+			}
+			/**
+			* Drop every entry referencing the removed session wherever it sits,
+			* keeping the cursor on the same logical position.
+			* @param sessionId - the removed session.
+			*/
+			prune(sessionId) {
+				let removedBeforeCursor = 0;
+				for (let index = this.#entries.length - 1; index >= 0; index -= 1) {
+					const entry = this.#entries[index];
+					if (entry === void 0 || entry.sessionId !== sessionId) continue;
+					this.#entries.splice(index, 1);
+					if (index <= this.#cursor) removedBeforeCursor += 1;
+				}
+				this.#cursor -= removedBeforeCursor;
+				if (this.#cursor > this.#entries.length - 1) this.#cursor = this.#entries.length - 1;
+			}
+		};
+		//#endregion
 		//#region lib/types/client/sessions/manager.js
 		function sessionSeqCursor(value) {
 			return value === -1 ? -1 : SessionSeq(value);
@@ -2229,6 +2310,10 @@ window.__ModuleLoader__.load({
 			*/
 			jobsBySession = /* @__PURE__ */ new Map();
 			selected;
+			/** Toolbar back/forward history over selections (session, addressed child, or clear). */
+			selectionHistory = new SelectionHistory();
+			/** While replaying a history entry, the selections it makes must not re-record. */
+			navigatingHistory = false;
 			listSnapshotCache;
 			/** Entry-identity cache (reference stability): list rebuilds reuse the previous entry
 			*  object when every field matches — wire refreshes mint all-new summary objects, so identity
@@ -2246,6 +2331,10 @@ window.__ModuleLoader__.load({
 				this.remote = remote;
 				this.selected = restoredSelection;
 				if (restoredAddress !== void 0) this.addresses.set(restoredAddress.childSessionId, restoredAddress);
+				this.selectionHistory.record(restoredSelection === void 0 ? {} : {
+					sessionId: restoredSelection,
+					...restoredAddress !== void 0 ? { address: restoredAddress } : {}
+				});
 				this.listSnapshotCache = this.buildListSnapshot();
 			}
 			/**
@@ -2259,6 +2348,10 @@ window.__ModuleLoader__.load({
 				this.sessions.get(sessionId)?.configureSubagent(address, address === void 0 ? void 0 : this.catalogs.get(address.parentSessionId)?.parentAvailable);
 				this.selected = sessionId;
 				this.completedNotifications.delete(sessionId);
+				if (!this.navigatingHistory) this.selectionHistory.record(address === void 0 ? { sessionId } : {
+					sessionId,
+					address
+				});
 				this.refreshSubagents(sessionId);
 				this.notifier.notifyNow();
 			}
@@ -2274,14 +2367,69 @@ window.__ModuleLoader__.load({
 				this.sessions.get(address.childSessionId)?.configureSubagent(address, catalog?.parentAvailable);
 				this.selected = address.childSessionId;
 				this.completedNotifications.delete(address.childSessionId);
+				if (!this.navigatingHistory) this.selectionHistory.record({
+					sessionId: address.childSessionId,
+					address
+				});
 				this.refreshSubagents(address.childSessionId);
 				this.notifier.notifyNow();
 			}
 			/** Clear the selection (the layout falls to the no-session view state). */
 			clearSelection() {
 				this.selected = void 0;
+				if (!this.navigatingHistory) this.selectionHistory.record({});
 				this.notifier.notifyNow();
 			}
+			/** Whether an older selection exists to go back to. */
+			canBack() {
+				return this.selectionHistory.canBack();
+			}
+			/** Whether a newer selection exists to go forward to. */
+			canForward() {
+				return this.selectionHistory.canForward();
+			}
+			/**
+			* Select the previous history entry. Unreachable entries (sessions removed
+			* before their prune landed) are pruned and the walk continues to older
+			* entries; the walk stops silently at the oldest bound.
+			*/
+			back() {
+				while (this.selectionHistory.canBack()) {
+					const entry = this.selectionHistory.back();
+					if (entry === void 0) return;
+					if (!this.canReplay(entry)) {
+						if (entry.sessionId !== void 0) this.selectionHistory.prune(entry.sessionId);
+						continue;
+					}
+					this.replaySelection(entry);
+					return;
+				}
+			}
+			/**
+			* Select the next history entry after a back navigation; silently a
+			* no-op at the newest bound.
+			*/
+			forward() {
+				const entry = this.selectionHistory.forward();
+				if (entry === void 0) return;
+				if (this.canReplay(entry)) this.replaySelection(entry);
+				else if (entry.sessionId !== void 0) this.selectionHistory.prune(entry.sessionId);
+			}
+			/** Whether a history entry names a session that is still listed or addressed. */
+			canReplay(entry) {
+				if (entry.sessionId === void 0) return true;
+				return this.summaries.some((summary) => summary.sessionId === entry.sessionId) || this.addresses.has(entry.sessionId);
+			}
+			/** Replay one entry without recording it back into the history. */
+			replaySelection(entry) {
+				this.navigatingHistory = true;
+				try {
+					if (entry.sessionId === void 0) this.clearSelection();
+					else this.select(entry.sessionId);
+				} finally {
+					this.navigatingHistory = false;
+				}
+			}
 			/**
 			* Return the durable catalog address retained for one child.
 			* @param sessionId - possible addressed child id.
@@ -2498,6 +2646,7 @@ window.__ModuleLoader__.load({
 							let summaries = baseline;
 							for (const mutation of mutations) {
 								summaries = applyMutation(summaries, mutation);
+								if (mutation.kind === "remove") this.selectionHistory.prune(mutation.sessionId);
 								this.summaries = summaries;
 								this.syncCompletedNotifications();
 							}
@@ -2638,6 +2787,7 @@ window.__ModuleLoader__.load({
 			recordMutation(mutation) {
 				this.listMutations?.push(mutation);
 				this.summaries = applyMutation(this.summaries, mutation);
+				if (mutation.kind === "remove") this.selectionHistory.prune(mutation.sessionId);
 				this.syncCompletedNotifications();
 				this.notifier.markDirty();
 			}
@@ -3132,6 +3282,22 @@ window.__ModuleLoader__.load({
 			clear() {
 				this.manager.clearSelection();
 			}
+			/** Whether the transient selection history has an older entry to go back to. */
+			canBack() {
+				return this.manager.canBack();
+			}
+			/** Whether the transient selection history has a newer entry to go forward to. */
+			canForward() {
+				return this.manager.canForward();
+			}
+			/** Select the previous history entry (prunes unreachable entries on the way). */
+			back() {
+				this.manager.back();
+			}
+			/** Select the next history entry after a back navigation. */
+			forward() {
+				this.manager.forward();
+			}
 			/**
 			* Refresh the real Session baseline, reusing an in-flight pull.
 			* @returns completion of the current or newly started baseline pull.

package/lib/types/client/contract/sessions.d.ts

@@ -65,6 +65,18 @@ export interface ISessions {
     refreshSubagents(parentSessionId: SessionId): Promise<void>;
     /** Clear the current selection into the no-session view state. */
     clear(): void;
+    /** Whether the transient selection history has an older entry to go back to. */
+    canBack(): boolean;
+    /** Whether the transient selection history has a newer entry to go forward to. */
+    canForward(): boolean;
+    /**
+     * Select the previous history entry (bounded, consecutive repeats
+     * collapsed, forward truncated by a fresh selection, removed sessions
+     * pruned). The cleared no-session state participates as an entry.
+     */
+    back(): void;
+    /** Select the next history entry after a back navigation. */
+    forward(): void;
     /**
      * Refresh the Host-authoritative Session list.
      * @returns completion of the current or newly started Session-list refresh.

package/lib/types/client/sessions/manager.d.ts

@@ -84,6 +84,10 @@ export declare class SessionManager {
      */
     private readonly jobsBySession;
     private selected;
+    /** Toolbar back/forward history over selections (session, addressed child, or clear). */
+    private readonly selectionHistory;
+    /** While replaying a history entry, the selections it makes must not re-record. */
+    private navigatingHistory;
     private listSnapshotCache;
     /** Entry-identity cache (reference stability): list rebuilds reuse the previous entry
      *  object when every field matches — wire refreshes mint all-new summary objects, so identity
@@ -108,6 +112,25 @@ export declare class SessionManager {
     selectSubagent(address: SubagentAddress): void;
     /** Clear the selection (the layout falls to the no-session view state). */
     clearSelection(): void;
+    /** Whether an older selection exists to go back to. */
+    canBack(): boolean;
+    /** Whether a newer selection exists to go forward to. */
+    canForward(): boolean;
+    /**
+     * Select the previous history entry. Unreachable entries (sessions removed
+     * before their prune landed) are pruned and the walk continues to older
+     * entries; the walk stops silently at the oldest bound.
+     */
+    back(): void;
+    /**
+     * Select the next history entry after a back navigation; silently a
+     * no-op at the newest bound.
+     */
+    forward(): void;
+    /** Whether a history entry names a session that is still listed or addressed. */
+    private canReplay;
+    /** Replay one entry without recording it back into the history. */
+    private replaySelection;
     /**
      * Return the durable catalog address retained for one child.
      * @param sessionId - possible addressed child id.

package/lib/types/client/sessions/manager.js

@@ -8,6 +8,7 @@ import { flattenLineage } from "./lineage.js";
 import { Notifier } from "./notifier.js";
 import { ProjectionValueStore } from "./projection-store.js";
 import { Session } from "./session.js";
+import { SelectionHistory } from "./selection-history.js";
 function sessionSeqCursor(value) {
     return value === -1 ? -1 : SessionSeq(value);
 }
@@ -57,6 +58,10 @@ export class SessionManager {
      */
     jobsBySession = new Map();
     selected;
+    /** Toolbar back/forward history over selections (session, addressed child, or clear). */
+    selectionHistory = new SelectionHistory();
+    /** While replaying a history entry, the selections it makes must not re-record. */
+    navigatingHistory = false;
     listSnapshotCache;
     /** Entry-identity cache (reference stability): list rebuilds reuse the previous entry
      *  object when every field matches — wire refreshes mint all-new summary objects, so identity
@@ -75,6 +80,11 @@ export class SessionManager {
         this.selected = restoredSelection;
         if (restoredAddress !== undefined)
             this.addresses.set(restoredAddress.childSessionId, restoredAddress);
+        // The restored selection seeds the history so back/forward always has a
+        // home position; a cold start without one records the cleared state.
+        this.selectionHistory.record(restoredSelection === undefined
+            ? {}
+            : { sessionId: restoredSelection, ...(restoredAddress !== undefined ? { address: restoredAddress } : {}) });
         this.listSnapshotCache = this.buildListSnapshot();
     }
     // ---- Selection ----
@@ -95,6 +105,8 @@ export class SessionManager {
         this.selected = sessionId;
         // Looking at the session consumes its completion reminder (dot clears).
         this.completedNotifications.delete(sessionId);
+        if (!this.navigatingHistory)
+            this.selectionHistory.record(address === undefined ? { sessionId } : { sessionId, address });
         void this.refreshSubagents(sessionId);
         this.notifier.notifyNow();
     }
@@ -112,14 +124,79 @@ export class SessionManager {
         this.sessions.get(address.childSessionId)?.configureSubagent(address, catalog?.parentAvailable);
         this.selected = address.childSessionId;
         this.completedNotifications.delete(address.childSessionId);
+        if (!this.navigatingHistory)
+            this.selectionHistory.record({ sessionId: address.childSessionId, address });
         void this.refreshSubagents(address.childSessionId);
         this.notifier.notifyNow();
     }
     /** Clear the selection (the layout falls to the no-session view state). */
     clearSelection() {
         this.selected = undefined;
+        if (!this.navigatingHistory)
+            this.selectionHistory.record({});
         this.notifier.notifyNow();
     }
+    // ---- Selection history (toolbar back/forward) ----
+    /** Whether an older selection exists to go back to. */
+    canBack() {
+        return this.selectionHistory.canBack();
+    }
+    /** Whether a newer selection exists to go forward to. */
+    canForward() {
+        return this.selectionHistory.canForward();
+    }
+    /**
+     * Select the previous history entry. Unreachable entries (sessions removed
+     * before their prune landed) are pruned and the walk continues to older
+     * entries; the walk stops silently at the oldest bound.
+     */
+    back() {
+        while (this.selectionHistory.canBack()) {
+            const entry = this.selectionHistory.back();
+            if (entry === undefined)
+                return;
+            if (!this.canReplay(entry)) {
+                if (entry.sessionId !== undefined)
+                    this.selectionHistory.prune(entry.sessionId);
+                continue;
+            }
+            this.replaySelection(entry);
+            return;
+        }
+    }
+    /**
+     * Select the next history entry after a back navigation; silently a
+     * no-op at the newest bound.
+     */
+    forward() {
+        const entry = this.selectionHistory.forward();
+        if (entry === undefined)
+            return;
+        if (this.canReplay(entry))
+            this.replaySelection(entry);
+        else if (entry.sessionId !== undefined)
+            this.selectionHistory.prune(entry.sessionId);
+    }
+    /** Whether a history entry names a session that is still listed or addressed. */
+    canReplay(entry) {
+        if (entry.sessionId === undefined)
+            return true;
+        return this.summaries.some(summary => summary.sessionId === entry.sessionId)
+            || this.addresses.has(entry.sessionId);
+    }
+    /** Replay one entry without recording it back into the history. */
+    replaySelection(entry) {
+        this.navigatingHistory = true;
+        try {
+            if (entry.sessionId === undefined)
+                this.clearSelection();
+            else
+                this.select(entry.sessionId);
+        }
+        finally {
+            this.navigatingHistory = false;
+        }
+    }
     /**
      * Return the durable catalog address retained for one child.
      * @param sessionId - possible addressed child id.
@@ -379,6 +456,8 @@ export class SessionManager {
                     let summaries = baseline;
                     for (const mutation of mutations) {
                         summaries = applyMutation(summaries, mutation);
+                        if (mutation.kind === 'remove')
+                            this.selectionHistory.prune(mutation.sessionId);
                         this.summaries = summaries;
                         this.syncCompletedNotifications();
                     }
@@ -524,6 +603,9 @@ export class SessionManager {
     recordMutation(mutation) {
         this.listMutations?.push(mutation);
         this.summaries = applyMutation(this.summaries, mutation);
+        // A removal forgets the session's toolbar back/forward history entries.
+        if (mutation.kind === 'remove')
+            this.selectionHistory.prune(mutation.sessionId);
         // Eager edge reconciliation — a snapshot-build-time pass would miss consecutive status frames.
         this.syncCompletedNotifications();
         this.notifier.markDirty();

package/lib/types/client/sessions/selection-history.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Bounded transient selection history behind the desktop toolbar's
+ * back/forward navigation. Entries record WHICH selection was made — a
+ * listed session, an addressed subagent, or the cleared no-session state —
+ * never when, and never any session content. Browser-local and transient by
+ * design: nothing here is persisted, so a reload starts empty.
+ */
+import type { SessionId } from '@deepseek-ai/dsh-session/types';
+import type { SubagentAddress } from '@deepseek-ai/dsh-subagent/client';
+/** One selection-history entry; `sessionId: undefined` is the cleared state. */
+export interface SelectionEntry {
+    readonly sessionId?: SessionId;
+    /** Retained direct-parent address for an addressed subagent selection. */
+    readonly address?: SubagentAddress;
+}
+/**
+ * Bounded LIFO-with-cursor history. Recording a selection made outside
+ * navigation collapses consecutive repeats, truncates the forward tail after
+ * a backtrack, and drops the oldest entry past the bound. Pruning removes
+ * deleted sessions wherever they sit and re-points the cursor onto the same
+ * logical position.
+ */
+export declare class SelectionHistory {
+    #private;
+    private readonly limit;
+    constructor(limit?: number);
+    get entries(): readonly SelectionEntry[];
+    get cursor(): number;
+    /** Whether an older entry exists to go back to. */
+    canBack(): boolean;
+    /** Whether a newer entry exists to go forward to. */
+    canForward(): boolean;
+    /**
+     * Record one selection made outside history navigation.
+     * @param entry - the selection (session, addressed subagent, or clear).
+     */
+    record(entry: SelectionEntry): void;
+    /**
+     * Step one entry back.
+     * @returns the entry to replay, or undefined at the oldest bound.
+     */
+    back(): SelectionEntry | undefined;
+    /**
+     * Step one entry forward.
+     * @returns the entry to replay, or undefined at the newest bound.
+     */
+    forward(): SelectionEntry | undefined;
+    /**
+     * Drop every entry referencing the removed session wherever it sits,
+     * keeping the cursor on the same logical position.
+     * @param sessionId - the removed session.
+     */
+    prune(sessionId: SessionId): void;
+}
+//# sourceMappingURL=selection-history.d.ts.map

package/lib/types/client/sessions/selection-history.js

@@ -0,0 +1,91 @@
+function sameSelection(left, right) {
+    return left.sessionId === right.sessionId
+        && left.address?.parentSessionId === right.address?.parentSessionId
+        && left.address?.childSessionId === right.address?.childSessionId;
+}
+/**
+ * Bounded LIFO-with-cursor history. Recording a selection made outside
+ * navigation collapses consecutive repeats, truncates the forward tail after
+ * a backtrack, and drops the oldest entry past the bound. Pruning removes
+ * deleted sessions wherever they sit and re-points the cursor onto the same
+ * logical position.
+ */
+export class SelectionHistory {
+    limit;
+    /** Oldest-first; the cursor sits ON the current entry (-1 while empty). */
+    #entries = [];
+    #cursor = -1;
+    constructor(limit = 50) {
+        this.limit = limit;
+    }
+    get entries() {
+        return this.#entries;
+    }
+    get cursor() {
+        return this.#cursor;
+    }
+    /** Whether an older entry exists to go back to. */
+    canBack() {
+        return this.#cursor > 0;
+    }
+    /** Whether a newer entry exists to go forward to. */
+    canForward() {
+        return this.#cursor < this.#entries.length - 1;
+    }
+    /**
+     * Record one selection made outside history navigation.
+     * @param entry - the selection (session, addressed subagent, or clear).
+     */
+    record(entry) {
+        const current = this.#entries[this.#cursor];
+        if (current !== undefined && sameSelection(current, entry))
+            return;
+        this.#entries.length = this.#cursor + 1;
+        this.#entries.push(entry);
+        if (this.#entries.length > this.limit)
+            this.#entries.shift();
+        this.#cursor = this.#entries.length - 1;
+    }
+    /**
+     * Step one entry back.
+     * @returns the entry to replay, or undefined at the oldest bound.
+     */
+    back() {
+        if (!this.canBack())
+            return undefined;
+        this.#cursor -= 1;
+        const entry = this.#entries[this.#cursor];
+        return entry;
+    }
+    /**
+     * Step one entry forward.
+     * @returns the entry to replay, or undefined at the newest bound.
+     */
+    forward() {
+        if (!this.canForward())
+            return undefined;
+        this.#cursor += 1;
+        const entry = this.#entries[this.#cursor];
+        return entry;
+    }
+    /**
+     * Drop every entry referencing the removed session wherever it sits,
+     * keeping the cursor on the same logical position.
+     * @param sessionId - the removed session.
+     */
+    prune(sessionId) {
+        let removedBeforeCursor = 0;
+        for (let index = this.#entries.length - 1; index >= 0; index -= 1) {
+            const entry = this.#entries[index];
+            if (entry === undefined || entry.sessionId !== sessionId)
+                continue;
+            this.#entries.splice(index, 1);
+            if (index <= this.#cursor)
+                removedBeforeCursor += 1;
+        }
+        this.#cursor -= removedBeforeCursor;
+        if (this.#cursor > this.#entries.length - 1)
+            this.#cursor = this.#entries.length - 1;
+    }
+}
+//# sourceMappingURL=selection-history.js.map

package/lib/types/client/sessions/service.d.ts

@@ -185,6 +185,14 @@ export declare class ClientSessions implements ISessions {
      * per the masked-gap contract until the next open() moves the stage.
      */
     clear(): void;
+    /** Whether the transient selection history has an older entry to go back to. */
+    canBack(): boolean;
+    /** Whether the transient selection history has a newer entry to go forward to. */
+    canForward(): boolean;
+    /** Select the previous history entry (prunes unreachable entries on the way). */
+    back(): void;
+    /** Select the next history entry after a back navigation. */
+    forward(): void;
     /**
      * Refresh the real Session baseline, reusing an in-flight pull.
      * @returns completion of the current or newly started baseline pull.

package/lib/types/client/sessions/service.js

@@ -193,6 +193,22 @@ export class ClientSessions {
     clear() {
         this.manager.clearSelection();
     }
+    /** Whether the transient selection history has an older entry to go back to. */
+    canBack() {
+        return this.manager.canBack();
+    }
+    /** Whether the transient selection history has a newer entry to go forward to. */
+    canForward() {
+        return this.manager.canForward();
+    }
+    /** Select the previous history entry (prunes unreachable entries on the way). */
+    back() {
+        this.manager.back();
+    }
+    /** Select the next history entry after a back navigation. */
+    forward() {
+        this.manager.forward();
+    }
     /**
      * Refresh the real Session baseline, reusing an in-flight pull.
      * @returns completion of the current or newly started baseline pull.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@crazx/dsh-api-session-controller",
   "description": "Session Remote commands, cold reads, and live control transport",
-  "version": "0.1.5-alpha.1.zw.1",
+  "version": "0.1.5-alpha.1.zw.3",
   "publishConfig": {
     "access": "public"
   },
@@ -73,7 +73,7 @@
   "peerDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-agent": "^0.1.5-alpha.1",
-    "@deepseek-ai/dsh-agent-default-model": "0.1.5-alpha.1.zw.1",
+    "@deepseek-ai/dsh-agent-default-model": "npm:@crazx/dsh-agent-default-model@0.1.5-alpha.1.zw.3",
     "@deepseek-ai/dsh-agent-presets": "^0.1.5-alpha.1",
     "@deepseek-ai/dsh-api-gateway": "^0.1.5-alpha.1",
     "@deepseek-ai/dsh-attachment": "^0.1.5-alpha.1",
@@ -115,7 +115,7 @@
   "devDependencies": {
     "@deepseek-ai/cordis": "^4.0.2",
     "@deepseek-ai/dsh-agent": "^0.1.5-alpha.1",
-    "@deepseek-ai/dsh-agent-default-model": "npm:@crazx/dsh-agent-default-model@0.1.5-alpha.1.zw.1",
+    "@deepseek-ai/dsh-agent-default-model": "npm:@crazx/dsh-agent-default-model@0.1.5-alpha.1.zw.3",
     "@deepseek-ai/dsh-agent-loop": "^0.1.5-alpha.1",
     "@deepseek-ai/dsh-agent-loop-testkit": "^0.1.5-alpha.1",
     "@deepseek-ai/dsh-agent-presets": "^0.1.5-alpha.1",