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

package/src/mesh/mesh-init.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
@@ -34,11 +40,21 @@ import {
     validateMeshWorktreeBootstrapConfig,
     type RepoMeshWorktreeBootstrapConfig,
 } from './worktree-bootstrap-config.js';
+import {
+    CHANGE_IMPACT_CONFIG_LOCATIONS,
+    loadChangeImpactConfig,
+    suggestChangeImpactConfig,
+    validateChangeImpactConfig,
+    type ChangeImpactConfig,
+} from '../git/change-impact-config.js';
+import { listMagiKindPanels } from '../config/mesh-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 const MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
 export const MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
+export const MESH_INIT_CHANGE_IMPACT_CONFIG_PATH = CHANGE_IMPACT_CONFIG_LOCATIONS[0];
 
 /**
  * Default lockfiles whose change should invalidate a 'ready' bootstrap.
@@ -61,7 +77,7 @@ export interface MeshInitConfigFileResult {
     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;
 }
 
 /**
@@ -158,16 +174,50 @@ export interface RunMeshInitOptions {
     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<{ id: string; displayName: string; 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;
 }
 
@@ -210,18 +260,58 @@ export function runMeshInit(
         overwrite,
     });
 
+    // change-impact classification (.adhdev/change-impact.json). suggest/validate/save
+    // mirror refine's engine exactly, so it drops into the same applyConfigSuggestion
+    // gate: existing-wins unless overwrite, dry-run by default, validated before write.
+    const changeImpactLoaded = loadChangeImpactConfig(workspace);
+    const changeImpact = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_CHANGE_IMPACT_CONFIG_PATH,
+        existing: changeImpactLoaded.sourceType === 'repo_file' ? changeImpactLoaded.config : undefined,
+        suggestedConfig: suggestChangeImpactConfig(workspace).suggestedConfig,
+        validate: (config) => validateChangeImpactConfig(config, MESH_INIT_CHANGE_IMPACT_CONFIG_PATH).valid,
+        write,
+        overwrite,
+    });
+
     const providers = suggestNodeProviderPriority(detected);
 
+    // Read-only echo of the currently-saved config per domain so the coordinator can
+    // present a current-vs-suggested diff before any overwrite (init vs reinit). This
+    // never suggests — it reports what is on disk / machine-local right now.
+    const refineLoaded = loadMeshRefineConfig(mesh, workspace);
+    const bootstrapLoaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
+    let magiKindPanels: MagiKindPanelMap = {};
+    try {
+        magiKindPanels = listMagiKindPanels();
+    } catch {
+        // Machine-local config unreadable — echo an empty binding rather than failing init.
+        magiKindPanels = {};
+    }
+    const currentConfig: MeshInitCurrentConfigEcho = {
+        refine: refineLoaded.config,
+        worktreeBootstrap: bootstrapLoaded.config,
+        changeImpact: changeImpactLoaded.sourceType === 'repo_file' ? changeImpactLoaded.config : undefined,
+        sourceTypes: {
+            refine: refineLoaded.sourceType,
+            worktreeBootstrap: bootstrapLoaded.sourceType,
+            changeImpact: changeImpactLoaded.sourceType,
+        },
+        magiKindPanels,
+    };
+
     return {
         success: true,
         workspace,
         dryRun: !write,
         refine,
         worktreeBootstrap,
+        changeImpact,
         providers,
+        currentConfig,
         note: write
-            ? 'Configs written to disk are the execution source of truth; suggestions are scaffold and only take effect once saved. providerPriority is a recommendation — apply it to node policy via clone/policy update.'
-            : 'Dry-run: no files written. Re-run with write=true to persist the suggested configs. Heuristic suggestions never execute until saved as repo config.',
+            ? 'Configs written to disk are the execution source of truth; suggestions are scaffold and only take effect once saved. providerPriority is a recommendation — apply it to node policy via clone/policy update. currentConfig echoes what was on disk before this run.'
+            : 'Dry-run: no files written. Re-run with write=true to persist the suggested configs. Heuristic suggestions never execute until saved as repo config. Use currentConfig to diff current-vs-suggested before overwriting.',
     };
 }
 
@@ -234,7 +324,7 @@ function applyConfigSuggestion(input: {
     workspace: string;
     relativePath: string;
     existing?: unknown;
-    suggestedConfig?: RepoMeshRefineConfig | RepoMeshWorktreeBootstrapConfig;
+    suggestedConfig?: RepoMeshRefineConfig | RepoMeshWorktreeBootstrapConfig | ChangeImpactConfig;
     validate: (config: unknown) => boolean;
     write: boolean;
     overwrite: boolean;

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/cli-provider-instance.ts

@@ -2813,7 +2813,13 @@ export class CliProviderInstance implements ProviderInstance {
             typeof data.providerSessionId === 'string' ? data.providerSessionId : '',
         );
         if (patchedProviderSessionId) {
-            this.promoteProviderSessionId(patchedProviderSessionId);
+            // A provider-response id is authoritative when it carries an
+            // explicit `new_session` marker (the CLI genuinely started a new
+            // conversation). Without that marker it's just an observed id and
+            // must not hijack an existing binding (see promoteProviderSessionId).
+            this.promoteProviderSessionId(patchedProviderSessionId, {
+                authoritative: data.sessionEvent === 'new_session',
+            });
         }
 
         if (data.sessionEvent === 'new_session') {
@@ -3167,10 +3173,26 @@ export class CliProviderInstance implements ProviderInstance {
         return lines.join('\n');
     }
 
-    private promoteProviderSessionId(sessionId: string): void {
+    private promoteProviderSessionId(sessionId: string, opts: { authoritative?: boolean } = {}): void {
         const nextSessionId = String(sessionId || '').trim();
         if (!nextSessionId || nextSessionId === this.providerSessionId) return;
 
+        // Sticky binding: once this instance is bound to a provider session,
+        // an *observed* id (one discovered from a status parse or the native
+        // history reader) must NOT hijack the live binding. hermes ≥0.14
+        // spawns a fresh `sessions` row per internal sub-session, so a
+        // newest-wins native read surfaces a different id mid-turn on every
+        // poll; accepting it would re-bind the instance, re-hydrate unbounded
+        // history (daemon saturation) and reset completion detection so the
+        // turn never finalizes. Only an *authoritative* change — the first
+        // bind (no id yet) or an explicit provider `new_session`/resume — may
+        // replace an existing binding. Legitimate resume/new-session paths
+        // pass authoritative:true and are unaffected.
+        if (this.providerSessionId && !opts.authoritative) {
+            LOG.debug('CLI', `[${this.type}] ignoring non-authoritative session id ${nextSessionId} (bound to ${this.providerSessionId})`);
+            return;
+        }
+
         const previousHistorySessionId = this.providerSessionId || this.instanceId;
         const previousProviderSessionId = this.providerSessionId;
         this.providerSessionId = nextSessionId;

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/native-history/dispatcher.ts

@@ -66,7 +66,7 @@ export function createNativeHistoryDispatcher(reader: ReaderId): (input: NativeH
             try { fs.statSync(sourcePath); } catch { /* best-effort metadata refresh */ }
         }
 
-        const session = readByReader(reader, sourcePath, sessionId, workspace);
+        const session = readByReader(reader, sourcePath, sessionId, workspace, requestedProviderSid);
         if (!session) return null;
 
         if (requestedProviderSid && session.providerSessionId && session.providerSessionId !== requestedProviderSid) {
@@ -265,12 +265,18 @@ function readByReader(
     sourcePath: string,
     sessionId: string,
     workspace: string,
+    requestedProviderSid: string,
 ): any | null {
     switch (reader) {
         case 'claude-cli':      return readClaudeCliSession(sourcePath);
         case 'codex-cli':       return readCodexCliSession(sourcePath);
         case 'antigravity-cli': return readAntigravityCliSession(sourcePath, sessionId || undefined, workspace || undefined);
-        case 'hermes-cli':      return readHermesCliSession(sourcePath);
+        // hermes reads a *shared* state.db and would otherwise pick the newest
+        // source='cli' session, which drifts every read (hermes ≥0.14 writes a
+        // fresh row per internal sub-session). Pass the bound id so it reads
+        // THAT session directly instead of newest-wins. claude/codex resolve a
+        // per-session file upstream, so they need no equivalent pin here.
+        case 'hermes-cli':      return readHermesCliSession(sourcePath, requestedProviderSid || undefined);
     }
 }
 

package/src/providers/native-history/hermes-cli-transcript.ts

@@ -93,26 +93,42 @@ function loadMessagesForSession(db: any, sessionId: string): NativeHistoryMessag
     return out;
 }
 
