@ordewell/core 0.4.22 → 0.4.23

package/dist/index.js

@@ -5589,10 +5589,10 @@ function checkModelAndModeValidity(runner, assignedModel, taskMode, catalog) {
     const models = catalog.modelsByRunner[runner];
     if (models) {
       const modelId = assignedModel.modelId;
-      if (!models.some((m) => m.modelId === modelId)) {
+      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
+      if (!models.some((m) => m.modelId === modelId) && !allowed?.includes(modelId)) {
         return { ok: false, error: `Runner "${runner}" does not offer model "${modelId}"` };
       }
-      const allowed = effectiveAllowlist(catalog.perRunnerAllowlist?.[runner], runner, catalog.modelsByRunner);
       if (allowed && !allowed.includes(modelId)) {
         return { ok: false, error: `Model "${modelId}" is excluded by the allowlist for runner "${runner}"` };
       }
@@ -13314,7 +13314,6 @@ var Session = class {
   approvalPolicy;
   fetcher;
   settingsFn;
-  currentAllowlist = {};
   /** Last discovered model catalog — lets sync plan commits clamp thinking efforts to real variants. */
   modelsCache = {};
   unsubObserver = null;
@@ -13519,7 +13518,6 @@ var Session = class {
     this.beginFreshPlan();
     this.approvalPolicy.reset();
     this.modelsCache = {};
-    this.currentAllowlist = {};
     this.remintSessionId();
   }
   runnerModesFor(runners) {
@@ -13529,17 +13527,41 @@ var Session = class {
    * The catalog a model/task-mode edit is checked against — the same
    * discovered models and manifest modes the per-turn catalog block shows the
    * planner, so a refusal here can never name something invalid that the
-   * planner was never told about. `modelsCache` is read live, not filtered by
-   * the allowlist here — {@link checkModelAndModeValidity} narrows by
+   * planner was never told about. The catalog is not filtered by the
+   * allowlist here — {@link checkModelAndModeValidity} narrows by
    * allowlist itself, the same way `coerceAssignments` does.
    */
   editCatalog() {
     return {
-      modelsByRunner: this.modelsCache,
+      modelsByRunner: this.models(),
       runnerModes: this.runnerModesFor(this.plan?.runners ?? []),
-      perRunnerAllowlist: this.settingsFn().modelAllowlist ?? this.currentAllowlist
+      perRunnerAllowlist: this.allowlist()
     };
   }
+  /**
+   * The allowlist in force right now. Unset means no restriction — falling
+   * back to the one planning started under would keep a restriction the user
+   * has since cleared.
+   */
+  allowlist() {
+    return this.settingsFn().modelAllowlist ?? {};
+  }
+  /**
+   * The discovered catalog as the resolver holds it now, per runner, with this
+   * session's own discovery as the fallback where the resolver has nothing
+   * cached. The resolver's cache outlives this session's snapshot in both
+   * directions — an allowlist picker re-discovers into it mid-session — and a
+   * model allowed after that must reach the planner with its real label and
+   * variants, not as an id-only stub. Never triggers discovery itself.
+   */
+  models() {
+    const out = { ...this.modelsCache };
+    for (const runner of /* @__PURE__ */ new Set([...Object.keys(out), ...this.plan?.runners ?? []])) {
+      const cached2 = this.modelResolver.getCachedRunnerModels(runner);
+      if (cached2.length > 0) out[runner] = cached2;
+    }
+    return out;
+  }
   get planState() {
     return this.plan;
   }
@@ -13677,8 +13699,7 @@ var Session = class {
     this.modelsCache = modelsByRunner;
     const runnerModes = this.runnerModesFor(chosenRunners);
     const { verificationEnabled, modelAllowlist } = this.settingsFn();
-    this.currentAllowlist = modelAllowlist ?? {};
-    const filteredModels = filterModelsForPrompt(modelsByRunner, this.currentAllowlist);
+    const filteredModels = filterModelsForPrompt(modelsByRunner, modelAllowlist ?? {});
     const now = (/* @__PURE__ */ new Date()).toISOString();
     this.plan = {
       tasks: [],
@@ -13803,12 +13824,12 @@ ${TASK_QUERY_ANSWER_OR_OPS}` : answer,
    */
   taskQueryAnswer(query) {
     const runners = this.plan?.runners ?? [];
-    const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
+    const allowlist = this.allowlist();
     return renderTaskQueryAnswer(query, this.store.planTasks, {
       runners,
       // Allowlist-filtered like the always-on block: a read must not offer a
       // model the planner is forbidden to assign.
-      models: filterModelsForPrompt(this.modelsCache, allowlist),
+      models: filterModelsForPrompt(this.models(), allowlist),
       modes: this.runnerModesFor(runners),
       autonomousDefault: this.config.autonomousMode
     });
@@ -13869,7 +13890,7 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
    *
    * Built from the allowlist-filtered view (`filterModelsForPrompt`), the same
    * one the system prompt used — a restricted allowlist stays a hard bound on
-   * every turn, not just the first. `this.modelsCache` itself is never
+   * every turn, not just the first. {@link models} itself is never
    * filtered: `coerceAssignments` needs the full discovered catalog alongside
    * the allowlist to resolve labels and clamp effort to real variants.
    *
@@ -13879,8 +13900,8 @@ The plan is unchanged. Rephrase the request, or adjust the tasks manually.`,
    */
   catalogBlock() {
     if (!this.plan) return null;
-    const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
-    const filteredModels = filterModelsForPrompt(this.modelsCache, allowlist);
+    const allowlist = this.allowlist();
+    const filteredModels = filterModelsForPrompt(this.models(), allowlist);
     const runnerModes = this.runnerModesFor(this.plan.runners);
     const autonomousDefault = this.config.autonomousMode;
     const modelLines = this.plan.runners.map((runner) => {
@@ -13964,8 +13985,8 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
     const plan = this.mutatePlan(
       () => {
         this.plan.researchLog = [...this.plan.researchLog ?? [], ...turn.researchLog];
-        const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
-        const coerced = coerceAssignments(result.tasks, allowlist, this.plan.runners, this.modelsCache);
+        const allowlist = this.allowlist();
+        const coerced = coerceAssignments(result.tasks, allowlist, this.plan.runners, this.models());
         if (this.orchestrator.isRunning) {
           this.orchestrator.reconcilePlan(coerced, this.plan.runners);
         } else {
@@ -13997,8 +14018,7 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
     this.modelsCache = modelsByRunner;
     const runnerModes = this.runnerModesFor(runners);
     const { verificationEnabled, modelAllowlist } = this.settingsFn();
-    this.currentAllowlist = modelAllowlist ?? {};
-    const filteredModels = filterModelsForPrompt(modelsByRunner, this.currentAllowlist);
+    const filteredModels = filterModelsForPrompt(modelsByRunner, modelAllowlist ?? {});
     const goal = this.goal || priorHistory.find((m) => m.role === "user")?.content || userMessage;
     return this.aiService.startConversation({
       goal,
@@ -14046,8 +14066,8 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
       return this.mutatePlan(() => {
         this.plan.researchLog = [...this.plan.researchLog ?? [], ...turn.researchLog];
         this.capturePrd(turn.text);
-        const allowlist = this.settingsFn().modelAllowlist ?? this.currentAllowlist;
-        const coerced = coerceAssignments(turn.tasks, allowlist, this.plan.runners, this.modelsCache);
+        const allowlist = this.allowlist();
+        const coerced = coerceAssignments(turn.tasks, allowlist, this.plan.runners, this.models());
         this.orchestrator.loadPlan(coerced, this.plan.runners);
         this.store.resetForRun({ preserveCompleted: false });
         this.appendTranscript("assistant", `Plan generated with ${coerced.length} task${coerced.length === 1 ? "" : "s"}.`, now, "plan_generated");
@@ -14298,7 +14318,7 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
     const allowed = effectiveAllowlist(
       this.settingsFn().modelAllowlist?.[runner],
       runner,
-      { ...this.modelsCache, [runner]: catalog.models }
+      { ...this.models(), [runner]: catalog.models }
     );
     if (!allowed) return catalog;
     const models = catalog.models.filter((m) => allowed.includes(m.modelId));