@adhdev/daemon-core 0.9.82-rc.482 → 0.9.82-rc.484

package/src/providers/contracts.ts

@@ -604,6 +604,53 @@ export interface ProviderModule {
    * request never fails a launch). Absent → no launch-time model selection for CLI.
    */
   modelLaunchArgs?: string[];
+  /**
+   * BRAIN-ROUTING (model axis): suggested model values for this provider, surfaced
+   * as dropdown options in the new-session dialog (e.g. claude ['opus','sonnet',
+   * 'haiku']; codex ['gpt-5.5','gpt-5-codex']). Advisory only — the UI allows free
+   * text too, so the list going stale never blocks a model the provider accepts.
+   */
+  modelOptions?: string[];
+  /**
+   * BRAIN-ROUTING (thinking axis): template for expanding an `initialThinkingLevel`
+   * selection into launch args for a CLI provider, parallel to modelLaunchArgs.
+   * `{{level}}` is substituted with the provider-appropriate reasoning-effort value
+   * (already mapped from the standard low|medium|high level, see thinkingLevelMap).
+   * Examples: claude-cli `['--effort', '{{level}}']` → `--effort high`; codex-cli
+   * `['-c', 'model_reasoning_effort={{level}}']`. Applied at session launch when
+   * `initialThinkingLevel` is passed AND this provider is a plain CLI. A CLI provider
+   * with no template silently ignores the thinking level (best-effort; never fails a
+   * launch). ACP providers instead route thinking through setConfigOption('thought_level').
+   */
+  thinkingLaunchArgs?: string[];
+  /**
+   * BRAIN-ROUTING (thinking axis): optional per-provider mapping from the standard
+   * thinking levels (`low`|`medium`|`high`) to this provider's own reasoning-effort
+   * vocabulary, used to fill `{{level}}` in thinkingLaunchArgs. e.g. claude-cli might
+   * map `{ high: 'max' }`; codex-cli `{ high: 'xhigh' }`. A level absent from the map
+   * passes through unchanged (so `medium` → `medium` by default).
+   */
+  thinkingLevelMap?: Partial<Record<'low' | 'medium' | 'high', string>>;
+  /**
+   * BRAIN-ROUTING (thinking axis): the reasoning-effort values this provider actually
+   * accepts, surfaced as the thinking-level dropdown options in the new-session
+   * dialog (e.g. claude ['low','medium','high','max']; codex ['minimal','low',
+   * 'medium','high','xhigh']). Absent → the UI falls back to the standard
+   * low/medium/high. These are the provider's OWN vocabulary and are passed through
+   * verbatim as initialThinkingLevel (not remapped by thinkingLevelMap, which only
+   * translates the mesh's standard low/medium/high presets).
+   */
+  thinkingLevelOptions?: string[];
+  /**
+   * BRAIN-ROUTING (thinking axis, runtime-control providers): the `controls[].id`
+   * of a runtime reasoning-effort control to drive for the thinking level when the
+   * provider has no `thinkingLaunchArgs` (e.g. hermes-cli's `reasoning` select,
+   * which types `/reasoning <level>` into the PTY via its setScript). At launch,
+   * initialThinkingLevel (after thinkingLevelMap) is applied by invoking that
+   * control's setScript with `{ value: <level> }`. Ignored if the id doesn't match a
+   * control. Providers that use thinkingLaunchArgs don't need this.
+   */
+  thinkingControlId?: string;
   /** Delay before submitting typed CLI input (provider-specific TUI tuning) */
   sendDelayMs?: number;
   /** Submit key used after typing into CLI PTY (default: carriage return) */

package/src/providers/provider-schema.ts

