@adhdev/daemon-core 0.9.82-rc.437 → 0.9.82-rc.439

package/dist/mesh/mesh-init.d.ts

@@ -4,7 +4,13 @@
  * One-shot helper that onboards an existing git project into Repo Mesh:
  *   1. suggest + write `.adhdev/refine.json`           (Refinery validation config)
  *   2. suggest + write `.adhdev/worktree_bootstrap.json` (worktree bootstrap config)
- *   3. recommend a node providerPriority from the installed CLI providers
+ *   3. suggest + write `.adhdev/change-impact.json`     (change-impact classification)
+ *   4. recommend a node providerPriority from the installed CLI providers
+ *
+ * mesh_init now covers all THREE repo-committed `.adhdev/*` config families that
+ * carry a suggest→validate→write engine (refine + worktree_bootstrap +
+ * change-impact). `.adhdev/mesh.json` (coordinator prompt + operating notes) has
+ * its own dedicated export/write path (export_mesh_json_config / write_mesh_json_config).
  *
  * Design contract (matches the rest of the mesh tooling):
  *   - Heuristics are suggestion/scaffold only. The written files are the
@@ -19,17 +25,20 @@
  */
 import { type RepoMeshRefineConfig, type RepoMeshRefineValidationCommandConfig } from './refine-config.js';
 import { type RepoMeshWorktreeBootstrapConfig } from './worktree-bootstrap-config.js';
+import { type ChangeImpactConfig } from '../git/change-impact-config.js';
+import type { MagiKindPanelMap } from '@adhdev/mesh-shared';
 import type { CLIInfo } from '../detection/cli-detector.js';
 /** Canonical write targets — the first/preferred location for each config family. */
 export declare const MESH_INIT_REFINE_CONFIG_PATH: string;
 export declare const MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH: string;
+export declare const MESH_INIT_CHANGE_IMPACT_CONFIG_PATH: string;
 export interface MeshInitConfigFileResult {
     path: string;
     relativePath: string;
     written: boolean;
     /** Why it was not written (already_exists / not_suggested / no change). */
     skippedReason?: 'already_exists' | 'no_suggestion';
-    config?: RepoMeshRefineConfig | RepoMeshWorktreeBootstrapConfig;
+    config?: RepoMeshRefineConfig | RepoMeshWorktreeBootstrapConfig | ChangeImpactConfig;
 }
 /**
  * Build a worktree_bootstrap scaffold from package scripts. Mirrors
@@ -58,12 +67,39 @@ export interface RunMeshInitOptions {
     /** When true, overwrite an existing config file. Defaults to false (never clobber). */
     overwrite?: boolean;
 }
