@north-light/crouter 0.3.187 → 0.3.188

package/dist/core/__tests__/plugin-kinds.test.js

@@ -85,6 +85,19 @@ test('the scope\u2019s own config.json overrides its plugins; a disabled plugin
     assert.equal(kinds['applet-builder']?.whenToUse, 'plugin gloss'); // patch merges, not replaces
     assert.equal(kinds['ghost'], undefined);
 });
+test('a whenToUse-only entry re-glosses an existing kind without stripping its model tier', () => {
+    // The pre-change footgun: `{whenToUse}` parsed as a FULL entry and wholly
+    // replaced the kind, silently dropping explore off its cheap model tier.
+    // Now every entry field-merges over an existing kind; only a NEW kind
+    // requires whenToUse (a whenToUse-less new kind is dropped).
+    const root = userRoot();
+    writeFileSync(join(root, 'config.json'), JSON.stringify({ kinds: { explore: { whenToUse: 'custom explore gloss' }, 'new-glossless': { model: 'openai/light' } } }));
+    const kinds = readMergedLaunchConfig().kinds;
+    assert.equal(kinds['explore']?.whenToUse, 'custom explore gloss');
+    assert.equal(kinds['explore']?.model, 'openai/light'); // builtin tier survives
+    assert.equal(kinds['explore']?.orchestratorModel, 'anthropic/strong');
+    assert.equal(kinds['new-glossless'], undefined);
+});
 test('a project-root plugin layers above user config, and the project config above the plugin', () => {
     const uRoot = userRoot();
     writeFileSync(join(uRoot, 'config.json'), JSON.stringify({ kinds: { shared: { whenToUse: 'user gloss', model: 'openai/light' } } }));

package/dist/core/config.js

@@ -265,42 +265,20 @@ function mergeSpawnEnv(raw, base = []) {
     }
     return { allow: [...new Set([...base, ...extra])] };
 }
-/** Validate one raw `kinds.<name>` entry into a `KindConfig`, or drop it
- *  (return null) rather than throwing — an invalid kind entry in config.json
- *  must not break config parsing for every other kind. `whenToUse` is the
- *  only required field. */
-function normalizeKindEntry(raw) {
-    if (raw === null || typeof raw !== 'object')
-        return null;
-    const r = raw;
-    if (typeof r.whenToUse !== 'string' || r.whenToUse.trim() === '')
-        return null;
-    const out = { whenToUse: r.whenToUse };
-    if (typeof r.model === 'string' && r.model.trim() !== '')
-        out.model = r.model;
-    if (typeof r.orchestratorModel === 'string' && r.orchestratorModel.trim() !== '')
-        out.orchestratorModel = r.orchestratorModel;
-    const isStringArray = (v) => Array.isArray(v) && v.every((item) => typeof item === 'string');
-    if (isStringArray(r.tools))
-        out.tools = r.tools;
-    if (isStringArray(r.extensions))
-        out.extensions = r.extensions;
-    if (isStringArray(r.availableTo))
-        out.availableTo = r.availableTo;
-    return out;
-}
-/** Validate one raw `kinds.<name>` entry as a sparse PATCH — an entry with no
- *  `whenToUse` that overrides individual launch knobs (model/orchestratorModel/
- *  tools/extensions/availableTo) of a kind some lower-precedence scope already
- *  defines. This is what lets a scope (e.g. a profile) persist ONLY
- *  `{ "model": "ultra" }` for a kind instead of freezing a full registry
- *  snapshot to disk (the same staleness trap `sparseModelLaddersToPersist`
- *  exists to avoid). Returns null when no valid field is present. */
-function normalizeKindPatch(raw) {
+/** Collect the valid `KindConfig` fields of one raw `kinds.<name>` entry —
+ *  every field is optional here, `whenToUse` included; mistyped fields are
+ *  dropped, never thrown (an invalid field in config.json must not break
+ *  config parsing for every other kind — the loud gate is install time, see
+ *  `invalidPluginKindsReasons`). Returns null when no valid field is present.
+ *  Whether `whenToUse` is REQUIRED is `mergeKinds`'s call: only an entry that
+ *  introduces a kind no lower layer defines needs one. */
+function normalizeKindFields(raw) {
     if (raw === null || typeof raw !== 'object')
         return null;
     const r = raw;
     const out = {};
+    if (typeof r.whenToUse === 'string' && r.whenToUse.trim() !== '')
+        out.whenToUse = r.whenToUse;
     if (typeof r.model === 'string' && r.model.trim() !== '')
         out.model = r.model;
     if (typeof r.orchestratorModel === 'string' && r.orchestratorModel.trim() !== '')
@@ -315,29 +293,31 @@ function normalizeKindPatch(raw) {
     return Object.keys(out).length > 0 ? out : null;
 }
 /** Merge a raw `kinds` block over `base` (defaulting to the builtin registry):
- *  each valid entry adds or shadows a kind by name; invalid entries are
- *  dropped, never thrown. Mirrors `mergeModelLadders`'s layer-over-defaults
- *  shape so a user/project config.json can add or override a single kind
- *  without restating the whole registry. Two entry shapes:
- *   - FULL (has `whenToUse`): defines or wholly replaces the kind, as before.
- *   - PATCH (no `whenToUse`, ≥1 valid launch field): field-merges over the
- *     kind the layers below already define (dropped when they don't) — the
- *     sparse-override shape `persistDefaultKindModel` writes. */
+ *  invalid entries are dropped, never thrown. Mirrors `mergeModelLadders`'s
+ *  layer-over-defaults shape so a config layer can add or override a single
+ *  kind without restating the whole registry. One rule, no entry shapes:
+ *   - A kind some lower layer already defines: the entry FIELD-MERGES over it
+ *     — any subset of fields, `whenToUse` included, so overriding just the
+ *     spawn-menu guidance of a builtin kind never strips its model tier
+ *     (the sparse-override shape `persistDefaultKindModel` writes).
+ *   - A NEW kind: the entry defines it and must carry `whenToUse` (a kind
+ *     with no spawn-menu gloss is meaningless); dropped otherwise.
+ *  Deliberately NOT expressible: wholly replacing a lower layer's kind — a
+ *  field can be overridden but never removed by omission. */
 function mergeKinds(raw, base = defaultKindsConfig()) {
     const out = { ...base };
     if (raw !== null && typeof raw === 'object') {
         for (const [kind, value] of Object.entries(raw)) {
-            const normalized = normalizeKindEntry(value);
-            if (normalized !== null) {
-                out[kind] = normalized;
+            const fields = normalizeKindFields(value);
+            if (fields === null)
                 continue;
-            }
             const existing = out[kind];
-            if (existing === undefined)
-                continue;
-            const patch = normalizeKindPatch(value);
-            if (patch !== null)
-                out[kind] = { ...existing, ...patch };
+            if (existing !== undefined) {
+                out[kind] = { ...existing, ...fields };
+            }
+            else if (fields.whenToUse !== undefined) {
+                out[kind] = fields;
+            }
         }
     }
     return out;
@@ -401,14 +381,14 @@ export function invalidPluginKindsReasons(raw) {
                 reasons.push(`kinds.${kind}.${field} must be an array of strings`);
             }
         }
-        if (normalizeKindEntry(value) === null && normalizeKindPatch(value) === null) {
-            reasons.push(`kinds.${kind} is neither a full kind (whenToUse required) nor a patch with at least one launch field`);
+        if (normalizeKindFields(value) === null) {
+            reasons.push(`kinds.${kind} has no valid KindConfig field — an entry must set at least one of: ${[...KIND_CONFIG_KEYS].join(', ')} (whenToUse is required when the kind exists in no lower layer)`);
         }
     }
     return reasons;
 }
 /** Validate one raw `remoteCanvas.targets.<name>` entry, or drop it (return
- *  null) rather than throwing — same rule `normalizeKindEntry` follows. A
+ *  null) rather than throwing — same rule `normalizeKindFields` follows. A
  *  valid entry needs a non-empty `previewEndpoint` and `relayTokenRef`; the
  *  token itself is never stored here (see `RemoteCanvasTarget`). */
 function normalizeRemoteCanvasTarget(raw) {

package/dist/types.d.ts

@@ -35,9 +35,11 @@ export interface PluginManifest {
     owner?: OwnerRef;
     /** Kind-registry contributions, keyed by full kind string (top-level e.g.
      *  `applet-builder`, or sub-kind e.g. `plan/reviewers/security`). Each entry
-     *  is either a FULL `KindConfig` (has `whenToUse`: defines or wholly shadows
-     *  the kind) or a sparse PATCH over a kind a lower layer already defines —
-     *  the same two shapes a scope `config.json` `kinds` block accepts.
+     *  is any subset of `KindConfig` fields: it FIELD-MERGES over a kind a lower
+     *  layer already defines (`whenToUse` included — overriding just the spawn
+     *  guidance never strips the kind's model tier), and defines a NEW kind when
+     *  none does (then `whenToUse` is required) — the same rule a scope
+     *  `config.json` `kinds` block follows.
      *  `readMergedLaunchConfig` layers an enabled plugin's entries directly
      *  above the builtin registry and below its host scope's own `config.json`,
      *  so a plugin can ship a persona kind (registry entry here + gated persona

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.187",
+  "version": "0.3.188",
   "description": "crtr — agent runtime with memory, plugins, and marketplaces",
   "type": "module",
   "main": "dist/index.js",

package/runtime.lock.json

@@ -1,12 +1,12 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.187",
+  "version": "0.3.188",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.187",
+      "version": "0.3.188",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {