koneck 2.25.59 → 2.25.61

package/dist/ink-chat.js

@@ -8,6 +8,8 @@ import { generateSessionId, saveSession, listSessions, loadSession, relativeAge,
 import { loadMemory } from './memory.js';
 import { loadKoneckConfig, saveKoneckConfig, setConfigKey, configKeyDescriptions, CONFIG_FILE, CONFIG_SCHEMA, stepValue, displayValue } from './config-store.js';
 import { PROVIDERS, resolveProvider, getApiKey, addUserProvider, userProvidersPath } from './providers.js';
+import { resolveEndpoint, normaliseEndpoint, withEndpoint, savedEndpoints } from './endpoints.js';
+import { loadProjectConfig, loadGlobalConfig } from './config.js';
 import { listCheckpoints, revertCheckpoint, snapshotTree, filesTouchedBy } from './checkpoint.js';
 import { fileDiff, diffSummary } from './diff-view.js';
 import { listWorkspaceEntries, filterEntries, activeReference } from './workspace-files.js';
@@ -270,6 +272,16 @@ function Shimmer({ text, frame, base }) {
 export const WORK_WORDS = {
     // No tool ran: it thought and answered. A cooking metaphor is wrong here — nothing was made.
     reply: [
+        ["Thinking it through", "Thought it through, sharp"],
+        ["Consulting the elders", "Elders consulted"],
+        ["Reading the room", "Room read"],
+        ["Chewing it over", "Chewed it over"],
+        ["Doing the maths", "Maths done"],
+        ["Asking the rubber duck", "Duck consulted"],
+        ["Squinting at it", "Squinted at it"],
+        ["Joining the dots", "Dots joined"],
+        ["Sleeping on it", "Slept on it"],
+        ["Weighing both sides", "Both sides weighed"],
         ['Thinking', 'Thought it through'], ['Weighing it up', 'Weighed it up'],
         ['Talking it through', 'Talked it through'], ['Laying it out', 'Laid it out'],
         ['Reading you', 'Read you'], ['Working it out', 'Worked it out'],
@@ -279,6 +291,18 @@ export const WORK_WORDS = {
     ],
     // Under ~3s. Snappy, almost dismissive — it barely counted as work.
     quick: [
+        ["Now-now", "Done now-now"],
+        ["Ayoba", "Made it ayoba"],
+        ["Kicking it", "Kicked"],
+        ["Zap-zapping", "Zap-zapped"],
+        ["Tapping the card", "Card tapped"],
+        ["Popping the kettle on", "Kettle popped on"],
+        ["Pulling an espresso", "Espresso pulled"],
+        ["Catching the kombi", "Kombi caught"],
+        ["Beating the robot", "Robot beaten"],
+        ["Slipping it in", "Slipped in"],
+        ["Grabbing a vetkoek", "Vetkoek grabbed"],
+        ["Skipping the queue", "Queue skipped"],
         ['Sharp-sharp', 'Sharp-sharp'], ['Doing it now-now', 'Done now-now'],
         ['One-tapping', 'One-tapped'], ['No-scoping', 'No-scoped'],
         ['Speedrunning', 'Speedran'], ['Microwaving', 'Microwaved'],
@@ -296,6 +320,32 @@ export const WORK_WORDS = {
     ],
     // The everyday middle. General flex and completion.
     normal: [
+        ["Stirring the sishwala", "Sishwala stirred"],
+        ["Pounding tinkhobe", "Tinkhobe pounded"],
+        ["Souring the emasi", "Emasi soured"],
+        ["Brewing emahewu", "Emahewu brewed"],
+        ["Frying magwinya", "Magwinya fried"],
+        ["Rolling a bunny chow", "Bunny chow rolled"],
+        ["Firing the shisanyama", "Shisanyama fired"],
+        ["Stirring the potjie", "Potjie stirred"],
+        ["Turning the pap", "Pap turned"],
+        ["Dropping the log drum", "Log drum dropped"],
+        ["Stewing jollof", "Jollof stewed"],
+        ["Pounding fufu", "Fufu pounded"],
+        ["Rolling injera", "Injera rolled"],
+        ["Grinding berbere", "Berbere ground"],
+        ["Wrapping dolmades", "Dolmades wrapped"],
+        ["Folding dumplings", "Dumplings folded"],
+        ["Rolling sushi", "Sushi rolled"],
+        ["Proving the sourdough", "Sourdough proved"],
+        ["Tempering chocolate", "Chocolate tempered"],
+        ["Layering the lasagne", "Lasagne layered"],
+        ["Negotiating with TypeScript", "TypeScript talked round"],
+        ["Bribing the linter", "Linter bribed"],
+        ["Blaming the cache", "Cache blamed"],
+        ["Threading the needle", "Needle threaded"],
+        ["Loading the kombi", "Kombi loaded"],
+        ["Beating loadshedding", "Loadshedding beaten"],
         ['Cooking', 'Cooked lekker'], ['Baking', 'Baked'],
         ['Grilling', 'Grilled'], ['Sizzling', 'Sizzled'],
         ['Brewing', 'Brewed'], ['Chowing', 'Chowed'],
@@ -332,6 +382,24 @@ export const WORK_WORDS = {
     ],
     // Over ~10s. Slow heat and visible effort — it earned the wait.
     heavy: [
+        ["Slow-braaiing", "Slow-braaied"],
+        ["Burying the potjie", "Potjie unearthed"],
+        ["Drying umncweba", "Umncweba dried"],
+        ["Curing biltong", "Biltong cured"],
+        ["Waiting for the kombi to fill", "Kombi finally filled"],
+        ["Smoking brisket", "Brisket smoked"],
+        ["Curing prosciutto", "Prosciutto cured"],
+        ["Ageing the parmesan", "Parmesan aged"],
+        ["Reducing the stock", "Stock reduced"],
+        ["Confiting the duck", "Duck confited"],
+        ["Fermenting the mageu", "Mageu fermented"],
+        ["Digging the imbawula", "Imbawula stoked"],
+        ["Walking to Mbabane", "Walked to Mbabane"],
+        ["Crossing the Lubombo", "Lubombo crossed"],
+        ["Counting the cattle", "Cattle counted"],
+        ["Thatching the roof", "Roof thatched"],
+        ["Waiting out stage six", "Stage six outlasted"],
+        ["Arguing with the compiler", "Compiler talked down"],
         ['Braaiing', "Braai'd"], ['Deep-frying', 'Deep-fried'],
         ['Pressure-cooking', 'Pressure-cooked'], ['Slow-smoking', 'Smoked'],
         ['Simmering', 'Simmered'], ['Marinating', 'Marinated'],
@@ -361,6 +429,14 @@ export const WORK_WORDS = {
     ],
     // Something failed on the way and had to be worked around.
     recovery: [
+        ["Patching the pothole", "Pothole patched"],
+        ["Jump-starting it", "Jump-started"],
+        ["Duct-taping it", "Duct-taped"],
+        ["Calling the mechanic", "Mechanic called"],
+        ["Rerouting round the roadworks", "Roadworks rerouted"],
+        ["Putting it back on the rails", "Back on the rails"],
+        ["Unblocking the drain", "Drain unblocked"],
+        ["Re-braaiing the burnt bit", "Burnt bit re-braaied"],
         ['Sorting it sharp-sharp', 'Sorted sharp-sharp'],
         ['De-spaghettifying', 'De-spaghettified'],
         ['Clutching it back', 'Clutched it'],
@@ -424,6 +500,7 @@ const COMMANDS = [
     { cmd: '/help', desc: 'Show help' },
     { cmd: '/models', desc: 'Browse and switch models for the connected provider' },
     { cmd: '/connect', desc: 'Connect a provider, or declare a new one with a URL' },
+    { cmd: '/endpoint', desc: "Show or change this provider's URL, e.g. a remote Ollama" },
     { cmd: '/key', desc: 'Enter an API key for the current provider' },
     { cmd: '/model', desc: 'Show or set the model by name' },
     { cmd: '/provider', desc: 'Show or switch provider' },
@@ -619,6 +696,32 @@ export function pickerLabelWidth(labels, descs, width) {
     const longestLabel = Math.max(18, ...labels.map(l => l.length));
     return Math.max(18, Math.min(longestLabel, width - longestDesc - 4));
 }
+/**
+ * Commands that must wait for a running turn, because they change what it is running against.
+ *
+ * Everything else runs immediately. Asking what the agent has done, or where the time went, is a
+ * question about the run in progress — queueing it until the run finishes answers it about a
+ * different moment, and typing /activity to watch a long turn and being told "1 queued, will run
+ * when this finishes" is the opposite of what was wanted.
+ *
+ * A deny list rather than an allow list, because the informational commands are the majority and
+ * a new one should work without being registered twice. The dangerous ones are few and named.
+ */
+const COMMANDS_THAT_MUST_WAIT = new Set([
+    '/clear', '/reset', '/new', // would wipe the history the turn is using
+    '/model', '/provider', '/connect', '/key', '/endpoint', '/baseurl', // rebuild the session
+    '/resume', '/fork', // replace it
+    '/revert', // undo files the turn may still be writing
+    '/init', '/setup',
+]);
+/** Commands that cannot do anything useful without an argument, so they are offered for editing. */
+const COMMANDS_NEEDING_ARGUMENT = new Set(['/send', '/ask', '/aside']);
+export function commandRunsWhileBusy(cmd) {
+    return !COMMANDS_THAT_MUST_WAIT.has(cmd.toLowerCase());
+}
+export function commandNeedsArgument(cmd) {
+    return COMMANDS_NEEDING_ARGUMENT.has(cmd.toLowerCase());
+}
 const MODES = MODE_SPECS.map(m => m.name);
 const HELP_TEXT = `
 Type / on an empty line to browse every command; keep typing to filter.
@@ -630,6 +733,9 @@ Slash commands:
   /connect [provider]   Connect a provider (picker when no name given)
   /connect <name> <url> Declare a provider KONECK does not ship with, e.g.
                         /connect openrouter https://openrouter.ai/api/v1
+  /endpoint             Show the endpoint in force and where it came from
+  /endpoint <url>       Point this provider somewhere else, e.g.
+                        /endpoint http://192.168.1.50:11434/v1
   /key                  Enter an API key for the current provider
   /status               Provider, model, mode, tokens, cost, CWD
   /clear /reset /new    Clear conversation history
@@ -1086,6 +1192,28 @@ function App({ config: initialConfig }) {
             setConfigMaxWidth(typeof c.maxWidth === 'number' && c.maxWidth >= 40 ? c.maxWidth : undefined);
         });
     }, []);
+    /**
+     * The config layers other than the store, kept so an endpoint can be resolved and, more to the
+     * point, explained. "It still sticks to the already set ollama" is a question about which file
+     * won, and the answer is not available from the store alone.
+     */
+    const [outerLayers, setOuterLayers] = useState({ project: {}, global: {} });
+    useEffect(() => {
+        void Promise.all([loadProjectConfig(cfg.cwd), loadGlobalConfig()])
+            .then(([project, global]) => setOuterLayers({ project, global }))
+            .catch(() => { });
+    }, [cfg.cwd]);
+    /** Nearest first, which is the order resolveEndpoint reads them in. */
+    const endpointLayers = (store = stored) => [outerLayers.project, store, outerLayers.global];
+    /** The endpoint in force for a provider, with where it came from. */
+    function endpointFor(provider, store) {
+        const def = PROVIDERS[provider.trim().toLowerCase()];
+        return resolveEndpoint(provider, endpointLayers(store), {
+            fallback: def?.baseURL ?? '',
+            baseURLEnv: def?.baseURLEnv,
+            fallbackIsUserDeclared: def?.userDefined === true,
+        });
+    }
     useEffect(() => {
         const onResize = () => {
             setTermCols(process.stdout.columns || 80);
@@ -1236,9 +1364,9 @@ function App({ config: initialConfig }) {
             const delay = currentDelay();
             setAnim(a => ({ spin: (a.spin + 1) % SPINNER.length, shimmer: a.shimmer + 1, elapsed }));
             wordTimer.current += 1;
-            // Roughly every 25 seconds, whatever the current rate. Long enough to read the word,
-            // notice it, and still see it change before the wait starts feeling stuck.
-            if (wordTimer.current % Math.max(20, Math.round(25_000 / delay)) === 0) {
+            // Roughly every 60 seconds, whatever the current rate. Twenty-five felt churned on a long
+            // run — the word is there to be read and enjoyed, not to reassure by moving.
+            if (wordTimer.current % Math.max(20, Math.round(60_000 / delay)) === 0) {
                 setSpinWord(w => w + 1);
             }
             timer = setTimeout(tick, delay);
@@ -1429,7 +1557,58 @@ function App({ config: initialConfig }) {
      * Persisting alone would leave the running session on the old value until restart, which is the
      * behaviour that made the old `/config` feel inert even when it had worked.
      */
+    /**
+     * What a setting is worth right now, wherever the value came from.
+     *
+     * The store is only one of three files. Reading a row from it alone showed "(not set)" beside a
+     * session that was plainly configured, and — with endpoints saved per provider — would show
+     * nothing at all for an endpoint that is in force.
+     */
+    function liveSetting(key) {
+        switch (key) {
+            case 'provider': return cfg.provider;
+            case 'model': return cfg.model;
+            case 'baseURL': return endpointFor(cfg.provider).url;
+            case 'effort': return effort;
+            case 'requireApproval': return cfg.requireApproval;
+            case 'maxTurns': return cfg.maxTurns;
+            case 'agentConcurrency': return cfg.agentConcurrency;
+            case 'maxWidth': return configMaxWidth;
+            case 'budget': return cfg.budget;
+            default: return stored[key];
+        }
+    }
+    /** The text an edit box opens on: what the row is showing. */
+    function settingText(field) {
+        const key = String(field.key);
+        const value = key === 'baseURL' || stored[key] === undefined ? liveSetting(key) : stored[key];
+        return value === undefined || value === null ? '' : String(value);
+    }
     async function applySetting(field, value) {
+        // The endpoint row is not a plain setting: it is one provider's address, so it is saved
+        // against the provider in force rather than into a single slot every provider shares.
+        if (field.key === 'baseURL') {
+            let url;
+            if (typeof value === 'string' && value.trim() !== '') {
+                const checked = normaliseEndpoint(value);
+                if (!checked.url) {
+                    addSystem(checked.problem ?? `"${value}" is not a URL.`);
+                    return;
+                }
+                url = checked.url;
+                if (checked.note)
+                    addSystem(checked.note);
+            }
+            const saved = withEndpoint(await loadKoneckConfig(), cfg.provider, url);
+            await saveKoneckConfig(saved);
+            setStored(saved);
+            const now = endpointFor(cfg.provider, saved);
+            const merged = { ...cfg, baseURL: now.url };
+            setCfg(merged);
+            await resetSession(merged);
+            addSystem(`**${cfg.provider}** → ${now.url}  (${now.source})`);
+            return;
+        }
         const next = { ...stored, [field.key]: value };
         if (value === undefined)
             delete next[field.key];
@@ -1442,9 +1621,21 @@ function App({ config: initialConfig }) {
             case 'maxWidth':
                 setConfigMaxWidth(typeof value === 'number' && value >= 40 ? value : undefined);
                 break;
+            case 'provider': {
+                // Changing the provider here has to move the endpoint with it, or the new provider is
+                // addressed at the old one's URL — the same fault /provider had.
+                const name = typeof value === 'string' && value.trim() !== '' ? value.trim() : cfg.provider;
+                const def = PROVIDERS[name.toLowerCase()];
+                const merged = {
+                    ...cfg, provider: name,
+                    model: def?.defaultModel ?? cfg.model,
+                    baseURL: endpointFor(name, next).url,
+                };
+                setCfg(merged);
+                await resetSession(merged);
+                break;
+            }
             case 'model':
-            case 'provider':
-            case 'baseURL':
             case 'maxTurns':
             case 'requireApproval':
             case 'agentConcurrency':
@@ -1614,9 +1805,18 @@ function App({ config: initialConfig }) {
             return;
         }
         if (kind === 'command') {
-            // Leave it in the composer so arguments can still be typed before submitting.
-            setDraft(item.value + ' ');
-            setCaret(item.value.length + 1);
+            // Run it. Picking a command out of the palette and pressing enter is choosing to run it;
+            // leaving it in the composer meant a second enter for every command, which is a keystroke
+            // that only ever existed to serve the few commands that need an argument.
+            if (commandNeedsArgument(item.value)) {
+                setDraft(item.value + ' ');
+                setCaret(item.value.length + 1);
+                return;
+            }
+            setDraft('');
+            setCaret(0);
+            setBusy(true);
+            await handleCommand(item.value, '').finally(() => setBusy(false));
             return;
         }
         if (kind === 'resume') {
@@ -1636,7 +1836,11 @@ function App({ config: initialConfig }) {
         }
         if (kind === 'provider') {
             const def = PROVIDERS[item.value];
-            const resolved = resolveProvider(item.value);
+            // The endpoint saved for the provider being switched to, not its built-in address. Passing
+            // it into resolveProvider also settles the credential question honestly: a remote Ollama is
+            // not loopback and does need a key, whatever the provider is called.
+            const endpoint = endpointFor(item.value);
+            const resolved = resolveProvider(item.value, endpoint.url);
             const next = {
                 ...cfg, provider: item.value,
                 model: def?.defaultModel ?? cfg.model,
@@ -1654,7 +1858,11 @@ function App({ config: initialConfig }) {
             }
             if (usable) {
                 await resetSession(next);
-                addSystem(`Provider → ${item.value}  ·  model → ${next.model}  (session reset)`);
+                const savedCfg = { ...(await loadKoneckConfig()), provider: item.value, model: next.model };
+                await saveKoneckConfig(savedCfg);
+                setStored(savedCfg);
+                addSystem(`Provider → ${item.value}  ·  model → ${next.model}\n` +
+                    `Endpoint  ${resolved.baseURL}  (${endpoint.source})  ·  session reset`);
                 return;
             }
             setCfg(next);
@@ -1744,10 +1952,74 @@ function App({ config: initialConfig }) {
                     addSystem(`Current provider: ${cfg.provider}\nAvailable: ${Object.keys(PROVIDERS).join(', ')}\nUsage: /provider <name>`);
                     return;
                 }
-                const def = PROVIDERS[arg.toLowerCase()];
-                const newCfg = { ...cfg, provider: arg.toLowerCase(), model: def?.defaultModel ?? cfg.model, baseURL: def?.baseURL };
+                const name = arg.trim().toLowerCase();
+                const def = PROVIDERS[name];
+                if (!def) {
+                    // Switching to a name that does not resolve used to reset the session anyway, leaving it
+                    // pointed at nothing and failing on the next message instead of on the command.
+                    addSystem(`Unknown provider "${arg}". Known: ${Object.keys(PROVIDERS).join(', ')}\n` +
+                        `Declare one:  /connect ${name} https://endpoint/v1`);
+                    return;
+                }
+                // The endpoint is the provider's own, not a literal default: whatever was saved for it,
+                // or its environment variable, still applies. Naming a provider used to overwrite the
+                // address with PROVIDERS[name].baseURL, which is how a configured Ollama kept coming back
+                // as localhost.
+                const endpoint = endpointFor(name);
+                const newCfg = { ...cfg, provider: name, model: def.defaultModel ?? cfg.model, baseURL: endpoint.url };
                 await resetSession(newCfg);
-                addSystem(`Provider → ${arg}  model → ${newCfg.model}  (session reset)`);
+                // Persisted, or the switch is undone by the next start and the old provider wins again.
+                const savedCfg = { ...(await loadKoneckConfig()), provider: name, model: newCfg.model };
+                await saveKoneckConfig(savedCfg);
+                setStored(savedCfg);
+                addSystem(`Provider → ${name}  model → ${newCfg.model}\n` +
+                    `Endpoint  ${endpoint.url}  (${endpoint.source})\n` +
+                    `Session reset. /endpoint <url> changes the address.`);
+                return;
+            }
+            case '/url':
+            case '/baseurl':
+            case '/endpoint': {
+                const provider = cfg.provider;
+                const current = endpointFor(provider);
+                if (!arg.trim()) {
+                    // No argument is the diagnostic. The complaint that produced this command was about a
+                    // change that appeared not to take, and the only useful reply names the file that won.
+                    const all = savedEndpoints(endpointLayers());
+                    const others = Object.entries(all).filter(([name]) => name !== provider.toLowerCase());
+                    addSystem(`**${provider}** → ${current.url}\n` +
+                        `Source: ${current.source}\n\n` +
+                        (others.length
+                            ? 'Also saved:\n' + others.map(([n, u]) => `  ${n.padEnd(12)} ${u}`).join('\n') + '\n\n'
+                            : '') +
+                        `Change it:  /endpoint http://192.168.1.50:11434/v1\n` +
+                        `Undo it:    /endpoint default`);
+                    return;
+                }
+                const wanted = arg.trim();
+                if (/^(default|reset|clear|unset)$/i.test(wanted)) {
+                    const saved = withEndpoint(await loadKoneckConfig(), provider, undefined);
+                    await saveKoneckConfig(saved);
+                    setStored(saved);
+                    const back = endpointFor(provider, saved);
+                    await resetSession({ ...cfg, baseURL: back.url });
+                    addSystem(`**${provider}** → ${back.url}  (${back.source})\nSession reset.`);
+                    return;
+                }
+                const { url, problem, note } = normaliseEndpoint(wanted);
+                if (!url) {
+                    addSystem(`${problem}\nUsage: /endpoint http://host:port/v1`);
+                    return;
+                }
+                // Saved against the provider, not as a global address: setting Ollama's URL used to move
+                // OmniRoute's too, and one of the two was then wrong whichever way round it was left.
+                const saved = withEndpoint(await loadKoneckConfig(), provider, url);
+                await saveKoneckConfig(saved);
+                setStored(saved);
+                await resetSession({ ...cfg, baseURL: url });
+                addSystem(`**${provider}** → ${url}\n` +
+                    `Saved for ${provider} in ${CONFIG_FILE}; session reset.` +
+                    (note ? `\n${note}` : ''));
                 return;
             }
             case '/mode':
@@ -2648,7 +2920,10 @@ function App({ config: initialConfig }) {
                         void applySetting(field, stepValue(field, stored[field.key], 1));
                     }
                     else {
-                        setEditing({ key: String(field.key), value: '' });
+                        // Opened on the current value rather than on an empty box. Editing a URL by retyping
+                        // all of it is not editing, and an empty box next to a value that is plainly set
+                        // reads as "this cannot be changed".
+                        setEditing({ key: String(field.key), value: settingText(field) });
                     }
                     return;
                 }
@@ -2710,6 +2985,19 @@ function App({ config: initialConfig }) {
                     void askAside(text.replace(/^\/aside\s*/, ''));
                     return;
                 }
+                // A local command runs now. It asks about the run in progress, and answering it after the
+                // run has finished answers it about a different moment.
+                if (isSlashCommand(text)) {
+                    const space = text.indexOf(' ');
+                    const cmd = space === -1 ? text : text.slice(0, space);
+                    if (commandRunsWhileBusy(cmd)) {
+                        setDraft('');
+                        setCaret(0);
+                        void handleCommand(cmd, space === -1 ? '' : text.slice(space + 1).trim());
+                        return;
+                    }
+                    addSystem(`${cmd} changes the session, so it waits until this turn finishes.`);
+                }
                 setQueued(q => [...q, expandPastes(text, pastesRef.current)]);
                 setDraft('');
                 setCaret(0);
@@ -3146,23 +3434,23 @@ function App({ config: initialConfig }) {
                     // What is actually in force, not just what this file happens to hold. provider and
                     // baseURL commonly come from ~/.koneckrc, and showing those as "(not set)" made a
                     // configured session look unconfigured.
-                    const live = {
-                        provider: cfg.provider, model: cfg.model, baseURL: cfg.baseURL,
-                        effort, requireApproval: cfg.requireApproval, maxTurns: cfg.maxTurns,
-                        agentConcurrency: cfg.agentConcurrency, maxWidth: configMaxWidth, budget: cfg.budget,
-                    };
+                    const endpoint = endpointFor(cfg.provider);
                     const labelW = Math.max(...CONFIG_SCHEMA.map(f => f.label.length));
                     for (const [i, f] of CONFIG_SCHEMA.entries()) {
                         const selected = i === settingRow;
                         const beingTyped = editing?.key === String(f.key);
-                        const here = stored[f.key] !== undefined;
-                        const value = here ? stored[f.key] : live[f.key];
+                        // An endpoint always has a source worth naming, so it never reads as unset or as
+                        // merely inherited: the question it answers is which file won.
+                        const isEndpoint = f.key === 'baseURL';
+                        const here = !isEndpoint && stored[f.key] !== undefined;
+                        const value = here ? stored[f.key] : liveSetting(String(f.key));
                         const raw = f.key === 'maxTurns' && (value === 0 || value === undefined)
                             ? 'no limit'
                             : displayValue(value);
                         const shown = beingTyped
                             ? `${editing.value}_`
-                            : raw + (here || value === undefined ? '' : ' (inherited)');
+                            : isEndpoint ? `${raw}  (${endpoint.source})`
+                                : raw + (here || value === undefined ? '' : ' (inherited)');
                         // The marker is what makes the selection legible without colour, which a panel line
                         // drawn as one string cannot carry per-segment.
                         const mark = selected ? '>' : ' ';