+/**
+ * A snapshot of the currently-saved config for each domain, so the coordinator can
+ * render a current-vs-suggested diff to the user before an init/reinit overwrite.
+ * This is READ-ONLY echo — every field is what is on disk / machine-local right now,
+ * never a suggestion. Absent domains are reported as `undefined` config.
+ */
+export interface MeshInitCurrentConfigEcho {
+    /** Currently-saved `.adhdev/refine.json` (repo-committed) — undefined when absent/invalid. */
+    refine?: RepoMeshRefineConfig;
+    /** Currently-saved `.adhdev/worktree_bootstrap.json` (repo-committed). */
+    worktreeBootstrap?: RepoMeshWorktreeBootstrapConfig;
+    /** Currently-saved `.adhdev/change-impact.json` (repo-committed). */
+    changeImpact?: ChangeImpactConfig;
+    /** Per-domain source type so the coordinator can tell "absent" from "invalid". */
+    sourceTypes: {
+        refine: string;
+        worktreeBootstrap: string;
+        changeImpact: string;
+    };
+    /**
+     * Currently-configured MAGI kind→panel slot bindings (machine-local
+     * ~/.adhdev/meshes.json). Empty object when none configured. This is a
+     * machine-local echo — the coordinator labels it as such vs. the repo files.
+     */
+    magiKindPanels: MagiKindPanelMap;
+}
 export interface RunMeshInitResult {
     success: true;
     workspace: string;
     dryRun: boolean;
     refine: MeshInitConfigFileResult;
     worktreeBootstrap: MeshInitConfigFileResult;
+    changeImpact: MeshInitConfigFileResult;
     providers: {
         providerPriority: string[];
         installedProviders: Array<{
@@ -72,6 +108,12 @@ export interface RunMeshInitResult {
             version?: string;
         }>;
     };
+    /**
+     * Read-only snapshot of the currently-saved config per domain (repo files +
+     * machine-local kind panels). Lets the coordinator present a current-vs-suggested
+     * diff to the user before any overwrite. Always populated (dry-run and write).
+     */
+    currentConfig: MeshInitCurrentConfigEcho;
     note: string;
 }
 /**

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/providers/native-history/hermes-cli-transcript.d.ts

@@ -26,5 +26,5 @@ export interface NativeHistorySessionMeta {
     preview?: string;
     workspace?: string;
 }
-export declare function readSession(sessionPath: string): NativeHistorySession | null;
+export declare function readSession(sessionPath: string, requestedSessionId?: string): NativeHistorySession | null;
 export declare function listSessions(_watchPath: string): Promise<NativeHistorySessionMeta[]>;

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.437",
+  "version": "0.9.82-rc.439",
   "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.437",
+    "@adhdev/mesh-shared": "0.9.82-rc.439",
     "@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

@@ -232,6 +232,95 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
         }
     },
 
+    // Gated WRITE path for `.adhdev/mesh.json` — the sibling of export_mesh_json_config
+    // (which only DRAFTS). Same write/overwrite/dry-run contract as mesh_init's config
+    // writer: defaults to dry-run (no write), never clobbers an existing repo mesh.json
+    // unless overwrite=true, and validates the scaffold before persisting. The scaffold
+    // is built from the machine-local mesh entry (coordinator prompt override/append);
+    // policy/operating-notes are intentionally NOT exported (see buildMeshJsonConfigScaffold).
+    write_mesh_json_config: async (_ctx: MedFamilyContext, args: any) => {
+        const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+        if (!meshId) return { success: false, error: 'meshId required' };
+        const workspace = typeof args?.workspace === 'string' && args.workspace.trim() ? args.workspace.trim() : process.cwd();
+        const write = args?.write === true;
+        const overwrite = args?.overwrite === true;
+        try {
+            const { getMesh } = await import('../../config/mesh-config.js');
+            const mesh = getMesh(meshId);
+            if (!mesh) return { success: false, error: 'Mesh not found' };
+            const {
+                buildMeshJsonConfigScaffold,
+                serializeMeshJsonConfigScaffold,
+                loadRepoMeshJsonConfig,
+                normalizeRepoMeshDeclarativeConfig,
+                MESH_JSON_CONFIG_LOCATIONS,
+            } = await import('../../config/mesh-json-config.js');
+            const { mkdirSync, writeFileSync } = await import('fs');
+            const { dirname, join } = await import('path');
+
+            const scaffold = buildMeshJsonConfigScaffold(mesh);
+            const scaffoldJson = serializeMeshJsonConfigScaffold(scaffold);
+            const relativePath = MESH_JSON_CONFIG_LOCATIONS[0];
+            const absolutePath = join(workspace, relativePath);
+
+            // Validate before we ever touch disk — never write an unusable mesh.json.
+            const validation = normalizeRepoMeshDeclarativeConfig(scaffold);
+            if (!validation.valid) {
+                return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join('; ')}` };
+            }
+
+            // existing-wins: a repo mesh.json already present is kept unless overwrite=true.
+            const existing = loadRepoMeshJsonConfig(workspace);
+            const existingPresent = existing.sourceType === 'repo_file' || existing.sourceType === 'invalid';
+            if (existingPresent && !overwrite) {
+                return {
+                    success: true,
+                    meshId,
+                    written: false,
+                    dryRun: !write,
+                    skippedReason: 'already_exists',
+                    path: absolutePath,
+                    relativePath,
+                    existing: existing.config,
+                    existingSourceType: existing.sourceType,
+                    scaffold,
+                    scaffoldJson,
+                    note: 'A repo mesh.json already exists — kept as-is. Re-run with overwrite=true to replace it (this silently drops operator hand-edits, so present a current-vs-suggested diff first).',
+                };
+            }
+
+            if (!write) {
+                return {
+                    success: true,
+                    meshId,
+                    written: false,
+                    dryRun: true,
+                    path: absolutePath,
+                    relativePath,
+                    scaffold,
+                    scaffoldJson,
+                    note: 'Dry-run: nothing written. Re-run with write=true to persist to the repo (commit target). meshes.json is untouched.',
+                };
+            }
+
+            mkdirSync(dirname(absolutePath), { recursive: true });
+            writeFileSync(absolutePath, `${scaffoldJson}\n`, 'utf-8');
+            return {
+                success: true,
+                meshId,
+                written: true,
+                dryRun: false,
+                path: absolutePath,
+                relativePath,
+                scaffold,
+                scaffoldJson,
+                note: 'Wrote .adhdev/mesh.json (repo commit target). Commit it to the repo; meshes.json (machine-local) is unchanged.',
+            };
+        } catch (e: any) {
+            return { success: false, error: e.message };
+        }
+    },
+
     delete_mesh: async (_ctx: MedFamilyContext, args: any) => {
         const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
         if (!meshId) return { success: false, error: 'meshId required' };
@@ -302,6 +391,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/chat-history.ts

@@ -1820,6 +1820,16 @@ function callProviderNativeHistoryRead(
     const result = fn({
         agentType,
         sessionId: normalizedSessionId,
+        // Arm the native-history executor's session pin guard. When the
+        // instance is already bound to a provider session, pass that id as
+        // `providerSessionId` so the executor rejects any *other* newest
+        // session it would otherwise pick (hermes ≥0.14 creates a fresh
+        // `sessions` row per internal sub-session, so an unpinned
+        // newest-wins query drifts to a different id on every read →
+        // re-bind churn + unbounded history re-hydration). When there is no
+        // bound id yet (first-bind / workspace-only discovery) this is '',
+        // which leaves the guard disarmed so discovery still works.
+        providerSessionId: normalizedSessionId,
         historySessionId: normalizedSessionId,
         workspace,
         format: canonicalHistory?.format,

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
@@ -203,6 +204,7 @@ export type { CreateMeshOptions, UpdateMeshOptions, AddNodeOptions } from './con
 // them without taking a direct @adhdev/mesh-shared dependency).
 export type {
   MagiPanel, MagiPanelMember, MagiPanelMap, MagiMode, MagiTaskKind, MagiPanelDefaultKind,
+  MagiSlot, MagiKindPanelMap,
   MagiClaim, MagiClaimStance, MagiAgentResponse,
   MagiResponseSource, MagiReplicaGitRef, MagiGitSkew, MagiSynthesizedResponse,
   MagiClusterCategory, MagiClusterMember, MagiClaimCluster, MagiSynthesis,

package/src/mesh/coordinator-prompt.ts

@@ -207,6 +207,9 @@ Repository: \`${mesh.repoIdentity}\`${mesh.defaultBranch ? `\nDefault branch: \`
     // ── Workflow ──
     sections.push(WORKFLOW_SECTION);
 
+    // ── Onboarding / Reinit ──
+    sections.push(ONBOARDING_SECTION);
+
     // ── Rules ──
     sections.push(buildRulesSection(coordinatorCliType));
 
@@ -255,6 +258,7 @@ function readUserPromptFile(cliType: string | undefined, suffix: string): string
  *   {{policy}}          — full policy section
  *   {{tools}}           — the canonical tools table
  *   {{workflow}}        — the canonical orchestration workflow
+ *   {{onboarding}}      — the guided init/reinit onboarding section
  *   {{rules}}           — the canonical rules section (with coordinatorNote)
  *   {{toolExposurePreflight}} — the MCP-missing preflight reminder
  *
@@ -281,6 +285,7 @@ function expandPromptPlaceholders(template: string, ctx: CoordinatorPromptContex
         policy: buildPolicySection(mergeAndNormalizePolicy(undefined, mesh.policy)),
         tools: TOOLS_SECTION,
         workflow: WORKFLOW_SECTION,
+        onboarding: ONBOARDING_SECTION,
         rules: buildRulesSection(coordinatorCliType),
         toolExposurePreflight: TOOL_EXPOSURE_PREFLIGHT_SECTION,
     };
@@ -493,7 +498,12 @@ const TOOLS_SECTION = `## Available Tools
 | \`mesh_clone_node\` | Create a worktree node for isolated parallel branch work |
 | \`mesh_refine_node\` | Validate and merge a completed worktree node back into its base branch |
 | \`mesh_remove_node\` | Remove a node (cleans up worktree if applicable) |
-| \`mesh_cleanup_sessions\` | Manually clean up delegated session records for a node |`;
+| \`mesh_cleanup_sessions\` | Manually clean up delegated session records for a node |
+| \`mesh_init\` | Guided onboarding for a fresh repo: dry-run scan → suggest \`.adhdev/*\` configs (refine/bootstrap/change-impact) + providerPriority + current-config echo; gated write on approval |
+| \`mesh_reinit\` | Re-onboard an already-configured repo: re-suggest with overwrite semantics + current-vs-suggested diff; dry-run preview first, per-section approval before write |
+| \`mesh_write_mesh_json_config\` | Gated write of \`.adhdev/mesh.json\` (repo coordinator-prompt config) from the mesh entry — dry-run/overwrite like mesh_init |
+| \`mesh_magi_kind_panel_set\` | Bind a task_kind → MAGI kind-panel slots (machine-local, wholesale replacement — approve current-vs-new first) |
+| \`mesh_magi_kind_panel_list\` | List configured task_kind → MAGI kind-panel slot bindings (machine-local, read-only) |`;
 
 const TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
@@ -529,6 +539,29 @@ Follow these recovery rules:
 3. **If no recovery context**: The stop may be intentional (normal completion). Use \`mesh_read_chat\` once to verify, then move on.
 4. **Always record what happened**: After handling a failure, briefly note the outcome in your report to the user.`;
 
+const ONBOARDING_SECTION = `## Onboarding / Reinit
+
+When the user asks to **set up / configure / onboard** this repo for Repo Mesh (or to **re-init / reconfigure** an already-onboarded repo), run ONE guided, approval-gated conversation. You draft, the user approves, the daemon writes. Never auto-write a heuristic suggestion without an explicit user approval turn.
+
+**Save scopes — label every draft with its scope before asking for approval:**
+- **repo-file (commit target)** — \`.adhdev/refine.json\`, \`.adhdev/worktree_bootstrap.json\`, \`.adhdev/change-impact.json\`, \`.adhdev/mesh.json\`. These are committed to the repository and shared with every machine/contributor.
+- **machine-local** — MAGI kind→panel bindings and named MAGI panels, node providerPriority (\`~/.adhdev/meshes.json\`). These stay on this machine and are NOT committed.
+
+**Guided sequence:**
+1. **Scan (dry-run)** — Call \`mesh_init\` (write=false, the default). It returns per-domain suggested configs for refine / worktree_bootstrap / change-impact, a recommended providerPriority, AND \`currentConfig\` — the currently-saved config per domain (repo files + machine-local \`magiKindPanels\`). Nothing is written.
+2. **Present drafts** — For each domain, show the user the suggested config with its **save scope label** (repo-file vs machine-local). When \`currentConfig\` already has a saved value for a domain (init on a partially-onboarded repo, or any reinit), present a **current-vs-suggested diff**, not just the suggestion.
+3. **Approve → gated write** — Only after the user approves, call the matching gated-write tool:
+   - repo \`.adhdev/*\` config files → \`mesh_init\` with \`write=true\` (and \`overwrite=true\` ONLY for domains the user approved replacing).
+   - \`.adhdev/mesh.json\` (coordinator prompt / operating notes) → \`mesh_write_mesh_json_config\` (write=true, overwrite only if approved).
+   - machine-local MAGI kind→panel slots → \`mesh_magi_kind_panel_set\` (write=true). NOTE: a kind binding is a **wholesale replacement** of that kind's slot list — present the current-vs-new slots first.
+   - machine-local named MAGI panels → \`mesh_magi_panel_set\`. providerPriority → apply via node policy update.
+
+**init vs reinit:**
+- **\`mesh_init\`** — for a fresh, never-onboarded repo. Existing config files are kept (existing-wins) unless the user explicitly approves overwrite. Use for first-time setup.
+- **\`mesh_reinit\`** — for a repo that is already onboarded and needs its config refreshed. It re-suggests with OVERWRITE semantics and returns the current-vs-suggested \`currentConfig\` echo. Its first call is a DRY-RUN preview: you MUST present the per-section current-vs-suggested diff and get EXPLICIT per-section approval before re-invoking with write=true. Overwrite is a wholesale replacement, so it silently drops operator hand-edits if you skip the diff — never do that.
+
+`;
+
 function buildRulesSection(coordinatorCliType?: string): string {
     const coordinatorNote = coordinatorCliType
         ? `\n- **Coordinator runtime is not a delegation default.** This coordinator is running as \`${coordinatorCliType}\`, but delegated node sessions must follow the user's requested provider, not the coordinator's own runtime.`