-export function readSession(sessionPath: string): NativeHistorySession | null {
+export function readSession(sessionPath: string, requestedSessionId?: string): NativeHistorySession | null {
     if (!sessionPath) return null;
 
-    // Path mode A: SQLite — sourcePath is the state.db path. Pick the
-    // newest source='cli' session that has at least one persisted message.
+    // Path mode A: SQLite — sourcePath is the state.db path.
     if (sessionPath === HERMES_STATE_DB) {
         const db = openDb();
         if (!db) return null;
         try {
-            const row: any = db.prepare(
-                `SELECT id, started_at FROM sessions
-                 WHERE source = 'cli' AND message_count > 0
-                 ORDER BY started_at DESC LIMIT 1`,
-            ).get();
-            if (!row) return null;
-            const messages = loadMessagesForSession(db, row.id);
+            const pinned = String(requestedSessionId || '').trim();
+            let sessionId: string;
+            if (pinned) {
+                // Session pin: the caller is already bound to a specific
+                // provider session, so read THAT session directly instead of
+                // the newest-wins pick below. hermes ≥0.14 writes a fresh
+                // `sessions` row per internal sub-session, so an unpinned
+                // `ORDER BY started_at DESC LIMIT 1` drifts to a different id
+                // on every read → re-bind churn + reading completion evidence
+                // from the wrong session. loadMessagesForSession returning
+                // rows validates the id exists.
+                sessionId = pinned;
+            } else {
+                // No bound id yet (discovery): pick the newest source='cli'
+                // session that has at least one persisted message.
+                const row: any = db.prepare(
+                    `SELECT id, started_at FROM sessions
+                     WHERE source = 'cli' AND message_count > 0
+                     ORDER BY started_at DESC LIMIT 1`,
+                ).get();
+                if (!row) return null;
+                sessionId = String(row.id);
+            }
+            const messages = loadMessagesForSession(db, sessionId);
             if (messages.length === 0) return null;
             return {
                 messages,
-                providerSessionId: String(row.id),
+                providerSessionId: sessionId,
                 source: 'provider-native',
                 sourcePath: sessionPath,
                 sourceMtimeMs: statMtimeMs(sessionPath),

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/providers/spec/native-history-executor.ts

@@ -263,35 +263,50 @@ function executeSqlite(src: NativeHistorySqliteSource, input: NativeHistoryInput
     catch { return null; }
 
     try {
-        let sessionRow: any;
-        try {
-            // session_query may reference `?` to receive the session's
-            // start-time floor in seconds (e.g. WHERE started_at >= ?).
-            // That gives spec authors a robust way to keep prior-session
-            // rows out of a fresh dashboard view without inventing their
-            // own time arithmetic in SQL. When the caller didn't pass a
-            // session floor (i.e. no live session is associated with the
-            // call), we use 0 so spec queries that bind `?` still produce
-            // a sane result rather than choking the whole executor.
-            const sessionFloorSeconds = typeof input.sessionStartedAtMs === 'number'
-                ? Math.floor(input.sessionStartedAtMs / 1000)
-                : 0;
-            const stmt = db.prepare(src.session_query);
+        const requested = input.providerSessionId || '';
+        let sessionId: string;
+        if (requested) {
+            // Session pin: the caller already bound this instance to a
+            // specific provider session, so read THAT session directly and
+            // skip the newest-wins `session_query` entirely. hermes ≥0.14
+            // spawns a fresh `sessions` row per internal sub-session, so the
+            // `ORDER BY started_at DESC LIMIT 1` pick drifts to a different
+            // id on every read. Left unpinned that churns the bound session
+            // (each re-bind re-hydrates unbounded history → daemon
+            // saturation) and reads completion evidence from the wrong
+            // session (turn never finalizes). Binding straight to the
+            // requested id fixes both. Existence is validated below by the
+            // spec's own `message_query` returning rows for this id, so we
+            // don't hardcode any schema here.
+            sessionId = requested;
+        } else {
+            let sessionRow: any;
             try {
-                sessionRow = stmt.get(sessionFloorSeconds);
-            } catch {
-                sessionRow = stmt.get();
-            }
-        } catch { return null; }
-        if (!sessionRow) return null;
-        // First column of the first row is the session id.
-        const sessionIdRaw = Object.values(sessionRow)[0];
-        const sessionId = sessionIdRaw == null ? '' : String(sessionIdRaw);
+                // session_query may reference `?` to receive the session's
+                // start-time floor in seconds (e.g. WHERE started_at >= ?).
+                // That gives spec authors a robust way to keep prior-session
+                // rows out of a fresh dashboard view without inventing their
+                // own time arithmetic in SQL. When the caller didn't pass a
+                // session floor (i.e. no live session is associated with the
+                // call), we use 0 so spec queries that bind `?` still produce
+                // a sane result rather than choking the whole executor.
+                const sessionFloorSeconds = typeof input.sessionStartedAtMs === 'number'
+                    ? Math.floor(input.sessionStartedAtMs / 1000)
+                    : 0;
+                const stmt = db.prepare(src.session_query);
+                try {
+                    sessionRow = stmt.get(sessionFloorSeconds);
+                } catch {
+                    sessionRow = stmt.get();
+                }
+            } catch { return null; }
+            if (!sessionRow) return null;
+            // First column of the first row is the session id.
+            const sessionIdRaw = Object.values(sessionRow)[0];
+            sessionId = sessionIdRaw == null ? '' : String(sessionIdRaw);
+        }
         if (!sessionId) return null;
 
-        const requested = input.providerSessionId || '';
-        if (requested && sessionId !== requested) return null;
-
         const messageRows: any[] = db.prepare(src.message_query).all(sessionId);
         if (!messageRows || messageRows.length === 0) return null;
 

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 {