dsh-loadout 0.12.6 → 0.13.0

package/index.js

@@ -189,6 +189,15 @@ function normalizeStore(value) {
     kits: normalizeKits(value.kits),
     defaultKit: typeof value.defaultKit === 'string' ? value.defaultKit.trim() : '',
     assignments: normalizeAssignments(value.assignments),
+    // A pick made in a conversation that has not started yet. Persisted on
+    // purpose: the marker has to survive a restart, or the next visit reads the
+    // binding as "this conversation was switched" and the default never wins.
+    drafts: normalizeAssignments(value.drafts),
+    // Sessions whose binding was not chosen but handed to them by the default
+    // kit at creation. They follow the default until their first turn; an
+    // explicit pick deletes the flag. Persisted for the same reason drafts are:
+    // a restart must not turn "the default I happened to have" into a decision.
+    auto: normalizeAuto(value.auto),
     migratedAt: typeof value.migratedAt === 'string' && !Number.isNaN(Date.parse(value.migratedAt))
       ? value.migratedAt
       : undefined,
@@ -211,8 +220,21 @@ function normalizeAssignments(value) {
   return out
 }
 
-function readStore() {
-  // New file first, then the pre-0.5 copy: a rename must not silently drop the
+/**
+ * Sessions whose binding came from the default kit rather than from a pick.
+ * Stored as `{ [sessionId]: true }`; anything but `true` is ignored, so a
+ * half-written file can only lose the flag, never invent one.
+ */
+function normalizeAuto(value) {
+  const out = {}
+  if (typeof value !== 'object' || value === null || Array.isArray(value)) return out
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof key === 'string' && key !== '' && entry === true) out[key] = true
+  }
+  return out
+}
+
+function readStore() {  // New file first, then the pre-0.5 copy: a rename must not silently drop the
   // kits someone already saved. The legacy file is never written again, so the
   // next save moves the store forward for good.
   for (const path of [STORE_PATH, LEGACY_STORE_PATH]) {
@@ -330,6 +352,8 @@ export function apply(ctx, config = {}) {
     kits: migrateUserKits(loaded?.store.kits ?? [], presets),
     defaultKit: loaded?.store.defaultKit ?? (typeof config?.defaultKit === 'string' ? config.defaultKit.trim() : ''),
     assignments: loaded?.store.assignments ?? {},
+    drafts: loaded?.store.drafts ?? {},
+    auto: loaded?.store.auto ?? {},
     migratedAt: loaded?.store.migratedAt,
     // The file the kits actually came from: the legacy path on the first boot
     // after the rename, the new one afterwards.
@@ -354,6 +378,11 @@ export function apply(ctx, config = {}) {
       })),
       defaultKit: book.defaultKit,
       assignments: book.assignments,
+      // Only non-empty while some conversation is still waiting for its first
+      // message; a started conversation drops its entry.
+      ...(Object.keys(book.drafts).length === 0 ? {} : { drafts: book.drafts }),
+      // Same rule: only conversations that have not run a turn yet carry this.
+      ...(Object.keys(book.auto).length === 0 ? {} : { auto: book.auto }),
       ...(book.migratedAt === undefined ? {} : { migratedAt: book.migratedAt }),
     })
     // `source` answers "where do the user's kits live". Writing assignments or a
@@ -478,6 +507,12 @@ export function apply(ctx, config = {}) {
    * parentSession / origin). Optional for the same reason as sessionController.
    */
   let sessions
+  /**
+   * The session-projection registry, read only for `contextPressure`: how big
+   * this conversation's prompt is right now. Optional — a host without the
+   * token meter simply shows no price estimate.
+   */
+  let sessionProjections
   let lastAgent
   /** Every tool name this profile can expose; filled by learnTools below. */
   const knownTools = new Set(OWN_TOOLS)
@@ -514,6 +549,40 @@ export function apply(ctx, config = {}) {
     }
   }
 
