@north-light/crouter 0.3.280 → 0.3.281

package/dist/core/__tests__/model-pin-durability.test.js

@@ -86,8 +86,8 @@ test('only concrete provider/id tokens pin; logical family/tier refs remain pref
     assert.equal(isProviderPinnedModelToken('ultra'), false, 'a bare tier has no `/` and stays unpinned');
     assert.equal(isProviderPinnedModelToken('opus'), false, 'a bare family alias has no `/` and stays unpinned');
 });
-test('a new --model override resolves once and freezes portable and concrete requests', () => {
-    for (const requested of ['anthropic/opus', 'strong', 'anthropic/claude-fable-5:high']) {
+test('a new --model override freezes a concrete pick', () => {
+    for (const requested of ['anthropic/claude-fable-5:high', 'openai-codex/gpt-5.6-sol:max']) {
         const launch = buildSpec({ model: requested, modelOverride: true });
         assert.equal(launch.model, normalizeModel(requested, ladders), `${requested} resolves through the configured ladder`);
         assert.equal(launch.modelExact, true, `${requested} is exact after resolution`);
@@ -95,6 +95,21 @@ test('a new --model override resolves once and freezes portable and concrete req
         assert.equal(launch.env.CRTR_MODEL_INTENT, undefined, `${requested} cannot re-enable fallback on revive`);
     }
 });
+// A strength word is a preference, not a model identity. Freezing it made every
+// `--model medium` child fail closed on a canvas whose only authenticated route
+// belonged to another provider, while a sibling that passed no --model routed
+// fine. Exactness now follows the raw token's shape, not the mere presence of
+// an override.
+test('a new --model override keeps a portable ladder token routable', () => {
+    for (const requested of ['medium', 'strong', 'anthropic/opus', 'opus']) {
+        const launch = buildSpec({ model: requested, modelOverride: true });
+        assert.equal(launch.model, normalizeModel(requested, ladders), `${requested} resolves through the configured ladder`);
+        assert.equal(launch.modelExact, undefined, `${requested} is a preference, so it must not fail closed`);
+        assert.notEqual(launch.modelIntent, undefined, `${requested} keeps its route intent`);
+        assert.equal(launch.env.CRTR_MODEL_INTENT, `${launch.modelIntent.family}/${launch.modelIntent.strength}`, `${requested} hands the broker the intent route fallback needs`);
+        assert.equal(launch.modelProviderPinned, false, `${requested} names no provider to pin to`);
+    }
+});
 // Direction 1: an EXPLICIT concrete pin must SURVIVE a config/lifecycle rebuild
 // even when the carried override has portablized back to a bare tier.
 test('an explicit concrete pin survives a config/lifecycle rebuild whose portablized override reads as a bare tier', () => {
@@ -112,7 +127,7 @@ test('an explicit concrete pin survives a config/lifecycle rebuild whose portabl
 // Direction 2: a deliberately TIER-run (unpinned) node must NOT be wrongly
 // re-pinned when a subsequent rebuild/persist normalizes its override to the
 // concrete cell it happens to share bytes with.
-test('reshape resolves and persists a new --model override as the exact revive recipe', () => {
+test('reshape resolves a new --model override and keeps a family alias routable', () => {
     createNode(node('override-node', {
         model_override: 'strong',
         launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'anthropic/strong' }, model: normalizeModel('strong', ladders), modelIntent: { family: 'anthropic', strength: 'strong' } },
@@ -122,6 +137,19 @@ test('reshape resolves and persists a new --model override as the exact revive r
     const expected = normalizeModel('anthropic/opus', ladders);
     assert.equal(after?.model_override, expected, 'the raw alias never becomes the durable override');
     assert.equal(after?.launch?.model, expected, 'revive replays the resolved provider/model');
+    assert.equal(after?.launch?.modelExact, undefined, 'a family alias is a preference, so revive may still route');
+    assert.deepEqual(after?.launch?.modelIntent, { family: 'anthropic', strength: 'strong' }, 'the route intent follows the new alias');
+    assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, 'anthropic/strong');
+});
+test('reshape freezes a new concrete --model override as the exact revive recipe', () => {
+    createNode(node('concrete-override-node', {
+        model_override: 'strong',
+        launch: { extensions: [], env: { CRTR_MODEL_INTENT: 'anthropic/strong' }, model: normalizeModel('strong', ladders), modelIntent: { family: 'anthropic', strength: 'strong' } },
+    }));
+    reshapeNode('concrete-override-node', { model: 'anthropic/claude-fable-5:high' });
+    const after = getNode('concrete-override-node');
+    assert.equal(after?.model_override, 'anthropic/claude-fable-5:high', 'the concrete pick is the durable override');
+    assert.equal(after?.launch?.model, 'anthropic/claude-fable-5:high', 'revive replays the exact spec');
     assert.equal(after?.launch?.modelExact, true, 'retries and revives reject substitutes');
     assert.equal(after?.launch?.modelIntent, undefined);
     assert.equal(after?.launch?.env.CRTR_MODEL_INTENT, undefined);

package/dist/core/runtime/launch.d.ts

@@ -68,8 +68,13 @@ export interface LaunchBuildOptions {
     /** A newly supplied `--model` override. Resolve it through the target
      *  ladder and any quality floor once, then freeze the resulting concrete
      *  provider/id[:thinking] spec into the launch recipe so every launch,
-     *  revive, and retry consults exactly that model. Existing recipes instead
-     *  carry `modelExact`/`modelIntent` below verbatim. */
+     *  revive, and retry consults exactly that model — but ONLY when the raw
+     *  token names a concrete model. A PORTABLE ladder token (`medium`,
+     *  `anthropic/opus`) is a strength preference, not a model identity, so it
+     *  keeps its route intent and stays eligible for fallback; freezing it
+     *  would fail a node closed on a canvas whose only authenticated route is a
+     *  different provider. Existing recipes instead carry
+     *  `modelExact`/`modelIntent` below verbatim. */
     modelOverride?: boolean;
     /** The TARGET node's cwd — anchors the project-scope stack for kind/ladder
      *  resolution. Defaults to this process's own cwd, which is correct only

package/dist/core/runtime/launch.js

@@ -251,7 +251,8 @@ function buildLaunchSpecFromMerged(kind, mode, opts, merged) {
     const ladders = merged.modelLadders;
     const kindModel = mode === 'orchestrator' ? kindConfig?.orchestratorModel ?? kindConfig?.model : kindConfig?.model;
     const chosenModel = opts.modelExact === true ? opts.model : floorReviewModel(kind, opts.model, kindModel, ladders);
-    const exact = opts.modelExact === true || opts.modelOverride === true;
+    const exact = opts.modelExact === true
+        || (opts.modelOverride === true && opts.model !== undefined && !isPortableModelToken(opts.model));
     const resolvedModel = opts.modelExact === true
         ? chosenModel
         : (chosenModel !== undefined ? normalizeModel(chosenModel, ladders) : undefined);

package/dist/daemon/api/__tests__/node-model-validation.test.js

@@ -103,7 +103,12 @@ test('promote and yield reject unregistered model recipes before reshaping the n
         assert.equal(after?.mode, before?.mode, `${operation} did not reshape the node`);
     }
 });
-test('promote and yield reject an unregistered resolved portable override before reshaping the node', async () => {
+// A portable override names a strength, not a model identity, so it is a route
+// request: the registry cannot pre-judge it, and the broker resolves it against
+// whichever route is authenticated at launch. Gating it on the ladder cell being
+// registered is what killed every `--model medium` child on a canvas whose only
+// authenticated route belonged to another provider.
+test('promote and yield accept a portable override whose ladder cell is unregistered', async () => {
     const cwd = join(home, 'target-project');
     mkdirSync(join(cwd, '.crouter'), { recursive: true });
     writeFileSync(join(cwd, '.crouter', 'config.json'), JSON.stringify({
@@ -113,14 +118,15 @@ test('promote and yield reject an unregistered resolved portable override before
     for (const operation of ['promote', 'yield']) {
         const id = `${operation}-portable-model`;
         createNode(node(id, cwd));
-        const before = getNode(id);
         const request = ctx('POST', `/v1/nodes/${id}/${operation}`, id, { model: 'openai/strong' });
-        await assert.rejects(() => operation === 'promote'
-            ? handlePromote(request, { modelRegistry: registry })
-            : handleYield(request, { modelRegistry: registry }), (error) => error instanceof CrtrError && error.code === 'usage' && /target-openai\/missing-strong/.test(error.message));
+        if (operation === 'promote')
+            await handlePromote(request, { modelRegistry: registry });
+        else
+            await handleYield(request, { modelRegistry: registry });
         const after = getNode(id);
-        assert.deepEqual(after?.launch, before?.launch, `${operation} did not rewrite the launch recipe`);
-        assert.equal(after?.mode, before?.mode, `${operation} did not reshape the node`);
+        assert.equal(after?.launch?.model, 'target-openai/missing-strong', `${operation} resolves the tier against the target scope`);
+        assert.equal(after?.launch?.modelExact, undefined, `${operation} leaves the strength request routable`);
+        assert.deepEqual(after?.launch?.modelIntent, { family: 'openai', strength: 'strong' }, `${operation} keeps the route intent`);
     }
 });
 test('config normalizes portable models against the target node scope', async () => {
@@ -151,5 +157,7 @@ test('config normalizes portable models against the target node scope', async ()
     await handleConfig(ctx('PATCH', `/v1/nodes/${id}/config`, id, { model: 'openai/strong' }), { modelRegistry: registry });
     assert.equal(getNode(id)?.model_override, 'target-openai/o-strong');
     assert.equal(getNode(id)?.launch?.model, 'target-openai/o-strong');
+    // `config --model` records exactness in the model-swap path (updateModelRecipe),
+    // not in buildLaunchSpec, so a live user's pick freezes whatever its shape.
     assert.equal(getNode(id)?.launch?.modelExact, true, 'a config override cannot route away on revive');
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@north-light/crouter",
-  "version": "0.3.280",
+  "version": "0.3.281",
   "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.280",
+  "version": "0.3.281",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@north-light/crouter",
-      "version": "0.3.280",
+      "version": "0.3.281",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {