@vincemakes/kiso-code 0.40.0 → 0.40.1

package/dist/chat.d.ts

@@ -309,6 +309,7 @@ export type ChatEnd = {
 } | {
     readonly next: "switch";
     readonly id: string;
+    readonly lines?: readonly string[];
 }
 /** §2.5: the caller REBUILDS the agent and re-enters on the same id.
  *  Not "switch": switching keeps the agent and only changes the id,
@@ -317,6 +318,7 @@ export type ChatEnd = {
  | {
     readonly next: "reload";
     readonly id: string;
+    readonly lines?: readonly string[];
 };
 /** The session-navigation seam main provides: the OTHER sessions'
  *  ids, and (when a dock is up) the existing picker. */
@@ -326,4 +328,4 @@ export interface ChatNav {
     readonly route?: (id: string) => SessionRoute | null;
     readonly pick?: () => Promise<string | null>;
 }
-export declare function chat(session: AgentSession, faux: boolean, input: LineInput, autoCompact?: AutoCompact, nav?: ChatNav): Promise<ChatEnd>;
+export declare function chat(session: AgentSession, faux: boolean, input: LineInput, autoCompact?: AutoCompact, nav?: ChatNav, seed?: readonly string[]): Promise<ChatEnd>;

package/dist/chat.js

@@ -8,6 +8,7 @@ import { readFileSync, statSync } from "node:fs";
 import { escapeTerminal, cacheHitPct, decodeRate, idleStatus, palette, renderEvent, renderRecap, runningStatus, toolTarget, verifyOfferView, STATUS_GLYPHS, } from "@vincemakes/kiso-tui";
 import { askView, coldResumeLine, coldResumeView, deletionRiskHint, editFileDiff, writeFileDiff } from "@vincemakes/kiso-tui";
 import { canonicalTargetPath, isProtectedPath, protectedIdentity, shellProgressPath } from "@vincemakes/kiso-tools-node";
+import { queuedSwitchLines } from "./state.js";
 import { echoText } from "@vincemakes/kiso-tui-cells/render";
 import { canonicalizeUsage } from "@vincemakes/kiso-runtime";
 import { canonicalizeUsageForModel, requestBudget } from "@vincemakes/kiso-runtime/internal";
@@ -153,6 +154,12 @@ export function estimateCtxRatio(session) {
  *  is the session's own (the durable profile), never the CLI's memory. */
 export function statusModelLabel(session) {
     const effort = session.reasoning?.effort;
+    // The owner's dogfood, 2026-09-21 (the second pass): the status row under
+    // the composer is the MODEL's, and only the model's — a host belongs where
+    // a choice is being made (`/model`'s rows, the switch notice) and where the
+    // identity is asked for (`/status`), not in a row that has ~40 columns and
+    // cut the host to `deepseek/d…ndcode.ai`. Unnecessary at best, misleading at
+    // worst: it read as a path, not as an account.
     return effort !== undefined && effort !== "default" ? `${agentModel} · ${effort}` : agentModel;
 }
 export function displayCtxRatio(session) {
@@ -1164,7 +1171,7 @@ submitTurn) {
     }
     return last;
 }
-export async function chat(session, faux, input, autoCompact, nav) {
+export async function chat(session, faux, input, autoCompact, nav, seed) {
     // the switch directive — set once by dispatch's /clear or /resume,
     // resolved through the end signal so the final awaits still run
     let switchTo = null;
@@ -1379,7 +1386,15 @@ export async function chat(session, faux, input, autoCompact, nav) {
     // REPL is ready (they are never dropped).
     const chainRef = { current: Promise.resolve() };
     let replReady = false;
-    const queuedLines = [];
+    const queuedLines = [...(seed ?? []), ...queuedSwitchLines.splice(0)];
+    // DC-57 (the owner's ruling, 2026-09-21): once the session is LEAVING —
+    // a switch or a reload has been requested — a line that arrives belongs
+    // to the session the person asked for, not to the one they are leaving.
+    // One read can carry several lines (a paste, a pipe, a scripted
+    // driver), and the departing instance used to dispatch them; they are
+    // queued here and replayed by the NEXT chat() entry, exactly as
+    // pre-ready lines are replayed by this one.
+    let leaving = false;
     // B area: user-turn counter for the status line. /last and /think read
     // the body (the ToolCell / ThinkingCell final states).
     let turnNo = 0;
@@ -1565,12 +1580,18 @@ export async function chat(session, faux, input, autoCompact, nav) {
         // the /resume+/clear mini-spec: the switch directive and the
         // session-navigation seam (absent nav = the commands degrade to
         // an honest refusal in dispatch)
+        // DC-57: the dispatch edge asks this before it answers a line, so the
+        // decision is made when the line's segment runs — not when its bytes
+        // arrived, which can be before the switch was even requested.
+        leaving: () => leaving,
         requestSwitch: (id) => {
             switchTo = id;
+            leaving = true;
             resolveEnd();
         },
         requestReload: () => {
             reloadReq = true;
+            leaving = true;
             resolveEnd();
         },
         sessions: () => nav?.sessions() ?? [],
@@ -1603,7 +1624,7 @@ export async function chat(session, faux, input, autoCompact, nav) {
             dispatch(line, dispatchCtx);
     };
     input.onLine((line) => {
-        if (!replReady) {
+        if (!replReady || leaving) {
             queuedLines.push(line);
             return;
         }
@@ -1708,8 +1729,8 @@ export async function chat(session, faux, input, autoCompact, nav) {
     // enough: the /compact segment appends nothing of its own.
     await chainRef.current;
     if (switchTo !== null)
-        return { next: "switch", id: switchTo };
+        return { next: "switch", id: switchTo, lines: queuedLines.slice() };
     // a switch beats a reload: /resume and /clear are going somewhere else,
     // and the agent they land on is rebuilt by the caller either way.
-    return reloadReq ? { next: "reload", id: session.id } : { next: "exit" };
+    return reloadReq ? { next: "reload", id: session.id, lines: queuedLines.slice() } : { next: "exit" };
 }

package/dist/dispatch.d.ts

@@ -37,6 +37,8 @@ export interface DispatchCtx {
     /** the /resume+/clear mini-spec: end this chat() with a switch to
      *  another session — main re-enters chat there; the editor survives. */
     readonly requestSwitch: (id: string) => void;
+    /** DC-57: true once this entry has been asked to leave — the guard that keeps a departing session from answering a batch's later lines. */
+    readonly leaving: () => boolean;
     /** §2.5: end this chat() with a REBUILD of the agent on the SAME
      *  session — extensions, skills and config are read again. */
     readonly requestReload: () => void;

package/dist/dispatch.js

@@ -9,8 +9,10 @@ import { buildAdapter, lookupModelMetadata, resolveContinuationScope, resolveRea
 import { MODES, MODE_NOTE, OFFERED_MODES, getMode, setMode } from "./mode.js";
 import { clipboardWrite, lastAnswer } from "./clipboard.js";
 import { protectedBangReason, protectedShellVerdict } from "./protected-shell.js";
-import { agentModel, body, bodyLog, codingToolOptions, protectedFiles, kisoHome, configModels, dock, lastBinding, loadedSkillsCatalog, mergedConfig, readContextLedger, retryOnRow, sessionsDir, setAgentModel, setConfiguredWindow, setCurrentModelName, setModelChoice, setRetryShown, setLastBinding } from "./state.js";
+import { agentBaseUrl, currentProfileName, setCurrentProfileName, currentModelName, agentModel, body, bodyLog, codingToolOptions, protectedFiles, kisoHome, configModels, dock, lastBinding, loadedSkillsCatalog, mergedConfig, readContextLedger, retryOnRow, sessionsDir, setAgentModel, setConfiguredWindow, setCurrentModelName, setModelChoice, setRetryShown, setLastBinding } from "./state.js";
 import { adapterOptionsFor } from "./auth/adapter-options.js";
+import { profileProviderLabel, providerLabel } from "./provider-label.js";
+import { queuedSwitchLines } from "./state.js";
 import { contextWindowTokens, microcompactThresholdFor, startStatusSpinner } from "./chat.js";
 import { authForProfile, directWriteProfile, profileAvailable, resolveContextWindow, unavailableReason } from "./config.js";
 import { shellTool } from "@vincemakes/kiso-tools-node";
@@ -190,6 +192,18 @@ function runBang(command, send, ctx) {
     });
 }
 export function dispatch(line, ctx) {
+    // DC-57 (the owner's ruling, 2026-09-21): a session that is LEAVING — a
+    // switch or a reload has been requested from an earlier segment of the
+    // chain — does not answer new lines. They are queued for the session the
+    // person asked for and replayed by its `chat()` entry. The guard lives
+    // HERE, not only at the input edge: a batch that arrived before the
+    // switch was requested still runs its segments after it (the chain is
+    // FIFO), which is exactly how a pasted prompt used to land in the
+    // departing session.
+    if (ctx.leaving()) {
+        queuedSwitchLines.push(line);
+        return;
+    }
     const trimmed = line.trim();
     // §2.2 — the `!` gesture is the COMPOSER's alone. A piped session, `-p`
     // and `--task-file` keep `!` as ordinary text: those lines are content,
@@ -474,6 +488,21 @@ export function dispatch(line, ctx) {
             bodyLog(`session ${ctx.session.id}`);
             bodyLog(`${ctx.session.log.all.length} events`);
             bodyLog(`ctx ${ctxPct}`);
+            // The owner, 2026-09-21: /status is where "what am I actually
+            // running on" is answered, so the identity is spelled out HERE —
+            // the model, the host the request goes to, the profile it came
+            // from and the key it spends. The status row stays short; this
+            // line is the disambiguation two same-named profiles need.
+            //
+            // REVIEW (2026-09-21): the profile is named only when what is in
+            // hand IS a profile key. `currentModelName` holds whatever the
+            // resolution produced — a profile alias after `/model`, a MODEL ID
+            // after a switch or a resume — so printing it unconditionally
+            // claimed `profile deepseek-v4-flash` for a session that was
+            // restored, not switched. (The real fix is to stop overloading that
+            // variable; until then, a label that cannot lie.)
+            const profileOf = currentProfileName === null ? "" : ` · profile ${currentProfileName}`;
+            bodyLog(`model ${agentModel}${providerLabel(agentBaseUrl)}${profileOf}`);
             ctx.input.prompt();
         });
         return;
@@ -567,8 +596,20 @@ export function dispatch(line, ctx) {
                             // the note keeps what tells two rows apart; the levels
                             // left it for the axis below (they were being cut off
                             // the end of the note column at 100 columns).
-                            const marks = [`profile: ${name}`, ...(profileAvailable(profile) ? [] : ["unavailable"]), ...(profile.model === agentModel ? ["current"] : [])];
-                            return { label: `${profile.kind}/${profile.model}`, note: marks.join(" · "), ...effortAxis(profile) };
+                            // The owner, 2026-09-21: two profiles can name ONE model
+                            // id and reach two accounts, so the current mark follows
+                            // the PROFILE the session is on (`currentModelName`), not
+                            // the model id — the id alone marked both such rows, or
+                            // neither. The row's own provider rides the label, so two
+                            // rows that share an id still read differently.
+                            // 0.40.1 (the owner's dogfood, 2026-09-21): the `profile: <key>` prefix
+                            // is gone — the row already names the model and its endpoint, and the
+                            // profile key is what `/model <name>` takes, not what a chooser
+                            // reading a list needs. What remains is what the chooser CANNOT
+                            // infer: availability, and which one is live.
+                            const marks = [...(profileAvailable(profile) ? [] : ["unavailable"]), ...(name === currentProfileName ? ["current"] : [])];
+                            const host = profileProviderLabel(profile.kind, profile.baseUrl);
+                            return { label: `${profile.kind}/${profile.model}${host === "" ? "" : ` ${host}`}`, note: marks.join(" · "), ...effortAxis(profile) };
                         }),
                         // PH-1a (finding PH-F4): the example must be a syntax
                         // directWriteProfile actually ACCEPTS — the old
@@ -617,7 +658,8 @@ export function dispatch(line, ctx) {
                 else {
                     for (const name of names) {
                         const p = configModels[name];
-                        bodyLog(`  ${name} → ${p.kind}/${p.model} · ${signInNote(p)} ${profileAvailable(p) ? "(available)" : "(unavailable)"} · ${effortNote(p)}`);
+                        const hostOf = profileProviderLabel(p.kind, p.baseUrl);
+                        bodyLog(`  ${name} → ${p.kind}/${p.model}${hostOf === "" ? "" : ` ${hostOf}`} · ${signInNote(p)} ${profileAvailable(p) ? "(available)" : "(unavailable)"} · ${effortNote(p)}`);
                     }
                 }
                 bodyLog("switch with /model <profile-name|provider/model>");
@@ -713,6 +755,7 @@ export function dispatch(line, ctx) {
                             setLastBinding(binding);
                             setAgentModel(profile.model, profile.baseUrl);
                             setCurrentModelName(arg);
+                            setCurrentProfileName(direct === null ? null : profName);
                             // §2.5: the ONE source a reload reads for the model — a
                             // switch made here must survive the rebuild.
                             setModelChoice(arg);
@@ -732,7 +775,7 @@ export function dispatch(line, ctx) {
                             // (and the owner's) read `gpt-6-astra · CH 92%`, the new
                             // model beside the previous model's figure.
                             ctx.modelSwitched();
-                            body.notice(`model → ${profName} (${profile.model}${effortTok !== undefined ? ` · ${effortTok}` : ""}) — takes effect on the next turn`);
+                            body.notice(`model → ${profName} (${profile.model}${providerLabel(profile.baseUrl) === "" ? "" : ` ${providerLabel(profile.baseUrl)}`}${effortTok !== undefined ? ` · ${effortTok}` : ""}) — takes effect on the next turn`);
                         }
                     }
                 }

package/dist/index.js

@@ -45,7 +45,7 @@ import { floorExtension, isDestructiveCall } from "./floor.js";
 import { protectedShellExtension } from "./protected-shell.js";
 import { breakerExtension } from "./breaker.js";
 import { builtInLayer } from "./builtin.js";
-import { agentModel, atFiles, body, bodyLog, codingToolOptions, kisoHome, workspaceRoot, projectRoot, ownSessionsDir, setOpenSessionFolder, builtInExtensions, currentFaux, dock, extensionsDir, loadedExtensions, mergedConfig, mergedTempPaths, modelChoice, projectExtensions, configModels, configuredWindow, agentBaseUrl, currentModelName, currentAgentExtensions, sessionStoreRef, sessionsDir, setAgentModel, setBody, setConfigModels, setConfiguredWindow, setCurrentAgentExtensions, setCurrentFaux, setCurrentModelName, setExtensionLists, setUserProtectedPaths, protectedFiles, setMergedConfig, setModelChoice, setSessionStore, setRetryShown, setNeverInherited, secretEnvNamesOf, userExtensions, VERSION, lastBinding, acceptDrift, setAcceptDrift, setFloorOn, floorOn, loadedSkillsCatalog } from "./state.js";
+import { agentModel, atFiles, body, bodyLog, codingToolOptions, kisoHome, workspaceRoot, projectRoot, ownSessionsDir, setOpenSessionFolder, builtInExtensions, currentFaux, dock, extensionsDir, loadedExtensions, mergedConfig, mergedTempPaths, modelChoice, projectExtensions, configModels, configuredWindow, agentBaseUrl, currentModelName, currentAgentExtensions, sessionStoreRef, sessionsDir, setAgentModel, setBody, setConfigModels, setConfiguredWindow, setCurrentAgentExtensions, setCurrentFaux, setCurrentModelName, setCurrentProfileName, setExtensionLists, setUserProtectedPaths, protectedFiles, setMergedConfig, setModelChoice, setSessionStore, setRetryShown, setNeverInherited, secretEnvNamesOf, userExtensions, VERSION, lastBinding, acceptDrift, setAcceptDrift, setFloorOn, floorOn, loadedSkillsCatalog, queuedSwitchLines } from "./state.js";
 import { maxRetriesFromEnv } from "./retries.js";
 import { askUi, resolveProjectTrust } from "./trust-ui.js";
 import { isFirstRun, scaffoldFirstRun } from "./first-run.js";
@@ -468,6 +468,7 @@ function makeLineInput() {
         // the panel's option rows, so the compositor is what the editor asks
         // where they are. Neither side computes the other's geometry.
         editor.bindPanelRows(() => dock.panelOptionRows());
+        editor.bindPickWindow(() => dock.visiblePickWindow());
         dock.bindMenu(() => editor.menuState()); // v3 §04: the slash-command menu
         editor.bindAtItems(atFiles); // KC3 §5: the file source — listed per OPEN
         dock.bindAt(() => editor.atState()); // KC3 §4: the picker's band
@@ -785,10 +786,12 @@ async function makeAgent(sessionId, input, modelFlag) {
         console.log("[faux mode — set ANTHROPIC_API_KEY or OPENAI_API_KEY, or configure models in ~/.kiso/config.json]\n");
         setCurrentFaux(true);
         setCurrentModelName("faux");
+        setCurrentProfileName(null);
     }
     else {
         setCurrentFaux(false);
         setCurrentModelName(resolved.name);
+        setCurrentProfileName(resolved.name);
     }
     setAgentModel(model, resolved?.profile.baseUrl); // v2b: the status bar shows it; OR-1: the endpoint rides along
     // W21: the extensions array is built ONCE per agent and shared with
@@ -1134,13 +1137,15 @@ function retiredAutoCompact(merged) {
  * threshold got stuck in the first place.
  */
 function bindRestoredSession(session) {
-    // 0.40.0: an acknowledged drift says what it did, once — including the
-    // owner-ruled reasoning reset, which was silent until now.
+    // 0.40.1 (the owner's ruling of 2026-09-21): a changed binding is neither
+    // blocked nor "acknowledged" — it is recorded as the next revision under
+    // the CURRENT configuration, and this ONE line says which binding and why
+    // (the owner-ruled reasoning reset rides with it, silently until 0.40.0).
     const ack = session.driftAcknowledgement ?? null;
     if (ack !== null) {
         const was = ack.reasoningReset;
         const prior = [was.effort !== "default" ? `effort ${was.effort}` : "", was.thinking !== "default" ? `thinking ${was.thinking}` : ""].filter((s) => s !== "").join(", ");
-        bodyLog(`drift acknowledged — now on ${session.model}; reasoning reset to defaults${prior === "" ? "" : ` (was ${prior})`}`);
+        bodyLog(`binding changed — now on ${session.model}: ${ack.reasons.join("; ")}; reasoning reset to defaults${prior === "" ? "" : ` (was ${prior})`}`);
     }
     setAgentModel(session.model, session.baseUrl);
     session.setMicrocompactThreshold(microcompactThresholdFor({
@@ -1261,6 +1266,7 @@ async function reloadAgent(old, id, input, announce = true) {
         setConfiguredWindow(oldCfg.window);
         setCurrentFaux(oldCfg.faux);
         setCurrentModelName(oldCfg.modelName);
+        setCurrentProfileName(null); // the reload snapshot carries no profile name: no mark beats a guessed one
         setModelChoice(oldCfg.choice);
         setAgentModel(oldCfg.agent, oldCfg.endpoint);
         if (oldCfg.delegation === undefined)
@@ -1294,6 +1300,15 @@ async function chatLoop(first, firstId, input, autoCompact) {
     // reload said what it did; repeating the session's opening would read
     // as a new session, which is the one thing it is not.
     let rebuilt = false;
+    // XP-1: the id of the session that IS open — null until the first open
+    // succeeds, and cleared by a refused switch, so one refusal can never
+    // recurse into another.
+    let opened = null;
+    // XP-1: the re-open that follows a refused switch. The session is the one
+    // already on screen, so this step prints neither banner nor tail.
+    let refused = false;
+    /** DC-57: lines that arrived with a switch command belong to the session being asked for. */
+    let seed = [];
     for (;;) {
         // 0.40.0 (the lead's ruling): a session opens in the folder that holds
         // it, never moved — a switch that crosses folders rebuilds the agent
@@ -1318,10 +1333,50 @@ async function chatLoop(first, firstId, input, autoCompact) {
             }
             agent = next;
         }
-        const session = await agent.session({ id, ...(acceptDrift() ? { acceptDrift: true } : {}) });
+        let session;
+        try {
+            session = await agent.session({ id, ...(acceptDrift() ? { acceptDrift: true } : {}) });
+        }
+        catch (err) {
+            // The profile contract's BLOCKED cases — a sidecar that cannot be
+            // read, an XP-era log without one — belong to the ENTRY: nothing is
+            // on screen yet, and the message says what to do. An in-session
+            // SWITCH is a LINE: it switches NOTHING and the session you were in
+            // stays open. The throw used to escape chatLoop, which killed the
+            // REPL and left the session that was open behind with no log at all
+            // (announced once, then empty and unopenable). Every refusal this
+            // open can throw is treated the same way — the message itself is
+            // what says what to do about it.
+            if (opened === null)
+                throw err;
+            bodyLog(escapeTerminal(err.message));
+            // DC-57's other half + DC-55 (the owner's ruling of 2026-09-21,
+            // option ①): the lines that arrived WITH the refused switch were aimed
+            // at a session that EXISTS and could not be opened. They are NOT run
+            // here — a departing session never answers lines meant for the target —
+            // and not dropped in silence either: what was held is printed, so
+            // nothing vanishes without the person seeing it. (Leaving them in the
+            // queue would hand them to the old session on its next entry, which is
+            // the thing this ruling forbids.)
+            seed = [];
+            const held = queuedSwitchLines.splice(0);
+            if (held.length > 0) {
+                bodyLog(`[${held.length} line${held.length === 1 ? "" : "s"} held back — the switch was refused, so nothing was run]`);
+                for (const line of held)
+                    bodyLog(`  ${escapeTerminal(line)}`);
+            }
+            id = opened; // the switch is undone
+            opened = null;
+            refused = true;
+            continue;
+        }
+        opened = id;
         if (rebuilt) {
             rebuilt = false;
         }
+        else if (refused) {
+            refused = false; // back in the session that was already on screen
+        }
         else if (prev === null) {
             bodyLog(`session ${id}\n`);
             // REL-0152-D5: a session with history says what that history WAS.
@@ -1379,6 +1434,12 @@ async function chatLoop(first, firstId, input, autoCompact) {
         // the threshold. One step, shared by all three entry points.
         bindRestoredSession(session);
         setCurrentModelName(session.model);
+        // A SWITCH knows only a model id here — nothing that names the profile —
+        // so the mark is cleared rather than guessed. A FRESH start keeps what
+        // makeAgent resolved from `--model <profile>`, which is the one place
+        // the name is known (prev is null only on the first entry).
+        if (prev !== null)
+            setCurrentProfileName(null);
         paintBootStatus(session);
         // The terminal's window title, HERE for the same reason the three
         // lines above are here: this is the one step all three entry points
@@ -1392,9 +1453,12 @@ async function chatLoop(first, firstId, input, autoCompact) {
             route: (sessionId) => routeSession(sessionId),
             ...(process.stdin.isTTY ? { pick: () => pickSession(agent, input) } : {}),
         };
-        const end = await chat(session, currentFaux, input, autoCompact, nav);
+        const end = await chat(session, currentFaux, input, autoCompact, nav, seed);
         if (end.next === "exit")
             return;
+        // DC-57: the lines that arrived with the switch command ride INTO the
+        // next entry — they were aimed at the session being asked for.
+        seed = end.lines ?? [];
         if (end.next === "reload") {
             agent = await reloadAgent(agent, id, input);
             rebuilt = true;

package/dist/provider-label.d.ts

@@ -0,0 +1,32 @@
+/**
+ * The provider's NAME on screen — the host the request will actually go to.
+ *
+ * The owner, 2026-09-21: switching models must say WHO is being billed. Two
+ * profiles can name the same model id and reach two different accounts; the
+ * model id alone leaves the person unable to tell which one they are about
+ * to spend, which is exactly the mistake a picker exists to prevent.
+ *
+ * The fact is already in hand: `agentBaseUrl` rides with `agentModel` (one
+ * `setAgentModel(model, baseUrl)` call, so the two cannot drift), and a
+ * profile's `baseUrl` is what its row shows. This module turns that URL into
+ * the one label worth spending columns on — the HOST — with the provider id
+ * as the fallback for a binding that names no URL at all.
+ *
+ * Deliberately not a new rule: `providerIdOf` (auth/credentials) is the CLI's
+ * copy of the runtime's origin rule (KNOWN_ORIGINS / resolveContinuationScope),
+ * and this function only chooses what to PRINT from the same inputs.
+ */
+/** The host of a base URL, without scheme, credentials or any path:
+ *  `https://api.commandcode.ai/provider/v1` → `commandcode.ai`.
+ *
+ *  `null` when there is no URL to read — never a guess. A URL that does not
+ *  parse is not invented either: the caller falls back to the provider id. */
+export declare function providerHost(baseUrl?: string): string | null;
+/** `@commandcode.ai` — the provider named beside a model. `""` when the
+ *  binding names no endpoint (the provider's own default origin), so a row
+ *  that has nothing to say does not print a stray `@`. */
+export declare function providerLabel(baseUrl?: string): string;
+/** The same label for a PROFILE, which knows its kind as well as its URL: a
+ *  profile with no baseUrl (a first-party provider) still names itself by
+ *  providerId, because a row that shows two profiles must tell them apart. */
+export declare function profileProviderLabel(kind: string, baseUrl?: string): string;

package/dist/provider-label.js

@@ -0,0 +1,53 @@
+/**
+ * The provider's NAME on screen — the host the request will actually go to.
+ *
+ * The owner, 2026-09-21: switching models must say WHO is being billed. Two
+ * profiles can name the same model id and reach two different accounts; the
+ * model id alone leaves the person unable to tell which one they are about
+ * to spend, which is exactly the mistake a picker exists to prevent.
+ *
+ * The fact is already in hand: `agentBaseUrl` rides with `agentModel` (one
+ * `setAgentModel(model, baseUrl)` call, so the two cannot drift), and a
+ * profile's `baseUrl` is what its row shows. This module turns that URL into
+ * the one label worth spending columns on — the HOST — with the provider id
+ * as the fallback for a binding that names no URL at all.
+ *
+ * Deliberately not a new rule: `providerIdOf` (auth/credentials) is the CLI's
+ * copy of the runtime's origin rule (KNOWN_ORIGINS / resolveContinuationScope),
+ * and this function only chooses what to PRINT from the same inputs.
+ */
+import { providerIdOf } from "./auth/credentials.js";
+/** The host of a base URL, without scheme, credentials or any path:
+ *  `https://api.commandcode.ai/provider/v1` → `commandcode.ai`.
+ *
+ *  `null` when there is no URL to read — never a guess. A URL that does not
+ *  parse is not invented either: the caller falls back to the provider id. */
+export function providerHost(baseUrl) {
+    if (baseUrl === undefined || baseUrl.trim() === "")
+        return null;
+    try {
+        const url = new URL(baseUrl);
+        // REVIEW (2026-09-21): `host`, not `hostname` — the PORT is part of the
+        // answer this label exists to give (`localhost:11434` and
+        // `localhost:8000` are two different places to spend, and both read as
+        // `@localhost` under `hostname`).
+        const host = url.host;
+        return host === "" ? null : host;
+    }
+    catch {
+        return null;
+    }
+}
+/** `@commandcode.ai` — the provider named beside a model. `""` when the
+ *  binding names no endpoint (the provider's own default origin), so a row
+ *  that has nothing to say does not print a stray `@`. */
+export function providerLabel(baseUrl) {
+    const host = providerHost(baseUrl);
+    return host === null ? "" : `@${host}`;
+}
+/** The same label for a PROFILE, which knows its kind as well as its URL: a
+ *  profile with no baseUrl (a first-party provider) still names itself by
+ *  providerId, because a row that shows two profiles must tell them apart. */
+export function profileProviderLabel(kind, baseUrl) {
+    return providerLabel(baseUrl) || `@${providerIdOf(kind, baseUrl)}`;
+}

package/dist/state.d.ts

@@ -275,6 +275,19 @@ export declare let modelChoice: string | undefined;
 export declare function setModelChoice(value: string | undefined): void;
 export declare let currentModelName: string;
 export declare function setCurrentModelName(value: string): void;
+/** REVIEW (2026-09-21): WHO the binding came from is a different fact from
+ *  WHICH model it names, and `currentModelName` carried both — a profile alias
+ *  after `/model`, a model id after a switch, a resume or a reload. Surfaces
+ *  that want to name the PROFILE ask this one; an unknown profile is null, and
+ *  nothing guesses a credential identity out of a model name and a host. */
+export declare let currentProfileName: string | null;
+export declare function setCurrentProfileName(value: string | null): void;
+/** DC-57 (the owner's ruling, 2026-09-21): lines that arrived with a switch
+ *  command — a paste, a pipe, a scripted driver — belong to the session the
+ *  person asked for. The departing entry queues them here and the next
+ *  `chat()` drains them into its own replay, so no line is answered by the
+ *  session being left and none is dropped. */
+export declare const queuedSwitchLines: string[];
 /** E1: the extensions loaded by makeAgent — their names feed the banner. */
 /** 0.40.0: whether the catastrophe floor is on (floor.ts) — the user
  *  config's `floor`, read where the chain is assembled. */

package/dist/state.js

@@ -368,6 +368,21 @@ export let currentModelName = "faux";
 export function setCurrentModelName(value) {
     currentModelName = value;
 }
+/** REVIEW (2026-09-21): WHO the binding came from is a different fact from
+ *  WHICH model it names, and `currentModelName` carried both — a profile alias
+ *  after `/model`, a model id after a switch, a resume or a reload. Surfaces
+ *  that want to name the PROFILE ask this one; an unknown profile is null, and
+ *  nothing guesses a credential identity out of a model name and a host. */
+export let currentProfileName = null;
+export function setCurrentProfileName(value) {
+    currentProfileName = value;
+}
+/** DC-57 (the owner's ruling, 2026-09-21): lines that arrived with a switch
+ *  command — a paste, a pipe, a scripted driver — belong to the session the
+ *  person asked for. The departing entry queues them here and the next
+ *  `chat()` drains them into its own replay, so no line is answered by the
+ *  session being left and none is dropped. */
+export const queuedSwitchLines = [];
 /** E1: the extensions loaded by makeAgent — their names feed the banner. */
 /** 0.40.0: whether the catastrophe floor is on (floor.ts) — the user
  *  config's `floor`, read where the chain is assembled. */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vincemakes/kiso-code",
-	"version": "0.40.0",
+	"version": "0.40.1",
 	"description": "kiso-code \u2014 the coding agent on kiso, the durable runtime for AI agents: kiso chat / kiso resume / kiso sessions.",
 	"type": "module",
 	"license": "MIT",
@@ -18,20 +18,20 @@
 		"test": "vitest run"
 	},
 	"dependencies": {
-		"@vincemakes/kiso-ask-ext": "0.40.0",
-		"@vincemakes/kiso-core": "0.40.0",
-		"@vincemakes/kiso-evals": "0.40.0",
-		"@vincemakes/kiso-mcp-ext": "0.40.0",
-		"@vincemakes/kiso-provider-anthropic": "0.40.0",
-		"@vincemakes/kiso-provider-openai": "0.40.0",
-		"@vincemakes/kiso-provider-openai-responses": "0.40.0",
-		"@vincemakes/kiso-runtime": "0.40.0",
-		"@vincemakes/kiso-skills-ext": "0.40.0",
-		"@vincemakes/kiso-subagent-ext": "0.40.0",
-		"@vincemakes/kiso-task-ext": "0.40.0",
-		"@vincemakes/kiso-tools-node": "0.40.0",
-		"@vincemakes/kiso-tui": "0.40.0",
-		"@vincemakes/kiso-tui-cells": "0.40.0"
+		"@vincemakes/kiso-ask-ext": "0.40.1",
+		"@vincemakes/kiso-core": "0.40.1",
+		"@vincemakes/kiso-evals": "0.40.1",
+		"@vincemakes/kiso-mcp-ext": "0.40.1",
+		"@vincemakes/kiso-provider-anthropic": "0.40.1",
+		"@vincemakes/kiso-provider-openai": "0.40.1",
+		"@vincemakes/kiso-provider-openai-responses": "0.40.1",
+		"@vincemakes/kiso-runtime": "0.40.1",
+		"@vincemakes/kiso-skills-ext": "0.40.1",
+		"@vincemakes/kiso-subagent-ext": "0.40.1",
+		"@vincemakes/kiso-task-ext": "0.40.1",
+		"@vincemakes/kiso-tools-node": "0.40.1",
+		"@vincemakes/kiso-tui": "0.40.1",
+		"@vincemakes/kiso-tui-cells": "0.40.1"
 	},
 	"devDependencies": {
 		"@types/node": "^26.1.2",