+  /**
+   * How large this conversation's prompt is right now, in tokens — the part a
+   * kit switch makes the provider bill again at the miss price.
+   *
+   * Read from the `contextPressure` session projection: the provider-reported
+   * prompt size of the last request, plus whatever the surface has grown by
+   * since that sample. O(1), no model call, and the same number the client
+   * shows as occupancy. `tokens: null` before the first request — which is
+   * exactly when a switch costs nothing.
+   */
+  function contextOf(agent) {
+    const sessionId = sessionIdOf(agent)
+    if (sessionId === undefined || sessionProjections === undefined || sessions === undefined) {
+      return { tokens: null }
+    }
+    try {
+      const session = sessions.get?.(sessionId)
+      if (session === undefined || session === null) return { tokens: null }
+      const { values } = sessionProjections.snapshot(session, ['contextPressure'])
+      const pressure = values?.contextPressure
+      const tokens = pressure?.projectedTokens ?? pressure?.pressureTokens
+      if (typeof tokens !== 'number' || !Number.isFinite(tokens) || tokens <= 0) {
+        return { tokens: null, window: pressure?.contextWindow ?? null }
+      }
+      return {
+        tokens: Math.round(tokens),
+        window: typeof pressure?.contextWindow === 'number' ? pressure.contextWindow : null,
+      }
+    } catch {
+      // The registry is optional; a host without it just has no number to show.
+      return { tokens: null }
+    }
+  }
+
   /** `hasOwnProperty`, because a stored `null` (全部) is a real answer. */
   function bindingOf(sessionId) {
     if (typeof sessionId !== 'string') return undefined
@@ -564,12 +633,20 @@ export function apply(ctx, config = {}) {
     const header = sessionHeaderOf(sessionId)
     if (header?.origin === 'subagent') return undefined
     let value
+    let fromDefault = false
     const parentBinding = header?.parentSession === undefined ? undefined : bindingOf(header.parentSession)
     if (parentBinding !== undefined) value = parentBinding
     else if (book.migratedAt !== undefined && typeof header?.createdAt === 'number'
       && header.createdAt < Date.parse(book.migratedAt)) value = null
-    else value = defaultBinding()
+    else {
+      value = defaultBinding()
+      fromDefault = true
+    }
     book.assignments[sessionId] = value
+    // Not the user's pick: remember who handed this conversation its kit, so a
+    // later default change can move it. The first turn (or an explicit pick)
+    // drops the flag and the binding becomes this conversation's own.
+    if (fromDefault) book.auto[sessionId] = true
     save()
     return value
   }
@@ -1045,6 +1122,8 @@ export function apply(ctx, config = {}) {
       const next = bindingForSelection(normalized)
       if (bindingOf(sessionId) !== next) {
         book.assignments[sessionId] = next
+        // Switched here, so this conversation stops following the default.
+        delete book.auto[sessionId]
         save()
       }
     }
@@ -1203,6 +1282,31 @@ export function apply(ctx, config = {}) {
     if (typeof retry?.unref === 'function') retry.unref()
   })
 
