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

package/dist/index.mjs

@@ -404,10 +404,10 @@ function readInjected(value) {
 }
 function getDaemonBuildInfo() {
   if (cached) return cached;
-  const commit = readInjected(true ? "84f8b9ff2e41b3bbf8375a9e4594c0ec33905b6e" : void 0) ?? "unknown";
-  const commitShort = readInjected(true ? "84f8b9ff" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-  const version = readInjected(true ? "0.9.82-rc.438" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-  const builtAt = readInjected(true ? "2026-07-01T02:03:18.523Z" : void 0);
+  const commit = readInjected(true ? "065287032ac520cf8950f90025e1758b873723b1" : void 0) ?? "unknown";
+  const commitShort = readInjected(true ? "06528703" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+  const version = readInjected(true ? "0.9.82-rc.439" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+  const builtAt = readInjected(true ? "2026-07-01T04:55:17.522Z" : void 0);
   cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
   return cached;
 }
@@ -3498,6 +3498,7 @@ Default branch: \`${mesh.defaultBranch}\`` : ""}`);
   sections.push(TOOLS_SECTION);
   sections.push(TOOL_EXPOSURE_PREFLIGHT_SECTION);
   sections.push(WORKFLOW_SECTION);
+  sections.push(ONBOARDING_SECTION);
   sections.push(buildRulesSection(coordinatorCliType));
   return sections.join("\n\n");
 }
@@ -3530,6 +3531,7 @@ function expandPromptPlaceholders(template, ctx) {
     policy: buildPolicySection(mergeAndNormalizePolicy(void 0, mesh.policy)),
     tools: TOOLS_SECTION,
     workflow: WORKFLOW_SECTION,
+    onboarding: ONBOARDING_SECTION,
     rules: buildRulesSection(coordinatorCliType),
     toolExposurePreflight: TOOL_EXPOSURE_PREFLIGHT_SECTION
   };
@@ -3688,7 +3690,7 @@ function buildRulesSection(coordinatorCliType) {
 - **Never fabricate tool results.** Always call the actual tool.
 - **Keep the user informed.** One or two sentences after each delegation round.${coordinatorNote}`;
 }
-var TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION;
+var TOOLS_SECTION, TOOL_EXPOSURE_PREFLIGHT_SECTION, WORKFLOW_SECTION, ONBOARDING_SECTION;
 var init_coordinator_prompt = __esm({
   "src/mesh/coordinator-prompt.ts"() {
     "use strict";
@@ -3717,7 +3719,12 @@ var init_coordinator_prompt = __esm({
 | \`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 \u2192 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 \u2014 dry-run/overwrite like mesh_init |
+| \`mesh_magi_kind_panel_set\` | Bind a task_kind \u2192 MAGI kind-panel slots (machine-local, wholesale replacement \u2014 approve current-vs-new first) |
+| \`mesh_magi_kind_panel_list\` | List configured task_kind \u2192 MAGI kind-panel slot bindings (machine-local, read-only) |`;
     TOOL_EXPOSURE_PREFLIGHT_SECTION = `## Tool Exposure Preflight
 
 Before doing any coordinator work, confirm that the actual callable tool list includes \`mesh_status\` and the other \`mesh_*\` tools from the table above. If this Repo Mesh coordinator prompt is present but the callable \`mesh_*\` tools are missing, the MCP server/tool manifest is stale or not injected yet. Do not substitute terminal/file/git tools, do not inspect or edit the repository directly, and do not continue as a non-mesh local coding agent. Stop immediately and tell the user to run \`/reload-mcp\` or start a fresh coordinator session so ADHDev can reconnect \`adhdev-mesh\`.`;
@@ -3750,6 +3757,28 @@ Follow these recovery rules:
 2. **If "Max retries exceeded"**: Do NOT retry on the same node. Either reassign the task to a different node, or inform the user that the task requires manual intervention.
 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.`;
+    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 \u2014 label every draft with its scope before asking for approval:**
+- **repo-file (commit target)** \u2014 \`.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** \u2014 MAGI kind\u2192panel 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)** \u2014 Call \`mesh_init\` (write=false, the default). It returns per-domain suggested configs for refine / worktree_bootstrap / change-impact, a recommended providerPriority, AND \`currentConfig\` \u2014 the currently-saved config per domain (repo files + machine-local \`magiKindPanels\`). Nothing is written.
+2. **Present drafts** \u2014 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 \u2192 gated write** \u2014 Only after the user approves, call the matching gated-write tool:
+   - repo \`.adhdev/*\` config files \u2192 \`mesh_init\` with \`write=true\` (and \`overwrite=true\` ONLY for domains the user approved replacing).
+   - \`.adhdev/mesh.json\` (coordinator prompt / operating notes) \u2192 \`mesh_write_mesh_json_config\` (write=true, overwrite only if approved).
+   - machine-local MAGI kind\u2192panel slots \u2192 \`mesh_magi_kind_panel_set\` (write=true). NOTE: a kind binding is a **wholesale replacement** of that kind's slot list \u2014 present the current-vs-new slots first.
+   - machine-local named MAGI panels \u2192 \`mesh_magi_panel_set\`. providerPriority \u2192 apply via node policy update.
+
+**init vs reinit:**
+- **\`mesh_init\`** \u2014 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\`** \u2014 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 \u2014 never do that.
+
+`;
   }
 });
 
@@ -28234,6 +28263,16 @@ function callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, his
   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,
@@ -38649,24 +38688,28 @@ function executeSqlite(src, input) {
     return null;
   }
   try {
-    let sessionRow;
-    try {
-      const sessionFloorSeconds = typeof input.sessionStartedAtMs === "number" ? Math.floor(input.sessionStartedAtMs / 1e3) : 0;
-      const stmt = db.prepare(src.session_query);
+    const requested = input.providerSessionId || "";
+    let sessionId;
+    if (requested) {
+      sessionId = requested;
+    } else {
+      let sessionRow;
       try {
-        sessionRow = stmt.get(sessionFloorSeconds);
+        const sessionFloorSeconds = typeof input.sessionStartedAtMs === "number" ? Math.floor(input.sessionStartedAtMs / 1e3) : 0;
+        const stmt = db.prepare(src.session_query);
+        try {
+          sessionRow = stmt.get(sessionFloorSeconds);
+        } catch {
+          sessionRow = stmt.get();
+        }
       } catch {
-        sessionRow = stmt.get();
+        return null;
       }
-    } catch {
-      return null;
+      if (!sessionRow) return null;
+      const sessionIdRaw = Object.values(sessionRow)[0];
+      sessionId = sessionIdRaw == null ? "" : String(sessionIdRaw);
     }
-    if (!sessionRow) return null;
-    const sessionIdRaw = Object.values(sessionRow)[0];
-    const sessionId = sessionIdRaw == null ? "" : String(sessionIdRaw);
     if (!sessionId) return null;
-    const requested = input.providerSessionId || "";
-    if (requested && sessionId !== requested) return null;
     const messageRows = db.prepare(src.message_query).all(sessionId);
     if (!messageRows || messageRows.length === 0) return null;
     const mtime = safeMtimeMs(resolved);
@@ -42108,7 +42151,9 @@ var CliProviderInstance = class _CliProviderInstance {
       typeof data.providerSessionId === "string" ? data.providerSessionId : ""
     );
     if (patchedProviderSessionId) {
-      this.promoteProviderSessionId(patchedProviderSessionId);
+      this.promoteProviderSessionId(patchedProviderSessionId, {
+        authoritative: data.sessionEvent === "new_session"
+      });
     }
     if (data.sessionEvent === "new_session") {
       this.runtimeMessages = [];
@@ -42403,9 +42448,13 @@ ${effect.notification.body || ""}`.trim();
     }
     return lines.join("\n");
   }
-  promoteProviderSessionId(sessionId) {
+  promoteProviderSessionId(sessionId, opts = {}) {
     const nextSessionId = String(sessionId || "").trim();
     if (!nextSessionId || nextSessionId === this.providerSessionId) return;
+    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;
@@ -46326,23 +46375,30 @@ function loadMessagesForSession(db, sessionId) {
   }
   return out;
 }
-function readSession4(sessionPath) {
+function readSession4(sessionPath, requestedSessionId) {
   if (!sessionPath) return null;
   if (sessionPath === HERMES_STATE_DB) {
     const db = openDb();
     if (!db) return null;
     try {
-      const row = 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 messages2 = loadMessagesForSession(db, row.id);
+      const pinned = String(requestedSessionId || "").trim();
+      let sessionId2;
+      if (pinned) {
+        sessionId2 = pinned;
+      } else {
+        const row = 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;
+        sessionId2 = String(row.id);
+      }
+      const messages2 = loadMessagesForSession(db, sessionId2);
       if (messages2.length === 0) return null;
       return {
         messages: messages2,
-        providerSessionId: String(row.id),
+        providerSessionId: sessionId2,
         source: "provider-native",
         sourcePath: sessionPath,
         sourceMtimeMs: statMtimeMs4(sessionPath),
@@ -46414,7 +46470,7 @@ function createNativeHistoryDispatcher(reader) {
       } catch {
       }
     }
-    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) {
       return null;
@@ -46577,7 +46633,7 @@ function resolveHermesPath(workspace, sessionId) {
   if (!fs24.existsSync(dir)) return null;
   return newestRecentFile2(dir, /^session_.*\.json$/);
 }
-function readByReader(reader, sourcePath, sessionId, workspace) {
+function readByReader(reader, sourcePath, sessionId, workspace, requestedProviderSid) {
   switch (reader) {
     case "claude-cli":
       return readSession(sourcePath);
@@ -46585,8 +46641,13 @@ function readByReader(reader, sourcePath, sessionId, workspace) {
       return readSession2(sourcePath);
     case "antigravity-cli":
       return readSession3(sourcePath, sessionId || void 0, workspace || void 0);
+    // 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 readSession4(sourcePath);
+      return readSession4(sourcePath, requestedProviderSid || void 0);
   }
 }
 function cwdAsDashes(cwd) {
@@ -49273,6 +49334,88 @@ var meshCrudHandlers = {
       return { success: false, error: e.message };
     }
   },
+  // 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, args) => {
+    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: getMesh2 } = await Promise.resolve().then(() => (init_mesh_config(), mesh_config_exports));
+      const mesh = getMesh2(meshId);
+      if (!mesh) return { success: false, error: "Mesh not found" };
+      const {
+        buildMeshJsonConfigScaffold: buildMeshJsonConfigScaffold2,
+        serializeMeshJsonConfigScaffold: serializeMeshJsonConfigScaffold2,
+        loadRepoMeshJsonConfig: loadRepoMeshJsonConfig2,
+        normalizeRepoMeshDeclarativeConfig: normalizeRepoMeshDeclarativeConfig2,
+        MESH_JSON_CONFIG_LOCATIONS: MESH_JSON_CONFIG_LOCATIONS2
+      } = await Promise.resolve().then(() => (init_mesh_json_config(), mesh_json_config_exports));
+      const { mkdirSync: mkdirSync21, writeFileSync: writeFileSync24 } = await import("fs");
+      const { dirname: dirname17, join: join49 } = await import("path");
+      const scaffold = buildMeshJsonConfigScaffold2(mesh);
+      const scaffoldJson = serializeMeshJsonConfigScaffold2(scaffold);
+      const relativePath = MESH_JSON_CONFIG_LOCATIONS2[0];
+      const absolutePath = join49(workspace, relativePath);
+      const validation = normalizeRepoMeshDeclarativeConfig2(scaffold);
+      if (!validation.valid) {
+        return { success: false, meshId, error: `invalid mesh.json scaffold: ${validation.errors.join("; ")}` };
+      }
+      const existing = loadRepoMeshJsonConfig2(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 \u2014 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."
+        };
+      }
+      mkdirSync21(dirname17(absolutePath), { recursive: true });
+      writeFileSync24(absolutePath, `${scaffoldJson}
+`, "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) {
+      return { success: false, error: e.message };
+    }
+  },
   delete_mesh: async (_ctx, args) => {
     const meshId = typeof args?.meshId === "string" ? args.meshId.trim() : "";
     if (!meshId) return { success: false, error: "meshId required" };
@@ -50298,10 +50441,13 @@ init_mesh_fast_forward();
 // src/mesh/mesh-init.ts
 init_refine_config();
 init_worktree_bootstrap_config();
+init_change_impact_config();
+init_mesh_config();
 import { existsSync as existsSync38, mkdirSync as mkdirSync15, writeFileSync as writeFileSync18 } from "fs";
 import { dirname as dirname11, join as join41 } from "path";
 var MESH_INIT_REFINE_CONFIG_PATH = MESH_REFINE_CONFIG_LOCATIONS[0];
 var MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH = MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS[0];
+var MESH_INIT_CHANGE_IMPACT_CONFIG_PATH = CHANGE_IMPACT_CONFIG_LOCATIONS[0];
 var CANDIDATE_STALE_INPUTS = [
   "package-lock.json",
   "pnpm-lock.yaml",
@@ -50383,15 +50529,46 @@ function runMeshInit(mesh, workspace, detected, options = {}) {
     write,
     overwrite
   });
+  const changeImpactLoaded = loadChangeImpactConfig(workspace);
+  const changeImpact = applyConfigSuggestion({
+    workspace,
+    relativePath: MESH_INIT_CHANGE_IMPACT_CONFIG_PATH,
+    existing: changeImpactLoaded.sourceType === "repo_file" ? changeImpactLoaded.config : void 0,
+    suggestedConfig: suggestChangeImpactConfig(workspace).suggestedConfig,
+    validate: (config) => validateChangeImpactConfig(config, MESH_INIT_CHANGE_IMPACT_CONFIG_PATH).valid,
+    write,
+    overwrite
+  });
   const providers = suggestNodeProviderPriority(detected);
+  const refineLoaded = loadMeshRefineConfig(mesh, workspace);
+  const bootstrapLoaded = loadMeshWorktreeBootstrapConfig(mesh, workspace);
+  let magiKindPanels = {};
+  try {
+    magiKindPanels = listMagiKindPanels();
+  } catch {
+    magiKindPanels = {};
+  }
+  const currentConfig2 = {
+    refine: refineLoaded.config,
+    worktreeBootstrap: bootstrapLoaded.config,
+    changeImpact: changeImpactLoaded.sourceType === "repo_file" ? changeImpactLoaded.config : void 0,
+    sourceTypes: {
+      refine: refineLoaded.sourceType,
+      worktreeBootstrap: bootstrapLoaded.sourceType,
+      changeImpact: changeImpactLoaded.sourceType
+    },
+    magiKindPanels
+  };
   return {
     success: true,
     workspace,
     dryRun: !write,
     refine,
     worktreeBootstrap,
+    changeImpact,
     providers,
-    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 \u2014 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."
+    currentConfig: currentConfig2,
+    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 \u2014 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."
   };
 }
 function applyConfigSuggestion(input) {