@hncode/hncode 0.2.0 → 0.3.1

package/src/config.js

@@ -6,6 +6,7 @@ import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
 import { parse } from './toml.js';
+import { pluginConfigDefaults } from './plugin.js';
 
 const home = os.homedir();
 
@@ -62,6 +63,124 @@ export function hncodeConfigFile() {
   return process.env.HNCODE_CONFIG || path.join(home, '.hncode', 'config.toml');
 }
 
+// ---- personal preferences (/personal) ----
+// Free-form markdown the user wants applied on EVERY turn ("reply in Chinese",
+// "I use pnpm", "never add a trailing newline", …). Two scopes are merged, the
+// project one LAST so it can refine the global one:
+//   * global  — ~/.hncode/PERSONAL.md      (every workspace)
+//   * project — <workspace>/.hncode/PERSONAL.md  (this workspace only)
+// Both are OPTIONAL; a missing/empty file injects nothing. The files are read
+// fresh on each turn, so an edit through /personal takes effect immediately.
+export function personalPromptFile(scope, workspace) {
+  if (scope === 'global') return path.join(home, '.hncode', 'PERSONAL.md');
+  return path.join(workspace || process.cwd(), '.hncode', 'PERSONAL.md');
+}
+
+// Header placed before the injected preferences, so the model knows where the
+// text came from and how much authority it has.
+export const PERSONAL_PROMPT_HEADER =
+  'USER PERSONAL PREFERENCES (persistent notes from the user; follow them unless\n'
+  + 'the current request says otherwise):';
+
+// Raw file content for one scope (no header) — used by /personal's editor.
+export function readPersonalPromptRaw(scope, workspace) {
+  try { return fs.readFileSync(personalPromptFile(scope, workspace), 'utf8'); } catch { return ''; }
+}
+
+// Save one scope. Empty text REMOVES the file (so nothing is injected).
+export function writePersonalPrompt(scope, workspace, text) {
+  const file = personalPromptFile(scope, workspace);
+  const value = String(text == null ? '' : text);
+  if (!value.trim()) {
+    try { fs.unlinkSync(file); } catch { /* already gone */ }
+    return file;
+  }
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, value.replace(/\s+$/, '') + '\n', 'utf8');
+  return file;
+}
+
+export function readPersonalPrompt(workspace) {
+  const parts = [];
+  for (const scope of ['global', 'project']) {
+    try {
+      const t = fs.readFileSync(personalPromptFile(scope, workspace), 'utf8').trim();
+      if (t) parts.push(t);
+    } catch { /* no file for this scope: nothing to inject */ }
+  }
+  if (!parts.length) return '';
+  return PERSONAL_PROMPT_HEADER + '\n' + parts.join('\n\n');
+}
+
+// ---- AGENTS.md --------------------------------------------------------------
+// Project instruction files, mirroring codex's AGENTS.md spec
+// (codex-rs/core/gpt_5_2_prompt.md, "AGENTS.md spec"):
+//   * a file's scope is the whole directory tree rooted where it sits;
+//   * for every file you touch you must obey the AGENTS.md whose scope covers it;
+//   * more-deeply-nested files take precedence on conflict;
+//   * direct system/user instructions outrank all of them.
+// Files are therefore collected from the workspace root DOWN to the working
+// directory and injected outermost-first, so the deepest one is read last and
+// naturally wins — the same precedence, without a merge step.
+//
+// This closes a real gap: /init WRITES an AGENTS.md and the prompt advertises it
+// as "smarter agent context", but nothing ever read it back.
+const AGENTS_MAX_BYTES = 32 * 1024;
+const AGENTS_FILENAMES = ['AGENTS.md', 'agents.md', 'AGENTS.override.md'];
+
+export const AGENTS_PROMPT_HEADER =
+  'PROJECT INSTRUCTIONS (AGENTS.md). The scope of each file is the directory it sits in,\n'
+  + 'so a deeper file is more specific and takes precedence over a shallower one. They apply\n'
+  + 'to every file you touch under that directory. The current request and the user\'s direct\n'
+  + 'instructions still outrank anything here.'
+
+// Every applicable AGENTS.md, outermost first. `dir` keeps the scope visible.
+export function agentsFilesFor(cwd, workspaceRoot) {
+  const start = path.resolve(cwd || process.cwd());
+  const root = path.resolve(workspaceRoot || start);
+  const dirs = [];
+  let dir = start;
+  for (;;) {
+    dirs.push(dir);
+    const parent = path.dirname(dir);
+    // Stop at the filesystem root, or once we have walked past the workspace.
+    if (parent === dir || dir === root) break;
+    dir = parent;
+  }
+  dirs.reverse();                     // outermost first
+  const found = [];
+  for (const d of dirs) {
+    for (const name of AGENTS_FILENAMES) {
+      const p = path.join(d, name);
+      try {
+        if (!fs.statSync(p).isFile()) continue;
+        found.push({ path: p, dir: d });
+        break;                        // one instruction file per directory
+      } catch { /* not present here */ }
+    }
+  }
+  return found;
+}
+
+// The block injected into the system prompt, or '' when the project has none.
+export function readAgentsMd(cwd, workspaceRoot) {
+  const files = agentsFilesFor(cwd, workspaceRoot);
+  if (!files.length) return '';
+  const parts = [];
+  for (const f of files) {
+    try {
+      let text = fs.readFileSync(f.path, 'utf8').trim();
+      if (!text) continue;
+      if (Buffer.byteLength(text, 'utf8') > AGENTS_MAX_BYTES) {
+        text = Buffer.from(text, 'utf8').subarray(0, AGENTS_MAX_BYTES).toString('utf8') + '\n[truncated]';
+      }
+      parts.push(`--- ${f.path} ---\n${text}`);
+    } catch { /* unreadable: skip rather than fail the turn */ }
+  }
+  if (!parts.length) return '';
+  return AGENTS_PROMPT_HEADER + '\n\n' + parts.join('\n\n');
+}
+
 function loadBaseToml() {
   // Only hncode's own config file participates.
   const f = hncodeConfigFile();
@@ -76,6 +195,11 @@ function loadBaseToml() {
 
 export function resolveConfig() {
   const root = loadBaseToml() || {};
+  // Merge plugin-provided defaults UNDER the user's config: an explicitly set
+  // user value always wins.
+  for (const [k, v] of Object.entries(pluginConfigDefaults || {})) {
+    if (!(k in root)) root[k] = v;
+  }
 
   const providers = root.providers || {};
   const models = root.models || {};
@@ -116,8 +240,11 @@ export function resolveConfig() {
   // The base URL is used EXACTLY as configured — we only append the API path.
   // (No `/v1` is injected: if the user's base ends in /v1, the result is
   // `<base>/chat/completions`; if it doesn't, it's `<base>/chat/completions` too.)
-  const b = baseUrl.replace(/\/+$/, '');
-  const endpoint = protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`;
+const b = baseUrl.replace(/\/+$/, '');
+  // An empty base URL produces a relative endpoint like "/chat/completions",
+  // which fetch() rejects with a URL-scheme error the model can't decode. Leave
+  // the endpoint empty instead so the caller can show "not set".
+  const endpoint = !b ? '' : (protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`);
 
   // Context window: an explicit env/root override wins, then the model's own
   // `contextLength` (discovered from the provider's /v1/models), then the
@@ -146,31 +273,66 @@ export function resolveConfig() {
       // Backwards-compat: read legacy cool_mode key if calm_mode is not set.
       : (root.calm_mode === true || root.calm_mode === 'true'
          || root.cool_mode === true || root.cool_mode === 'true'),
+    // SUBAGENT MODEL (/swarm-sub-agent): the model each subagent runs on. Empty
+    // (the default) means "follow this session's model", which is what the Agent
+    // and AgentSwarm tools fall back to. Set from config.toml so it persists.
+    subagentModel: process.env.HNCODE_SUBAGENT_MODEL || root.subagent_model || '',
     // Plugin directory (default: ~/.hncode/plugins). Set to "" or "false" to
     // disable plugin loading entirely.
     pluginDir: process.env.HNCODE_PLUGINS || root.plugins_dir || '',
+    // AUTO-UPDATE (/auto-update): when true, hncode checks npm for a newer
+    // version at startup and then every 30 minutes, installing in the background
+    // without interrupting the session.
+    autoUpdate: process.env.HNCODE_AUTO_UPDATE
+      ? /^(1|true|yes|on)$/i.test(process.env.HNCODE_AUTO_UPDATE)
+      : (root.auto_update === true || root.auto_update === 'true'),
     raw: root,
   };
 }
 
 export function saveConfig(overlay) {
   const dir = hncodeConfigFile();
+  const entries = Object.entries(overlay || {});
+  if (entries.length === 0) return dir;
+  // Render the overlay to TOML lines, preserving key order.
   let out = '';
-  for (const [k, v] of Object.entries(overlay)) out += toTomlLine(k, v) + '\n';
+  for (const [k, v] of entries) out += toTomlLine(k, v) + '\n';
   fs.mkdirSync(path.dirname(dir), { recursive: true });
-  
+
   // Check if file exists and has content
   try {
     if (fs.statSync(dir).isFile()) {
       const existing = fs.readFileSync(dir, 'utf8');
       if (existing.trim().length > 0) {
-        // Append to existing config instead of overwriting
-        fs.writeFileSync(dir, existing + '\n' + out, 'utf8');
+        // Append to existing config instead of overwriting — but only for keys
+        // that are NOT already present as top-level lines, so two saveConfig
+        // calls for the same key never produce duplicate keys. Reuse the same
+        // "top-level before any [table] header" rule as setConfigString.
+        const keys = new Set(entries.map(([k]) => k));
+        const lines = existing.split(/\r?\n/);
+        const seen = new Set();       // top-level keys already in the file
+        let inTable = false;
+        for (const ln of lines) {
+          if (/^\s*\[/.test(ln)) inTable = true;
+          if (!inTable) {
+            const km = /^\s*([A-Za-z0-9_]+)\s*=\s*/.exec(ln);
+            if (km) seen.add(km[1]);
+          }
+        }
+        // Nothing to add: every overlay key is already present top-level.
+        let add = '';
+        for (const [k, v] of entries) {
+          if (!seen.has(k)) add += toTomlLine(k, v) + '\n';
+        }
+        if (add) {
+          const sep = existing.endsWith('\n') ? '' : '\n';
+          fs.writeFileSync(dir, existing + sep + '\n' + add.trimEnd() + '\n', 'utf8');
+        }
         return dir;
       }
     }
   } catch {}
-  
+
   // New file or empty file
   fs.writeFileSync(dir, out, 'utf8');
   return dir;
@@ -506,6 +668,20 @@ export function effectiveSnapshot(cfg) {
 // sub-table takes precedence (it's the point of switching); env vars set at boot
 // are already baked into `cfg` and only remain in effect when the provider table
 // does not override a given field.
+// Recompute the context window for a given model key. `resolveConfig` picks the
+// window from the model's [models.*] entry (context_length), an env/root
+// override, or the default. resolveProvider / resolveModelArg must reuse the
+// SAME rule when the user switches provider/model mid-session, otherwise the
+// status-bar context gauge (state.ctxMax) keeps the stale previous model's value.
+function contextForModel(cfg, modelName) {
+  const root = (cfg && cfg.raw) || {};
+  const models = (root.models) || {};
+  const overrideContext = process.env.HNCODE_MAX_CONTEXT || root.max_context_size || root.max_context_tokens;
+  const entry = models[modelName] || {};
+  const modelContext = Number(entry.contextLength || entry.context_length || entry.max_context_size || 0);
+  return Number(overrideContext || modelContext || DEFAULTS.maxContextTokens);
+}
+
 export function resolveProvider(cfg, providerName, innerModel) {
   const pr = (cfg.raw && cfg.raw.providers) || {};
   const prov = pr[providerName] || {};
@@ -514,8 +690,11 @@ export function resolveProvider(cfg, providerName, innerModel) {
   const protocol = (prov.protocol) || cfg.protocol;
   const inner = prov.model || (innerModel != null ? innerModel : cfg.innerModel);
   const b = String(baseUrl || '').replace(/\/+$/, '');
-  const endpoint = protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`;
-  return { ...cfg, provider: providerName, innerModel: inner, baseUrl: b, endpoint, apiKey, protocol };
+  const endpoint = !b ? '' : (protocol === 'anthropic' ? `${b}/messages` : `${b}/chat/completions`);
+  // Provider switch may move the active model too; refresh the context window
+  // so the gauge reflects the newly active model, not the old one.
+  const maxContextTokens = contextForModel(cfg, cfg.model);
+  return { ...cfg, provider: providerName, innerModel: inner, baseUrl: b, endpoint, apiKey, protocol, maxContextTokens };
 }
 
 // Switch model, optionally moving to a provider declared via [models.NAME].
@@ -527,7 +706,9 @@ export function resolveModelArg(cfg, modelName) {
   const entry = models[modelName] || {};
   const provider = entry.provider || cfg.provider;
   const inner = bareModelId(provider, modelName, entry);
-  return { ...resolveProvider(cfg, provider, inner), model: modelName };
+  // Refresh the context window for the newly selected model.
+  const maxContextTokens = contextForModel(cfg, modelName);
+  return { ...resolveProvider(cfg, provider, inner), model: modelName, maxContextTokens };
 }
 
 export default { resolveConfig, saveConfig, effectiveSnapshot, resolveProvider, resolveModelArg, addProvider, removeProvider, addModel, fetchModels, fetchCatalog, modelKey, modelLabel, bareModelId, rememberModel, hncodeConfigFile };

package/src/index.js

@@ -3,13 +3,16 @@
 import os from 'node:os';
 import path from 'node:path';
 import fs from 'node:fs';
-import { resolveConfig, effectiveSnapshot, saveConfig, resolveModelArg } from './config.js';
+import { resolveConfig, effectiveSnapshot, saveConfig, resolveModelArg, readPersonalPrompt } from './config.js';
 import * as sess from './session.js';
 import { Agent, SYSTEM_PROMPT } from './agent.js';
 import { llmTools } from './tools/index.js';
 import { setToolsList } from './llm.js';
+import { localVersion } from './version.js';
 
-export const VERSION = '0.1.0';
+// The version shown by `hncode -V` and the help banner. Read from package.json
+// (via version.js) so it can never drift from the published version again.
+export const VERSION = localVersion();
 
 const HELP = `hncode ${VERSION} — a Kimi Code-style coding agent.
 
@@ -53,17 +56,31 @@ export function parseArgs(argv) {
       else { key = a.slice(2); val = null; }
       if (key === 'resume') key = 'session'; // `--resume <id>` is an alias for `--session <id>`
       if (['session'].includes(key) && val === null) { const nx = argv[i + 1]; out[key] = nx !== undefined && !nx.startsWith('-') ? (i++, nx) : true; }
-      else if (key === 'model' || key === 'prompt' || key === 'output-format' || key === 'add-dir') {
-        if (val === null) { val = argv[++i]; }
-        out[key] = key === 'add-dir' ? (out[key] || []).concat([val]) : val;
+else if (key === 'model' || key === 'prompt' || key === 'output-format' || key === 'add-dir') {
+        if (val === null) {
+          const nx = argv[i + 1];
+          // Only consume the next token if it is a real value, not another flag
+          // or the end of argv. Previously `--model -y` and a trailing `--model`
+          // swallowed or mangled the value, breaking the real flag.
+          val = (nx !== undefined && !nx.startsWith('-')) ? argv[++i] : undefined;
+        }
+out[key] = (key === 'add-dir' && val !== undefined)
+        ? (out[key] || []).concat([val])
+        : val;
       } else if (val !== null) { out[key] = val === 'true' ? true : val === 'false' ? false : val; }
       else out[key] = true;
     } else if (a.startsWith('-') && a.length > 1) {
       const key = a.slice(1);
       const short = { V: 'version', S: 'session', c: 'continue', y: 'yolo', auto: 'auto', m: 'model', p: 'prompt', h: 'help' };
-      if (key === 'S' || key === 'm' || key === 'p') {
-        let val = argv[++i];
-        out[short[key]] = val;
+if (key === 'S' || key === 'm' || key === 'p') {
+        const nx = argv[i + 1];
+        // Take the next token as the value only if it exists and is not another
+        // flag. Previously `-S -y` swallowed `-y` as the session id and a bare
+        // trailing `-m` became undefined; both silently broke the real flag.
+        const hasVal = nx !== undefined && !nx.startsWith('-');
+        if (hasVal) { out[short[key]] = argv[i + 1]; i++; }
+        else if (key === 'S') { out.session = true; }  // "-S" with no id => pick interactively
+        // '-m' / '-p' with no usable value: leave unset (same as a missing arg).
       } else out[short[key]] = true;
     } else {
       out.positional.push(a);
@@ -171,7 +188,12 @@ async function runPrompt({ cfg, prompt, format, session, modelArg }) {
   }
   const messages = [];
   if (session && session.messages) for (const m of session.messages.slice(-30)) messages.push(m);
-  messages.push({ role: 'system', content: SYSTEM_PROMPT });
+  // Same layering as the TUI: built-in prompt first, then the user's own
+  // system_prompt override if any, then the /personal notes, then calm mode.
+  let sysText = (cfg.systemPrompt && String(cfg.systemPrompt).trim()) || SYSTEM_PROMPT;
+  const personal = readPersonalPrompt(cfg.workspace);
+  if (personal) sysText += '\n\n' + personal;
+  messages.push({ role: 'system', content: sysText });
   const saved = session || { id: sess.newId(), title: prompt.slice(0, 60), workspace: path.resolve(process.cwd()), model: cfg.model, createdAt: Date.now(), messages: [] };
   const agent = new Agent({
     cfg,

package/src/llm.js

@@ -111,7 +111,23 @@ let llmToolsList = [];
 export function setToolsList(list) { llmToolsList = list; }
 
 export class LLM {
-  constructor(cfg) { this.cfg = cfg; this.controller = null; }
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.controller = null;
+    // Inline-reasoning state carried ACROSS requests. Our system prompt tells the
+    // model to put all its reasoning inside one <think> span, and tool calls happen
+    // inside that span — so the span outlives a single request. Reset when the turn
+    // ends (see resetThink).
+    this._inThink = false;
+    this._tagPending = '';
+  }
+
+  // Called by the agent at the end of a turn: the next turn starts a fresh
+  // reasoning block, even if the previous one never saw its closing tag.
+  resetThink() {
+    this._inThink = false;
+    this._tagPending = '';
+  }
 
   // Abort an in-flight request (Esc / Ctrl-C while the agent is running).
   abort() {
@@ -219,7 +235,15 @@ export class LLM {
     const reader = res.body.getReader();
     const decoder = new TextDecoder();
     let buf = '';
-    const state = { tools: new Map(), indexToId: {}, doneEmitted: false };
+    // The inline-reasoning state (`inThink` / `tagPending`) is carried on the LLM
+    // instance, NOT recreated per request. A model that opens <think>, runs a tool,
+    // and only writes </think> in the NEXT step would otherwise have everything
+    // after the tool call reclassified as the ANSWER — the reasoning text and the
+    // literal `</think>` tag both showed up in the transcript.
+    const state = {
+      tools: new Map(), indexToId: {}, doneEmitted: false,
+      inThink: !!this._inThink, tagPending: this._tagPending || '',
+    };
     try {
       while (true) {
         const { done, value } = await reader.read();
@@ -242,6 +266,12 @@ export class LLM {
       return;
     } finally {
       reader.releaseLock?.();
+      // Carry the inline-reasoning state forward on EVERY exit path — a normal end,
+      // [DONE], an abort and an error all pass through here. The model may resume an
+      // open <think> span after a tool call in the next step, so this belongs to the
+      // turn, not to one request.
+      this._inThink = !!state.inThink;
+      this._tagPending = state.tagPending || '';
     }
     finish(state, onEvent);
   }
@@ -249,15 +279,28 @@ export class LLM {
 
 // ---- inline reasoning tags -------------------------------------------------
 // Some OpenAI-compatible servers do not send a separate `reasoning_content`
-// field: they put the chain of thought INLINE in `content`, wrapped in a tag
-// such as ` thinking…<｜end▁of▁thinking｜>` or `<thinking>…</thinking>`. Without splitting
-// those out, the raw tags and the whole reasoning trace are rendered as the
-// assistant's answer (and counted as output tokens). This is a streaming state
-// machine: a tag can be split across chunks, so a trailing partial tag is held
-// back until the next chunk decides what it is.
-const THINK_OPEN_TAGS = [' thinking', '<thinking>'];
+// field: they put the chain of thought INLINE in `content`, wrapped in a tag.
+// Three spellings have to be supported, because they come from three places:
+//   ` thinking…`                 — the DeepSeek-R1 token markers, as emitted by
+//                               vLLM / llama.cpp builds of that model
+//   `<thinking>…</thinking>`    — what several OpenAI-compatible servers wrap it in
+//   `<think>…</think>`          — what OUR OWN system prompt asks for (agent.js
+//                               and prompt-presets.js both instruct this)
+// The last one was missing, so a model that followed our prompt had its whole
+// reasoning trace rendered as the ANSWER, raw tags and all.
+//
+// The three are mutually distinguishable, which is what makes supporting all of
+// them safe: `</think>` does not occur inside `</thinking>`, `<think>` does not
+// occur inside `<thinking>`, and `' thinking'` does not occur inside `<think>`.
+// So an early match can never be caused by the longer tag.
+//
+// Without splitting these out, the raw tags and the whole reasoning trace are
+// rendered as the assistant's answer (and counted as output tokens). This is a
+// streaming state machine: a tag can be split across chunks, so a trailing partial
+// tag is held back until the next chunk decides what it is.
+const THINK_OPEN_TAGS = [' thinking', '<thinking>', '<think>'];
 // Closing tags. If none of these appear, the block stays in think mode to EOI.
-const THINK_CLOSE_TAGS = ['<｜end▁of▁thinking｜>', '</thinking>'];
+const THINK_CLOSE_TAGS = ['<｜end▁of▁thinking｜>', '</thinking>', '</think>'];
 
 // Longest suffix of `buf` that is a proper prefix of one of `tags`.
 // A single trailing space is deliberately NOT a candidate: `' '` is a prefix of
@@ -313,7 +356,13 @@ function flushContent(onEvent, state) {
 function finish(state, onEvent) {
   // close any tool calls that started but never got an explicit end
   if (state.doneEmitted) return;
-  flushContent(onEvent, state);
+  // A still-OPEN reasoning block is deliberately NOT flushed here. The model can
+  // continue it after a tool call in the next step — our own system prompt tells it
+  // to put ALL reasoning in one <think> span, and tool calls happen inside that
+  // span. Flushing would dump the held-back partial tag and end the block early, so
+  // the rest of the reasoning would be reclassified as the ANSWER. The caller keeps
+  // `inThink`/`tagPending` on the LLM instance and the block resumes there.
+  if (!state.inThink) flushContent(onEvent, state);
   for (const [, t] of state.tools) {
     if (!t.done) onEvent({ type: 'tool_end', id: t.id });
   }

package/src/plugin.js

@@ -125,6 +125,15 @@ export async function loadPlugins(dir) {
   const pluginDir = dir || PLUGIN_DIR;
   if (!fs.existsSync(pluginDir)) return [];
 
+  // loadPlugins() may be called more than once (tests, hot reload). Reset the
+  // registries first so a second load cannot throw "tool already registered"
+  // and accumulate stale hooks/config over reloads.
+  registeredTools.length = 0;
+  registeredCommands.length = 0;
+  for (const k of Object.keys(registeredHooks)) delete registeredHooks[k];
+  for (const k of Object.keys(registeredConfig)) delete registeredConfig[k];
+  loadedPlugins.length = 0;
+
   const files = fs.readdirSync(pluginDir)
     .filter((f) => f.endsWith('.js') || f.endsWith('.mjs'))
     .sort();
@@ -143,8 +152,18 @@ export async function loadPlugins(dir) {
         continue;
       }
 
-      const meta = (mod.default && (mod.default.name || mod.default.meta)) || { name: f };
-      const plugin = { id: f, name: meta.name || f, version: meta.version || '0.0.0' };
+      // Metadata comes from the default export. `name` there is a plain STRING
+      // (`export default { name: 'recorder' }`), so reading `meta.name` off it
+      // returned undefined and the plugin showed up as its FILENAME with version
+      // 0.0.0 — /plugins listed every plugin under the wrong name. Accept both
+      // shapes: a string name, or an object carrying { name, version }.
+      const def = (mod && mod.default) || {};
+      const meta = typeof def === 'string' ? { name: def } : def;
+      const plugin = {
+        id: f,
+        name: meta.name || meta.meta?.name || f,
+        version: meta.version || meta.meta?.version || '0.0.0',
+      };
       loadedPlugins.push(plugin);
       installFn(API);
       // eslint-disable-next-line no-console
@@ -179,6 +198,10 @@ export async function runHooks(name, ...args) {
 // ---------------------------------------------------------------------------
 
 export { API, registeredTools as pluginTools, registeredCommands as pluginCommands };
+// Plugin-provided config DEFAULTS. resolveConfig() must merge these BEFORE
+// user config so a plugin can supply a value the user has not set. Previously
+// registerConfig() stored into this object and nothing ever read it.
+export { registeredConfig as pluginConfigDefaults };
 
 // Reset state — useful for tests.
 export function _resetPlugins() {