+  try {
+    // A draft pick stops being a draft as soon as the conversation runs a turn:
+    // from then on it is this conversation's kit, like any explicit switch. A
+    // conversation that is disposed without ever running one takes its draft
+    // with it. The marker is persisted (`book.drafts`), so a restart between the
+    // pick and the first message does not turn it into a permanent binding.
+    const dropDraft = (id) => {
+      if (typeof id !== 'string') return
+      // The first turn ends the grace period for both markers: the pick is now
+      // this conversation's kit, and so is a default it was handed at creation.
+      const hadDraft = Object.prototype.hasOwnProperty.call(book.drafts, id)
+      const borrowed = book.auto[id] === true
+      if (!hadDraft && !borrowed) return
+      if (hadDraft) delete book.drafts[id]
+      if (borrowed) delete book.auto[id]
+      save()
+    }
+    ctx.on('session/event', (session, event) => {
+      if (event?.type === 'turn/end') dropDraft(session?.id)
+    })
+    ctx.on('session/disposed', (session) => dropDraft(session?.id))
+  } catch {
+    // An older host without these events still works; drafts just live longer.
+  }
+
   try {
     ctx.effect(() => () => {
       for (const [, entry] of state) {
@@ -1454,6 +1558,16 @@ export function apply(ctx, config = {}) {
     // larger than the whole tool table.
     const surface = new Set(visibleNamesFor(agent?.ctx?.tools, agent) ?? [])
     const universe = surface.size > 0 ? surface : catalogue
+    // What each of the two base rows would put in the prompt. Without this the
+    // menu can only price a switch by context length, which is the same number
+    // on every row and therefore says nothing about the row; the tool-table size
+    // is what actually differs between 全部 / 仅内置 / each kit.
+    const baseTokens = index.size === 0
+      ? undefined
+      : {
+        all: ledger?.totalTokens ?? tokensForNames([...catalogue].filter((name) => universe.has(name)), index),
+        dsh: tokensForNames(catalog.builtins.filter((name) => universe.has(name)), index),
+      }
     const priced = (row) => {
       if (index.size === 0) return row
       const names = asNames(row.allow ?? row.builtins).filter((name) => universe.has(name))
@@ -1471,6 +1585,17 @@ export function apply(ctx, config = {}) {
       // '' when the conversation has none (a subagent). The chip reads this
       // instead of inferring "no kit" from the live label.
       binding: bindingOf(sessionIdOf(agent)) ?? '',
+      // `binding` cannot tell "chose 全部" from "has not chosen yet" (both read
+      // as ''); the new-conversation picker shows the default kit until one is
+      // chosen, so the distinction has to travel with the snapshot. A binding
+      // that came from the default is not a choice either — the picker has to
+      // keep following the default for it.
+      bound: bindingOf(sessionIdOf(agent)) !== undefined && book.auto[sessionIdOf(agent)] !== true,
+      // Prompt size, so the chip can price a switch without guessing: swapping
+      // the kit rewrites the tool definitions, and every token after them is
+      // billed again at the miss price.
+      context: contextOf(agent),
+      baseTokens,
       ledger,
       catalog,
       tools: toolCatalog(),
@@ -1628,6 +1753,12 @@ export function apply(ctx, config = {}) {
       const kit = resolveKit(lastAgent, wanted)
       if (kit === undefined) throw new Error(`未知套装 "${wanted}"`)
       book.defaultKit = kit.name
+      // No conversation is touched here, not even one that is still blank: the
+      // default is a rule for conversations that have not been created yet. A
+      // conversation that borrowed the old default is repointed by the welcome
+      // screen itself (it can see the mismatch and ask for the new one), which
+      // keeps "changing the default never rewrites a conversation" true for
+      // every caller, including the tool.
       save()
       return { defaultKit: book.defaultKit }
     },
@@ -1903,6 +2034,7 @@ export function apply(ctx, config = {}) {
         value = kit.name
       }
       book.assignments[sessionId] = value
+      delete book.auto[sessionId]
       save()
       // Apply it live when that conversation is still open; otherwise the pin is
       // picked up the next time the conversation is read.
@@ -2016,7 +2148,23 @@ export function apply(ctx, config = {}) {
             // and an unknown id still answer from the last agent seen.
             const sessionId = new URL(req.url ?? '', 'http://localhost').searchParams.get('sessionId') ?? ''
             const found = await agentForSession(sessionId)
-            return sendJson(res, 200, { ok: true, ...(found.ok ? snapshot(found.agent) : snapshot()) })
+            const view = found.ok ? { live: true, ...snapshot(found.agent) } : { live: false, ...snapshot() }
+            // A conversation that has not sent a message yet may have no agent; its
+            // binding is still readable by Session id, which is what lets the
+            // new-conversation picker show the kit this conversation will start with.
+            // These three are per-Session facts, so they are answered for the id the
+            // caller named — not for whichever agent happened to be resolved.
+            if (sessionId !== '') {
+              view.binding = bindingOf(sessionId) ?? ''
+              // "Chose 全部" and "never chose" both read as an empty binding, and
+              // they mean different kits to show in the picker.
+              view.bound = bindingOf(sessionId) !== undefined && book.auto[sessionId] !== true
+              // `draft` says the pick was made on a screen that never started, so
+              // the next visit drops it instead of inheriting it. It is read from
+              // the store, so a restart cannot turn a draft into a decision.
+              view.draft = Object.prototype.hasOwnProperty.call(book.drafts, sessionId)
+            }
+            return sendJson(res, 200, { ok: true, ...view })
           }
           if (req.method !== 'POST') return sendJson(res, 405, { ok: false, error: '只支持 GET/POST' })
           const body = await readJson(req)
@@ -2083,6 +2231,67 @@ export function apply(ctx, config = {}) {
               if (!result.ok) return sendJson(res, 400, { ok: false, error: result.reason })
               return sendJson(res, 200, { ok: true, kit: kit.name, ...snapshot(found.agent) })
             }
+            case 'bind': {
+              // A conversation that has not sent anything may have no agent yet, so
+              // there is nothing to switch — but the binding is keyed by Session id,
+              // so the pick can be recorded now and installed the moment the agent
+              // exists. That happens before the first request builds a prompt, which
+              // is why this pick costs nothing (no cache reset).
+              const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
+              if (sessionId === '') return sendJson(res, 400, { ok: false, error: '缺少会话 id' })
+              const wanted = typeof body.name === 'string' ? body.name.trim() : ''
+              const value = wanted === '' ? null : wanted
+              if (value !== null && value !== DEFAULT_DSH && resolveKit(lastAgent, value) === undefined) {
+                return sendJson(res, 404, { ok: false, error: `没有套装「${value}」` })
+              }
+              book.assignments[sessionId] = value
+              if (body.follow === true) {
+                // "Catch up with the default", not a pick: the welcome screen uses
+                // this when the conversation still holds the kit a previous
+                // default gave it. No draft, and the auto flag stays, so a later
+                // default change moves it again.
+                book.auto[sessionId] = true
+                delete book.drafts[sessionId]
+                save()
+                const follow = await agentForSession(sessionId)
+                if (!follow.ok) return sendJson(res, 200, { ok: true, ...snapshot(), binding: value ?? '', bound: false, draft: false })
+                rememberAgent(follow.agent)
+                return sendJson(res, 200, { ok: true, ...snapshot(follow.agent), bound: false, draft: false })
+              }
+              // An explicit pick stops following the default.
+              delete book.auto[sessionId]
+              // Remember that this was a welcome-screen pick, so the next visit
+              // can drop it again unless the conversation has actually started.
+              // Persisted: a restart must not launder a draft into a decision.
+              book.drafts[sessionId] = value
+              save()
+              // With an agent this applies right away; without one the reply still
+              // carries the stored binding, which is all the picker needs to show.
+              const bound = await agentForSession(sessionId)
+              if (!bound.ok) return sendJson(res, 200, { ok: true, ...snapshot(), binding: value ?? '', bound: true, draft: true })
+              rememberAgent(bound.agent)
+              // `bound` tells the picker that an empty binding was a choice, not
+              // the absence of one — the same distinction the GET branch makes.
+              return sendJson(res, 200, { ok: true, ...snapshot(bound.agent), bound: true, draft: true })
+            }
+            case 'release': {
+              // The user came back to a welcome screen carrying a draft pick from
+              // a previous visit. A draft that was never sent is not a decision:
+              // drop it so the screen looks untouched, exactly like the host
+              // resetting its own mode.
+              const sessionId = typeof body.sessionId === 'string' ? body.sessionId : ''
+              if (sessionId === '') return sendJson(res, 400, { ok: false, error: '缺少会话 id' })
+              const hadDraft = Object.prototype.hasOwnProperty.call(book.drafts, sessionId)
+              if (!hadDraft) {
+                const boundHere = bindingOf(sessionId) !== undefined && book.auto[sessionId] !== true
+                return sendJson(res, 200, { ok: true, ...snapshot(), binding: bindingOf(sessionId) ?? '', bound: boundHere, live: false })
+              }
+              delete book.drafts[sessionId]
+              delete book.assignments[sessionId]
+              delete book.auto[sessionId]
+              save()
+              return sendJson(res, 200, { ok: true, ...snapshot(), binding: '', bound: false, live: false, draft: false })
+            }
             case 'create': operations.create(body); break
             case 'update': operations.update(body); break
             case 'delete':
@@ -2211,6 +2420,9 @@ export function apply(ctx, config = {}) {
   optional(['sessions'], (child) => {
     sessions = child.sessions
   })
+  optional(['sessionProjections'], (child) => {
+    sessionProjections = child.sessionProjections
+  })
 
   ctx.logger?.info(`dsh-loadout: ${book.kits.length} 个我的套装 + ${presets.length} 个预设，默认 ${book.defaultKit || '(未设置)'}，来源 ${book.source}`)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-loadout",
-  "version": "0.12.6",
+  "version": "0.13.0",
   "description": "Loadout for DeepSeek Harness: group tools into kits, keep only the current kit's tools visible in each conversation, and manage everything from a settings panel.",
   "type": "module",
   "main": "./index.js",
@@ -60,7 +60,8 @@
       "inject": [
         "@deepseek-ai/dsh-client-locale",
         "@deepseek-ai/dsh-client-ui-slots",
-        "@deepseek-ai/dsh-client-ui-settings"
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-conversation"
       ]
     },
     "manifestVersion": 1