@adhdev/daemon-core 0.9.82-rc.436 → 0.9.82-rc.438

package/dist/mesh/mesh-work-queue.d.ts

@@ -72,6 +72,14 @@ export interface MeshWorkQueueEntry {
      * replicas. Absent on ordinary tasks. Rides in the payload JSON (no column).
      */
     consensusGroupId?: string;
+    /**
+     * MAGI-KIND-PANEL (model axis): model override for the session that executes this
+     * task. When the task auto-launches a session, this is passed to launch_cli as
+     * `initialModel` (ACP → setConfigOption; CLI → modelLaunchArgs template). Absent on
+     * ordinary tasks. Rides in the payload JSON (no column). Best-effort — a provider
+     * that cannot honor the model still runs the task (never a fatal launch error).
+     */
+    model?: string;
     /**
      * M1: why this task is held back (e.g. "dependency_failed:<taskId>").
      * Only set by the system on dependency failure under the 'block' policy;
@@ -186,6 +194,8 @@ export declare function enqueueTask(meshId: string, message: string, opts?: {
     missionId?: string;
     /** MAGI: consensus group id shared by every replica of a mesh_magi_review fan-out. */
     consensusGroupId?: string;
+    /** MAGI-KIND-PANEL: model override forwarded to the executing session's launch (initialModel). */
+    model?: string;
     /** Explicit task id for batch/template flows (M5). Random UUID when omitted. */
     id?: string;
     /** (3) Originating coordinator session id (for session-anchored completion routing). */

package/dist/providers/contracts.d.ts

@@ -489,6 +489,16 @@ export interface ProviderModule {
         /** Auto-implement spawn config — controls how this provider is invoked for autonomous script generation */
         autoImpl?: ProviderAutoImplSpawnConfig;
     };
+    /**
+     * MAGI-KIND-PANEL (model axis): template for expanding an `initialModel` selection
+     * into launch args for a CLI provider. `{{model}}` is substituted with the model
+     * string; e.g. `['--model', '{{model}}']` for claude-cli → `--model opus`. Applied
+     * at session launch when `initialModel` is passed AND this provider is a plain CLI
+     * (ACP providers instead route the model through setConfigOption). A CLI provider
+     * with no template silently ignores `initialModel` at launch (best-effort; a model
+     * request never fails a launch). Absent → no launch-time model selection for CLI.
+     */
+    modelLaunchArgs?: 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/dist/repo-mesh-types.d.ts

@@ -13,7 +13,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 { MagiPanelMap } from '@adhdev/mesh-shared';
+import type { MagiPanelMap, MagiKindPanelMap } from '@adhdev/mesh-shared';
 export interface RepoMesh {
     id: string;
     name: string;
@@ -536,6 +536,14 @@ export interface LocalMeshConfig {
      * Optional: absent on configs written before MAGI existed.
      */
     magiPanels?: MagiPanelMap;
+    /**
+     * MAGI-KIND-PANEL: per-task_kind panel bindings (machine-local). Keyed by
+     * task_kind (rca / design / claim_audit / freeform); each maps to ≥1
+     * `(node × provider × model?)` slot. A `mesh_magi_review` invoked with a bare
+     * `task_kind` resolves its panel from here — an unconfigured kind is a hard
+     * error, never a synthesized fallback. Optional; absent on pre-feature configs.
+     */
+    magiKindPanels?: MagiKindPanelMap;
 }
 export interface LocalMeshEntry {
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.436",
+  "version": "0.9.82-rc.438",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.436",
+    "@adhdev/mesh-shared": "0.9.82-rc.438",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",

package/src/commands/cli-manager.ts

@@ -369,6 +369,18 @@ function expandResumeArgs(template: string[] | undefined, sessionId: string): st
     return template.map((part) => part === '{{id}}' ? sessionId : part);
 }
 
+/**
+ * Expand a provider's `modelLaunchArgs` template with the requested model, mirroring
+ * expandResumeArgs. `{{model}}` → the trimmed model string. Returns undefined when
+ * there is no template or no model (a model request without a template is a no-op —
+ * see startSession, where the caller logs the skip). MAGI kind-panel model axis.
+ */
+function expandModelLaunchArgs(template: string[] | undefined, model: string | undefined): string[] | undefined {
+    const m = typeof model === 'string' ? model.trim() : '';
+    if (!m || !Array.isArray(template) || template.length === 0) return undefined;
+    return template.map((part) => part === '{{model}}' ? m : part);
+}
+
 function readSubcommandSessionId(args: string[], subcommands: string[]): string | undefined {
     const resumeIndex = args.findIndex((arg) => subcommands.includes(arg));
     if (resumeIndex < 0) return undefined;
@@ -895,8 +907,23 @@ export class DaemonCliManager {
             console.log(colorize('cyan', `  📦 Using provider: ${provider.name} (${provider.type})`));
         }
 
+ // ─── Model axis (MAGI kind-panel): expand initialModel → launch args ───
+ // For a plain CLI provider the model is selected at spawn time via the manifest's
+ // modelLaunchArgs template ('{{model}}' → the requested model). ACP providers took
+ // the setConfigOption path above and never reach here. A provider with no template,
+ // or no requested model, is a no-op — model selection is best-effort and must never
+ // fail a launch. The model args are prepended so a caller's explicit cliArgs (e.g. a
+ // resume flag) still win positionally where order matters.
+        const modelLaunchArgs = expandModelLaunchArgs(provider?.modelLaunchArgs, initialModel);
+        const cliArgsWithModel = modelLaunchArgs
+            ? [...modelLaunchArgs, ...(cliArgs || [])]
+            : cliArgs;
+        if (initialModel && !modelLaunchArgs) {
+            LOG.warn('CLI', `[${normalizedType}] initialModel='${initialModel}' requested but provider declares no modelLaunchArgs template — launching without model selection.`);
+        }
+
  // ─── Resolve launch options → provider session binding ───
-        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgs, options?.resumeSessionId);
+        const sessionBinding = resolveCliSessionBinding(provider, normalizedType, cliArgsWithModel, options?.resumeSessionId);
         const resolvedCliArgs = sessionBinding.cliArgs;
 
  // If InstanceManager exists, manage as CliProviderInstance unified

package/src/commands/med-family/mesh-crud.ts

@@ -302,6 +302,48 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         }
     },
 