@@ -66,6 +66,12 @@ const KNOWN_PROVIDER_FIELDS = new Set<string>([
   'providerVersion',
   'status',
   'details',
+  'modelLaunchArgs',
+  'modelOptions',
+  'thinkingLaunchArgs',
+  'thinkingLevelMap',
+  'thinkingLevelOptions',
+  'thinkingControlId',
   'sendDelayMs',
   'sendKey',
   'submitStrategy',

package/src/providers/sdk/v1/schemas/cli/provider.schema.json

@@ -129,6 +129,35 @@
       "items": { "type": "string" },
       "description": "Template for expanding an initialModel selection into launch args. '{{model}}' is substituted with the model string (e.g. ['--model', '{{model}}'] → --model opus). Applied at launch when a model is requested for this CLI provider (MAGI kind-panel model axis). Absent → no launch-time model selection."
     },
+    "modelOptions": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Suggested model values shown as dropdown options in the new-session dialog (brain-routing model axis), e.g. ['opus','sonnet','haiku']. Advisory — the UI still accepts free text, so a stale list never blocks an accepted model."
+    },
+    "thinkingLaunchArgs": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Template for expanding an initialThinkingLevel selection into launch args (brain-routing thinking axis, parallel to modelLaunchArgs). '{{level}}' is substituted with the provider-mapped reasoning-effort value (e.g. ['--effort', '{{level}}'] → --effort high; ['-c', 'model_reasoning_effort={{level}}']). Applied at launch when a thinking level is requested. Absent → no launch-time thinking selection."
+    },
+    "thinkingLevelMap": {
+      "type": "object",
+      "properties": {
+        "low": { "type": "string" },
+        "medium": { "type": "string" },
+        "high": { "type": "string" }
+      },
+      "additionalProperties": false,
+      "description": "Optional map from the standard thinking levels (low/medium/high) to this provider's own reasoning-effort vocabulary, used to fill {{level}} in thinkingLaunchArgs. A level absent from the map passes through unchanged."
+    },
+    "thinkingLevelOptions": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Reasoning-effort values this provider accepts, shown as the thinking-level dropdown in the new-session dialog (e.g. ['low','medium','high','max']). Absent → the UI falls back to standard low/medium/high. Provider's own vocabulary, passed through verbatim."
+    },
+    "thinkingControlId": {
+      "type": "string",
+      "description": "For a provider with no thinkingLaunchArgs but a runtime reasoning-effort control (e.g. hermes 'reasoning'), the controls[].id to drive at launch for the thinking level. The control's setScript is invoked with { value: <mapped level> }."
+    },
     "scriptCallBudgetMs": {
       "type": "integer",
       "minimum": 1,

package/src/repo-mesh-types.ts

@@ -14,7 +14,7 @@
 import type { GitRepoStatus, GitCompactSummary } from './git/git-types.js';
 import type { MeshMissionSummary, MeshMissionSlimSummary } from './mesh/mesh-missions.js';
 import type { MeshMagiActivitySummary } from './mesh/mesh-magi-status.js';
-import type { MagiKindPanelMap } from '@adhdev/mesh-shared';
+import type { MagiKindPanelMap, DifficultyBrainMap } from '@adhdev/mesh-shared';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -527,7 +527,7 @@ const DIRTY_WORKSPACE_BEHAVIORS = new Set<RepoMeshPolicy['dirtyWorkspaceBehavior
 
 /** Min/max bounds for the global write-task parallel cap. */
 export const MESH_MAX_PARALLEL_TASKS_MIN = 1;
-export const MESH_MAX_PARALLEL_TASKS_MAX = 8;
+export const MESH_MAX_PARALLEL_TASKS_MAX = 64;
 
 /**
  * Default multiplier applied to the write cap to derive the read-only diagnosis
@@ -822,6 +822,15 @@ export interface LocalMeshConfig {
      * Optional; absent on pre-feature configs.
      */
     magiKindPanels?: MagiKindPanelMap;
+    /**
+     * BRAIN-ROUTING: per-task-difficulty brain presets (machine-local), sibling of
+     * magiKindPanels. Keyed by difficulty (easy / medium / difficult / freeform);
+     * each maps to a BrainSlot (provider? / model? / thinkingLevel?). The coordinator
+     * classifies a task's difficulty at enqueue; the matching preset fills in the
+     * task's model / thinking level (an explicit task value wins). Optional; a mesh
+     * with none seeded uses DEFAULT_DIFFICULTY_BRAINS on first read.
+     */
+    difficultyBrains?: DifficultyBrainMap;
 }
 
 export interface LocalMeshEntry {

package/src/shared-types.ts

@@ -555,6 +555,10 @@ export interface AvailableProviderInfo {
     lastVerification?: MachineProviderCheckResult;
     /** Provider-declared Repo Mesh coordinator/MCP behavior. */
     meshCoordinator?: ProviderMeshCoordinatorConfig;
+    /** BRAIN-ROUTING: suggested model values for the new-session model dropdown. */
+    modelOptions?: string[];
+    /** BRAIN-ROUTING: reasoning-effort values for the new-session thinking dropdown. */
+    thinkingLevelOptions?: string[];
     /**
      * Provider trust classification — derived from the on-disk layer the
      * manifest came from and the shape of the manifest. Dashboards use

package/src/status/snapshot.ts

@@ -153,6 +153,8 @@ function buildAvailableProviders(
         status?: string;
         details?: string;
         links?: Record<string, string>;
+        modelOptions?: string[];
+        thinkingLevelOptions?: string[];
     }> = providerLoader.getAvailableProviderInfos?.() || providerLoader.getAll();
     // Trust helpers come from daemon-core; resolve them lazily so the
     // status snapshot path stays loadable in older bundles that don't
@@ -189,6 +191,8 @@ function buildAvailableProviders(
             ...(sourceLayer ? { sourceLayer } : {}),
             ...(sourceName ? { sourceName } : {}),
             ...(provider.providerVersion ? { providerVersion: provider.providerVersion } : {}),
+            ...(Array.isArray(provider.modelOptions) && provider.modelOptions.length ? { modelOptions: provider.modelOptions } : {}),
+            ...(Array.isArray(provider.thinkingLevelOptions) && provider.thinkingLevelOptions.length ? { thinkingLevelOptions: provider.thinkingLevelOptions } : {}),
             ...(provider.binary ? { binary: provider.binary } : {}),
             ...(provider.status ? { status: provider.status } : {}),
             ...(provider.details ? { details: provider.details } : {}),