@ordewell/core 0.4.21 → 0.4.23

package/dist/index.d.mts

@@ -2492,7 +2492,6 @@ declare class Session {
     private approvalPolicy;
     private fetcher;
     private settingsFn;
-    private currentAllowlist;
     /** Last discovered model catalog — lets sync plan commits clamp thinking efforts to real variants. */
     private modelsCache;
     private unsubObserver;
@@ -2559,11 +2558,26 @@ declare class Session {
      * 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.
      */
     private editCatalog;
+    /**
+     * 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.
+     */
+    private allowlist;
+    /**
+     * 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.
+     */
+    private models;
     get planState(): LegacyPlanState | null;
     /**
      * The live plan in the shape a saved session is read back as. The disk
@@ -2643,7 +2657,7 @@ declare class Session {
      *
      * 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.
      *
@@ -2942,6 +2956,13 @@ declare function coerceAssignments(tasks: Task[], perRunnerAllowlist: Partial<Re
 interface RunnerCatalog {
     models: DiscoveredModel[];
     modes: RunnerModeInfo[];
+    /**
+     * The mode a task lands on when it carries none this runner offers: the
+     * manifest's `autonomous`/`safe`-tagged mode under the user's toggle
+     * (ADR-0001). Absent, `modes[0]` stands in — which for Codex is its
+     * workspace-write sandbox, not the full access an unattended run needs.
+     */
+    defaultMode?: string;
 }
 /**
  * The model, thinking effort and mode a runner offers for a task.
@@ -2952,8 +2973,8 @@ interface RunnerCatalog {
  * assignment — a runner change (below) and a hand-added task derive it the same
  * way. Each field in `current` is preserved when the runner also offers it, and
  * otherwise snapped to that runner's preferred entry (discovery already sorts
- * models by the manifest's `preferredPatterns`; `modes[0]` is the manifest's own
- * first choice).
+ * models by the manifest's `preferredPatterns`; the mode is the catalog's
+ * `defaultMode`).
  *
  * An empty catalog means discovery failed or the runner is a plugin we have no
  * list for — not that the runner offers nothing. That field is left out of the

package/dist/index.d.ts

@@ -2492,7 +2492,6 @@ declare class Session {
     private approvalPolicy;
     private fetcher;
     private settingsFn;
-    private currentAllowlist;
     /** Last discovered model catalog — lets sync plan commits clamp thinking efforts to real variants. */
     private modelsCache;
     private unsubObserver;
@@ -2559,11 +2558,26 @@ declare class Session {
      * 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.
      */
     private editCatalog;
+    /**
+     * 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.
+     */
+    private allowlist;
+    /**
+     * 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.
+     */
+    private models;
     get planState(): LegacyPlanState | null;
     /**
      * The live plan in the shape a saved session is read back as. The disk
@@ -2643,7 +2657,7 @@ declare class Session {
      *
      * 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.
      *
@@ -2942,6 +2956,13 @@ declare function coerceAssignments(tasks: Task[], perRunnerAllowlist: Partial<Re
 interface RunnerCatalog {
     models: DiscoveredModel[];
     modes: RunnerModeInfo[];
+    /**
+     * The mode a task lands on when it carries none this runner offers: the
+     * manifest's `autonomous`/`safe`-tagged mode under the user's toggle
+     * (ADR-0001). Absent, `modes[0]` stands in — which for Codex is its
+     * workspace-write sandbox, not the full access an unattended run needs.
+     */
+    defaultMode?: string;
 }
 /**
  * The model, thinking effort and mode a runner offers for a task.
@@ -2952,8 +2973,8 @@ interface RunnerCatalog {
  * assignment — a runner change (below) and a hand-added task derive it the same
  * way. Each field in `current` is preserved when the runner also offers it, and
  * otherwise snapped to that runner's preferred entry (discovery already sorts
- * models by the manifest's `preferredPatterns`; `modes[0]` is the manifest's own
- * first choice).
+ * models by the manifest's `preferredPatterns`; the mode is the catalog's
+ * `defaultMode`).
  *
  * An empty catalog means discovery failed or the runner is a plugin we have no
  * list for — not that the runner offers nothing. That field is left out of the

package/dist/index.js

@@ -4340,6 +4340,7 @@ function resolveTaskMode(emittedMode, runnerId, runnerModes, autonomousDefault =
   if (!runnerModes) return rawMode === "plan" ? "plan" : "build";
   const modes = runnerModes[runnerId];
   if (!modes || modes.length === 0) return rawMode;
+  if (!emittedMode) return resolveDefaultMode(modes, autonomousDefault) ?? "build";
   const validIds = new Set(modes.map((m) => m.id));
   if (rawMode === "build" || validIds.has(rawMode)) {
     if (rawMode === "plan" || rawMode === "build") return rawMode;
@@ -5588,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}"` };
       }
@@ -12836,7 +12837,7 @@ function runnerAssignment(catalog, current) {
     changes.thinkingEffort = thinkingEffort;
   }
   if (catalog.modes.length > 0) {
-    changes.taskMode = catalog.modes.some((m) => m.id === current?.taskMode) ? current.taskMode : catalog.modes[0].id;
+    changes.taskMode = catalog.modes.some((m) => m.id === current?.taskMode) ? current.taskMode : catalog.defaultMode ?? catalog.modes[0].id;
   }
   return changes;
 }
@@ -13313,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;
@@ -13518,7 +13518,6 @@ var Session = class {
     this.beginFreshPlan();
     this.approvalPolicy.reset();
     this.modelsCache = {};
-    this.currentAllowlist = {};
     this.remintSessionId();
   }
   runnerModesFor(runners) {
@@ -13528,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;
   }
@@ -13676,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: [],
@@ -13802,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
     });
@@ -13868,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.
    *
@@ -13878,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) => {
@@ -13963,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 {
@@ -13996,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,
@@ -14045,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");
@@ -14276,9 +14297,11 @@ Execution is RUNNING${locked.length ? ` \u2014 these tasks are locked: ${locked.
   }
   /** What a runner offers, as {@link runnerAssignment} needs it. Spawns the runner's CLI to list models. */
   async catalogFor(runner) {
+    const modes = this.runnerModesFor([runner])[runner];
     return {
       models: (await this.modelResolver.modelsForRunners([runner]))[runner] ?? [],
-      modes: this.runnerModesFor([runner])[runner]
+      modes,
+      defaultMode: resolveDefaultMode(modes, this.config.autonomousMode)
     };
   }
   /**
@@ -14295,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));