+    // ─── MAGI kind → panel bindings (MAGI-KIND-PANEL, machine-local config) ───
+    // Per-task_kind slot lists in ~/.adhdev/meshes.json `magiKindPanels`. Same
+    // owner-only gating and structured-error precedent as the magi_panel_* handlers
+    // above (not listed in canPeerUsePrivilegedShareCommand → owner-only). set/remove
+    // are WRITE commands; list is read-only. normalizeMagiSlots (inside setMagiKindPanel)
+    // surfaces invalid_magi_kind_panel: … messages verbatim for the editor.
+    magi_kind_panel_list: async (_ctx: MedFamilyContext, _args: any) => {
+        try {
+            const { listMagiKindPanels } = await import('../../config/mesh-config.js');
+            return { success: true, kindPanels: listMagiKindPanels() };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
+    magi_kind_panel_set: async (_ctx: MedFamilyContext, args: any) => {
+        const kind = typeof args?.kind === 'string' ? args.kind.trim() : '';
+        if (!kind) return { success: false, error: 'invalid_magi_kind_panel: task_kind is required' };
+        try {
+            const { setMagiKindPanel } = await import('../../config/mesh-config.js');
+            // normalizeMagiTaskKindKey + normalizeMagiSlots (inside setMagiKindPanel)
+            // validate the kind and each slot (provider required; model/nodeId optional;
+            // replica counts clamped). Structured errors flow back as `error`.
+            const slots = setMagiKindPanel(kind, args?.slots);
+            return { success: true, kind, slots };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
+    magi_kind_panel_remove: async (_ctx: MedFamilyContext, args: any) => {
+        const kind = typeof args?.kind === 'string' ? args.kind.trim() : '';
+        if (!kind) return { success: false, error: 'invalid_magi_kind_panel: task_kind is required' };
+        try {
+            const { removeMagiKindPanel } = await import('../../config/mesh-config.js');
+            const removed = removeMagiKindPanel(kind);
+            return { success: true, removed };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
     add_mesh_node: async (ctx: MedFamilyContext, args: any) => {
         const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
         const workspace = typeof args?.workspace === 'string' ? args.workspace.trim() : '';

package/src/config/mesh-config.ts

@@ -22,7 +22,7 @@ import type {
     RepoMeshHostMetadata,
     RepoMeshDaemonRole,
 } from '../repo-mesh-types.js';
-import type { MagiPanel, MagiPanelMember, MagiPanelDefaultKind } from '@adhdev/mesh-shared';
+import type { MagiPanel, MagiPanelMember, MagiPanelDefaultKind, MagiKindPanelMap, MagiSlot, MagiTaskKind } from '@adhdev/mesh-shared';
 import { mergeAndNormalizePolicy } from '../repo-mesh-types.js';
 import { createDefaultMeshHostMetadata } from '../mesh/mesh-host-ownership.js';
 
@@ -650,11 +650,13 @@ export function normalizeMagiPanel(config: unknown): MagiPanel {
             throw new Error(`invalid_magi_panel: member[${idx}].provider is required`);
         }
         const nodeId = typeof m.nodeId === 'string' && m.nodeId.trim() ? m.nodeId.trim() : undefined;
+        const model = typeof m.model === 'string' && m.model.trim() ? m.model.trim() : undefined;
         const capabilityTags = normalizeCapabilityTags(m.capabilityTags);
         const n = normalizeReplicaCount(m.n);
         return {
             provider,
             ...(nodeId ? { nodeId } : {}),
+            ...(model ? { model } : {}),
             ...(capabilityTags ? { capabilityTags } : {}),
             ...(n !== undefined ? { n } : {}),
         };
@@ -726,3 +728,99 @@ export function removeMagiPanel(name: string): boolean {
     saveMeshConfig(stored);
     return true;
 }
+
+// ─── MAGI kind → panel bindings (MAGI-KIND-PANEL) ─────────
+//
+// Per-task_kind slot lists (machine-local, meshes.json `magiKindPanels`). A bare
+// `mesh_magi_review({task_kind})` resolves its panel exclusively from here — an
+// unconfigured kind is a hard error, never a synthesized fallback. Mirrors the named
+// panel accessors above (normalize / list / get / set / remove).
+
+/** The task kinds a kind-panel can be bound to. Unlike a named panel's defaultKind,
+ * 'freeform' IS a valid kind-panel key (this is a direct kind→slots binding). */
+const MAGI_KIND_PANEL_KINDS: readonly MagiTaskKind[] = ['claim_audit', 'rca', 'design', 'freeform'];
+const MAX_MAGI_KIND_SLOTS = 24;
+
+function normalizeMagiTaskKindKey(raw: unknown): MagiTaskKind {
+    const s = typeof raw === 'string' ? raw.trim().toLowerCase() : '';
+    if (!(MAGI_KIND_PANEL_KINDS as readonly string[]).includes(s)) {
+        throw new Error(`invalid_magi_kind_panel: task_kind must be one of ${MAGI_KIND_PANEL_KINDS.join(' / ')} (got '${s || '(empty)'}')`);
+    }
+    return s as MagiTaskKind;
+}
+
+/**
+ * Validate + normalize a kind-panel's slots. Mirrors normalizeMagiPanel's member
+ * normalization: provider required per slot, trims strings, drops empties, clamps
+ * replica counts, and additionally carries an optional per-slot `model`. Throws on
+ * structurally invalid input (empty list / no provider) so the write returns a clear
+ * error. Returns the normalized slot array.
+ */
+export function normalizeMagiSlots(slots: unknown): MagiSlot[] {
+    if (!Array.isArray(slots) || slots.length === 0) {
+        throw new Error('invalid_magi_kind_panel: slots must be a non-empty array');
+    }
+    if (slots.length > MAX_MAGI_KIND_SLOTS) {
+        throw new Error(`invalid_magi_kind_panel: too many slots (max ${MAX_MAGI_KIND_SLOTS})`);
+    }
+    return slots.map((entry, idx) => {
+        if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+            throw new Error(`invalid_magi_kind_panel: slot[${idx}] must be an object`);
+        }
+        const s = entry as Record<string, unknown>;
+        const provider = typeof s.provider === 'string' ? s.provider.trim() : '';
+        if (!provider) {
+            throw new Error(`invalid_magi_kind_panel: slot[${idx}].provider is required`);
+        }
+        const nodeId = typeof s.nodeId === 'string' && s.nodeId.trim() ? s.nodeId.trim() : undefined;
+        const model = typeof s.model === 'string' && s.model.trim() ? s.model.trim() : undefined;
+        const capabilityTags = normalizeCapabilityTags(s.capabilityTags);
+        const n = normalizeReplicaCount(s.n);
+        return {
+            provider,
+            ...(nodeId ? { nodeId } : {}),
+            ...(model ? { model } : {}),
+            ...(capabilityTags ? { capabilityTags } : {}),
+            ...(n !== undefined ? { n } : {}),
+        };
+    });
+}
+
+/** All configured kind-panels (machine-local), keyed by task_kind. Empty when none. */
+export function listMagiKindPanels(): MagiKindPanelMap {
+    return loadMeshConfig().magiKindPanels ?? {};
+}
+
+/** The slot list for one task_kind, or undefined when the kind is not configured. */
+export function getMagiKindPanel(kind: string): MagiSlot[] | undefined {
+    let key: MagiTaskKind;
+    try { key = normalizeMagiTaskKindKey(kind); } catch { return undefined; }
+    return loadMeshConfig().magiKindPanels?.[key];
+}
+
+/**
+ * Upsert the slot list for one task_kind. Unlike named panels this ALWAYS overwrites
+ * (a kind has exactly one binding) — the editor pushes the full desired slot set.
+ * Returns the normalized, persisted slots.
+ */
+export function setMagiKindPanel(kind: string, slots: unknown): MagiSlot[] {
+    const key = normalizeMagiTaskKindKey(kind);
+    const normalized = normalizeMagiSlots(slots);
+    const stored = loadMeshConfig();
+    const map = stored.magiKindPanels ?? {};
+    map[key] = normalized;
+    stored.magiKindPanels = map;
+    saveMeshConfig(stored);
+    return normalized;
+}
+
+/** Remove the binding for one task_kind. Returns true when a binding was removed. */
+export function removeMagiKindPanel(kind: string): boolean {
+    let key: MagiTaskKind;
+    try { key = normalizeMagiTaskKindKey(kind); } catch { return false; }
+    const stored = loadMeshConfig();
+    if (!stored.magiKindPanels || !stored.magiKindPanels[key]) return false;
+    delete stored.magiKindPanels[key];
+    saveMeshConfig(stored);
+    return true;
+}

package/src/index.ts

@@ -196,6 +196,7 @@ export {
   listMeshes, getMesh, getMeshByRepo, createMesh, updateMesh, deleteMesh,
   addNode, removeNode, updateNode, normalizeRepoIdentity,
   listMagiPanels, getMagiPanel, upsertMagiPanel, removeMagiPanel, normalizeMagiPanel,
+  listMagiKindPanels, getMagiKindPanel, setMagiKindPanel, removeMagiKindPanel, normalizeMagiSlots,
 } from './config/mesh-config.js';
 export type { CreateMeshOptions, UpdateMeshOptions, AddNodeOptions } from './config/mesh-config.js';
 // MAGI panel / common-output / synthesis types (re-exported from the mesh-shared

package/src/mesh/mesh-queue-assignment.ts

@@ -1538,6 +1538,9 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                             cliType: resolved.providerType,
                             dir: node.workspace,
                             settings: remoteSettings,
+                            // MAGI-KIND-PANEL model axis: forward the task's model override so the
+                            // remote worker session launches with it (initialModel). Best-effort.
+                            ...(typeof task.model === 'string' && task.model.trim() ? { initialModel: task.model.trim() } : {}),
                         });
                     } catch (e: any) {
                         markAutoLaunch(meshId, task.id, { status: 'failed', reason: `remote_launch_dispatch_failed: ${e?.message || String(e)}`, nodeId, providerType: resolved.providerType });
@@ -1567,6 +1570,9 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
                     cliType: resolved.providerType,
                     dir: node.workspace,
                     settings: launchSettings,
+                    // MAGI-KIND-PANEL model axis: local launch forwards the task's model
+                    // override as initialModel (CLI → modelLaunchArgs; ACP → setConfigOption).
+                    ...(typeof task.model === 'string' && task.model.trim() ? { initialModel: task.model.trim() } : {}),
                 });
                 if (!launchResult?.success) {
                     const reason = launchResult?.error || 'launch_cli_failed';

package/src/mesh/mesh-work-queue.ts

@@ -502,6 +502,14 @@ export interface MeshWorkQueueEntry {
      * replicas. Absent on ordinary tasks. Rides in the payload JSON (no column).
      */
     consensusGroupId?: string;
+    /**
+     * MAGI-KIND-PANEL (model axis): model override for the session that executes this
+     * task. When the task auto-launches a session, this is passed to launch_cli as
+     * `initialModel` (ACP → setConfigOption; CLI → modelLaunchArgs template). Absent on
+     * ordinary tasks. Rides in the payload JSON (no column). Best-effort — a provider
+     * that cannot honor the model still runs the task (never a fatal launch error).
+     */
+    model?: string;
     /**
      * M1: why this task is held back (e.g. "dependency_failed:<taskId>").
      * Only set by the system on dependency failure under the 'block' policy;
@@ -772,6 +780,8 @@ export function enqueueTask(
         missionId?: string;
         /** MAGI: consensus group id shared by every replica of a mesh_magi_review fan-out. */
         consensusGroupId?: string;
+        /** MAGI-KIND-PANEL: model override forwarded to the executing session's launch (initialModel). */
+        model?: string;
         /** Explicit task id for batch/template flows (M5). Random UUID when omitted. */
         id?: string;
         /** (3) Originating coordinator session id (for session-anchored completion routing). */
@@ -816,6 +826,7 @@ export function enqueueTask(
             ...(dependsOn.length > 0 ? { dependsOn } : {}),
             ...(typeof opts?.missionId === 'string' && opts.missionId.trim() ? { missionId: opts.missionId.trim() } : {}),
             ...(typeof opts?.consensusGroupId === 'string' && opts.consensusGroupId.trim() ? { consensusGroupId: opts.consensusGroupId.trim() } : {}),
+            ...(typeof opts?.model === 'string' && opts.model.trim() ? { model: opts.model.trim() } : {}),
             ...(typeof opts?.sourceCoordinatorSessionId === 'string' && opts.sourceCoordinatorSessionId.trim()
                 ? { sourceCoordinatorSessionId: opts.sourceCoordinatorSessionId.trim() }
                 : {}),

package/src/providers/contracts.ts

@@ -594,6 +594,16 @@ export interface ProviderModule {
     /** Auto-implement spawn config — controls how this provider is invoked for autonomous script generation */
     autoImpl?: ProviderAutoImplSpawnConfig;
   };
+  /**
+   * MAGI-KIND-PANEL (model axis): template for expanding an `initialModel` selection
+   * into launch args for a CLI provider. `{{model}}` is substituted with the model
+   * string; e.g. `['--model', '{{model}}']` for claude-cli → `--model opus`. Applied
+   * at session launch when `initialModel` is passed AND this provider is a plain CLI
+   * (ACP providers instead route the model through setConfigOption). A CLI provider
+   * with no template silently ignores `initialModel` at launch (best-effort; a model
+   * request never fails a launch). Absent → no launch-time model selection for CLI.
+   */
+  modelLaunchArgs?: 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/sdk/v1/schemas/cli/provider.schema.json

@@ -124,6 +124,11 @@
       "minimum": 0,
       "description": "Delay between pasting prompt text and pressing Enter."
     },
+    "modelLaunchArgs": {
+      "type": "array",
+      "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."
+    },
     "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 { MagiPanelMap } from '@adhdev/mesh-shared';
+import type { MagiPanelMap, MagiKindPanelMap } from '@adhdev/mesh-shared';
 
 // ─── Core Mesh Types ────────────────────────────
 
@@ -803,6 +803,14 @@ export interface LocalMeshConfig {
      * Optional: absent on configs written before MAGI existed.
      */
     magiPanels?: MagiPanelMap;
+    /**
+     * MAGI-KIND-PANEL: per-task_kind panel bindings (machine-local). Keyed by
+     * task_kind (rca / design / claim_audit / freeform); each maps to ≥1
+     * `(node × provider × model?)` slot. A `mesh_magi_review` invoked with a bare
+     * `task_kind` resolves its panel from here — an unconfigured kind is a hard
+     * error, never a synthesized fallback. Optional; absent on pre-feature configs.
+     */
+    magiKindPanels?: MagiKindPanelMap;
 }
 
 export interface LocalMeshEntry {