@adhdev/daemon-core 0.9.82-rc.5 → 0.9.82-rc.500

package/src/mesh/mesh-host-ownership.ts

@@ -0,0 +1,111 @@
+import { daemonIdsEquivalent } from '@adhdev/mesh-shared';
+import type { RepoMeshDaemonRole, RepoMeshHostMetadata, RepoMeshHostStatus } from '../repo-mesh-types.js';
+
+function readObject(value: unknown): Record<string, unknown> | null {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+
+function readString(value: unknown): string | undefined {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+export function normalizeMeshDaemonRole(value: unknown): RepoMeshDaemonRole | undefined {
+    return value === 'host' || value === 'member' ? value : undefined;
+}
+
+/**
+ * Options for resolveMeshHostStatus's read-side host-pin default.
+ *
+ * `localDaemonId` is the id of the daemon evaluating the mesh (typically
+ * `deps.statusInstanceId`). When the persisted `meshHost` declares `role:'host'`
+ * but carries NO `hostDaemonId` (the first-setup miss — a host mesh whose pin was
+ * never written to config), the host daemon IS this local daemon by definition, so
+ * we synthesize `hostDaemonId = localDaemonId` (and, when the mesh has a node
+ * representing this daemon, `hostNodeId`). This is the read-side default — the SSOT
+ * is computed from the role + the evaluating daemon's identity rather than requiring
+ * a config migration to backfill every already-created mesh.
+ *
+ * HARD guard: the synthesis fires ONLY for `role:'host'`. A `role:'member'` daemon
+ * must NEVER fill itself in as host — that would make a member falsely claim
+ * coordinator/queue ownership.
+ */
+export interface ResolveMeshHostOptions {
+    /** Id of the daemon evaluating this mesh (e.g. deps.statusInstanceId). */
+    localDaemonId?: string;
+}
+
+export function resolveMeshHostStatus(mesh: unknown, opts?: ResolveMeshHostOptions): RepoMeshHostStatus {
+    const meshRecord = readObject(mesh);
+    const raw = readObject(meshRecord?.meshHost);
+    const role = normalizeMeshDaemonRole(raw?.role) ?? 'host';
+    const pairing = readObject(raw?.pairing);
+    const normalized: RepoMeshHostStatus = {
+        role,
+        canOwnCoordinator: role === 'host',
+        canOwnQueue: role === 'host',
+        defaulted: !raw,
+    };
+    let hostDaemonId = readString(raw?.hostDaemonId);
+    let hostNodeId = readString(raw?.hostNodeId);
+    const hostAddress = readString(raw?.hostAddress);
+    // HOST-MISSEED-FIRSTSETUP read-side default: a host mesh with no persisted
+    // hostDaemonId is hosted by THIS daemon (role:'host' is local-relative), so
+    // fill the pin from the evaluating daemon. Member daemons are never synthesized.
+    const localDaemonId = readString(opts?.localDaemonId);
+    if (role === 'host' && !hostDaemonId && localDaemonId) {
+        hostDaemonId = localDaemonId;
+        // Anchor hostNodeId to the node representing this local daemon, when present.
+        if (!hostNodeId && Array.isArray(meshRecord?.nodes)) {
+            const selfNode = (meshRecord!.nodes as unknown[]).find(n => {
+                const nodeDaemonId = readString(readObject(n)?.daemonId);
+                return nodeDaemonId ? daemonIdsEquivalent(nodeDaemonId, localDaemonId) : false;
+            });
+            const selfNodeId = readString(readObject(selfNode)?.id);
+            if (selfNodeId) hostNodeId = selfNodeId;
+        }
+    }
+    if (hostDaemonId) normalized.hostDaemonId = hostDaemonId;
+    if (hostNodeId) normalized.hostNodeId = hostNodeId;
+    if (hostAddress) normalized.hostAddress = hostAddress;
+    if (pairing) {
+        const status = pairing.status === 'pairing' || pairing.status === 'paired' || pairing.status === 'rejected' || pairing.status === 'revoked'
+            ? pairing.status
+            : 'not_configured';
+        normalized.pairing = {
+            status,
+            ...(readString(pairing.tokenId) ? { tokenId: readString(pairing.tokenId) } : {}),
+            ...(readString(pairing.joinedAt) ? { joinedAt: readString(pairing.joinedAt) } : {}),
+            ...(readString(pairing.lastPairedAt) ? { lastPairedAt: readString(pairing.lastPairedAt) } : {}),
+            ...(readString(pairing.lastRejectedAt) ? { lastRejectedAt: readString(pairing.lastRejectedAt) } : {}),
+            ...(readString(pairing.expiresAt) ? { expiresAt: readString(pairing.expiresAt) } : {}),
+        };
+    }
+    return normalized;
+}
+
+export function isMeshHostOwner(mesh: unknown): boolean {
+    return resolveMeshHostStatus(mesh).role === 'host';
+}
+
+export function buildMeshHostRequiredFailure(mesh: unknown, operation: string): Record<string, unknown> {
+    const meshHost = resolveMeshHostStatus(mesh);
+    return {
+        success: false,
+        code: 'mesh_host_required',
+        error: `Mesh Host daemon required for ${operation}; member daemons must pair with the host and cannot own coordinator/queue mutations.`,
+        meshHost,
+    };
+}
+
+export function requireMeshHostQueueOwner(opts?: { ownerRole?: RepoMeshDaemonRole }): void {
+    if (opts?.ownerRole === 'member') {
+        throw new Error('Mesh Host daemon required to mutate mesh queue; member daemons must use the host-owned queue.');
+    }
+}
+
+export function createDefaultMeshHostMetadata(): RepoMeshHostMetadata {
+    return {
+        role: 'host',
+        pairing: { status: 'not_configured' },
+    };
+}

package/src/mesh/mesh-idle-reminder.ts

@@ -0,0 +1,153 @@
+/**
+ * Idle-active-mission reminder.
+ *
+ * When a coordinator session becomes fully idle — no queue/direct work in flight,
+ * no pending coordinator events to drain — yet the mesh still carries `active`
+ * missions, inject a one-shot "[System] Coordinator idle with N active mission(s)"
+ * reminder into that coordinator session. This nudges the coordinator to decide a
+ * lingering mission's real outcome (close it, or continue it) rather than leaving it
+ * drifting in `active` after its work is actually done.
+ *
+ * Precedent: mesh-missions.ts `maybeEmitMissionCloseCandidate` — a terminal-edge,
+ * once-per-edge coordinator nudge with an idempotency marker. This mirrors that
+ * shape, but the "edge" is the coordinator's idle transition (fired by the fast-path
+ * in mesh-event-forwarding and the slow-path idle tick in mesh-reconcile-loop) and
+ * the idempotency marker is a time+mission-set debounce held in MeshRuntimeStore
+ * (getIdleReminderState / setIdleReminderState). Fully best-effort: a throw here must
+ * never break the drain/injection path that called it.
+ *
+ * Design invariants:
+ *  - Only fires when the mesh has ≥1 `active` mission AND is fully idle. Fully idle =
+ *    buildMeshActiveWork over queue + direct dispatches reports totalActiveCount === 0
+ *    && generatingCount === 0. We intentionally do NOT probe remote node sessions here
+ *    (expensive per-tick RPC): any non-terminal queue/direct work already makes
+ *    totalActiveCount > 0, so the idle check is conservative — it suppresses the
+ *    reminder whenever any work is outstanding, which is the safe direction.
+ *  - NEVER transitions a mission's status. It only surfaces a hint; the coordinator
+ *    decides via mesh_mission_upsert.
+ *  - Debounced per mission-set. Re-fires only when the debounce window has elapsed OR
+ *    the set of active mission ids changed (a mission was closed/added), so a mesh that
+ *    stays idle with the same active missions is nudged at most once per window.
+ *  - Opt-out via policy.idleActiveMissionReminder === false.
+ */
+
+import { LOG } from '../logging/logger.js';
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { RepoMeshPolicy } from '../repo-mesh-types.js';
+import { MeshRuntimeStore } from './mesh-runtime-store.js';
+import { getMeshMissions, type MeshMissionRecord } from './mesh-missions.js';
+import { getQueue, getActiveDirectDispatches } from './mesh-work-queue.js';
+import { readLedgerEntries } from './mesh-ledger.js';
+import { buildMeshActiveWork } from './mesh-active-work.js';
+
+/** Coordinator instance the reminder is injected into (the idle CLI session). */
+type CoordinatorInstance = ReturnType<DaemonComponents['instanceManager']['getInstance']>;
+
+/**
+ * Debounce window: while the mesh stays idle with the SAME active-mission set, re-fire
+ * the reminder at most once per this interval. A changed mission set bypasses the window.
+ */
+export const IDLE_REMINDER_DEBOUNCE_MS = 300_000; // 5 minutes
+
+/** How many missions to name individually before folding the rest into "and M more". */
+const MISSION_LIST_CAP = 10;
+
+/** Stable hash of the active-mission id set (sorted, joined) for debounce comparison. */
+export function missionSetHash(missions: MeshMissionRecord[]): string {
+    return missions.map(m => m.id).sort().join(',');
+}
+
+/**
+ * Decide whether a reminder should fire this call, given the debounce marker. Pure so it
+ * is independently testable. Re-fires when there is no prior marker, the debounce window
+ * has elapsed, or the active-mission set changed since the last reminder.
+ */
+export function shouldFireIdleReminder(
+    last: { emittedAt: number; missionSetHash: string } | null,
+    hash: string,
+    now: number,
+    debounceMs: number = IDLE_REMINDER_DEBOUNCE_MS,
+): boolean {
+    if (!last) return true;
+    if (now - last.emittedAt > debounceMs) return true;
+    return hash !== last.missionSetHash;
+}
+
+/**
+ * Build the coordinator-facing reminder text. Deliberately terse — one line per mission
+ * (`title (id)`), NEVER the full goal (goals can be thousands of chars). When there are
+ * more than MISSION_LIST_CAP missions, name the first N and fold the remainder.
+ */
+export function buildIdleReminderMessage(missions: MeshMissionRecord[]): string {
+    const shown = missions.slice(0, MISSION_LIST_CAP);
+    const lines = shown.map(m => `- ${m.title} (${m.id})`);
+    const overflow = missions.length - shown.length;
+    if (overflow > 0) lines.push(`- …and ${overflow} more`);
+    return (
+        `[System] Coordinator idle with ${missions.length} active mission(s):\n`
+        + `${lines.join('\n')}\n`
+        + `The mesh has no work in flight. For each mission, decide its outcome: continue it `
+        + `(enqueue/dispatch the remaining work) or close it with `
+        + `mesh_mission_upsert(mission_id, status: "completed" | "abandoned"). `
+        + `Do not leave a finished mission in 'active'. This is a one-time reminder.`
+    );
+}
+
+/**
+ * Fire-and-forget idle-active-mission reminder. Call this at a coordinator idle edge
+ * once the pending-event queue is empty (nothing else to inject). `coordinator` is the
+ * idle CLI session to inject into; `policy` is the mesh's policy (for the opt-out flag).
+ *
+ * Returns true iff a reminder was injected on this call.
+ */
+export function maybeInjectIdleActiveMissionReminder(
+    meshId: string,
+    coordinator: CoordinatorInstance,
+    policy: RepoMeshPolicy | undefined,
+    now: number = Date.now(),
+): boolean {
+    try {
+        if (!coordinator) return false;
+        // Opt-out: default is ON; only an explicit false disables it.
+        if (policy?.idleActiveMissionReminder === false) return false;
+
+        // Active missions gate — no active mission, nothing to remind about.
+        const activeMissions = getMeshMissions(meshId, ['active']);
+        if (activeMissions.length === 0) return false;
+
+        // Fully-idle gate — any non-terminal queue/direct work suppresses the reminder.
+        // We pass no `nodes`: totalActiveCount already counts pending/assigned queue tasks
+        // and un-acknowledged direct dispatches from the store alone, so the check stays
+        // cheap (no per-node status RPC) and conservative.
+        const summary = buildMeshActiveWork({
+            meshId,
+            queue: getQueue(meshId),
+            directDispatches: getActiveDirectDispatches(meshId),
+            ledgerEntries: readLedgerEntries(meshId, { tail: 200 }),
+            now,
+        }).summary;
+        if (summary.totalActiveCount !== 0 || summary.generatingCount !== 0) return false;
+
+        // Debounce — same mission set within the window is nudged at most once.
+        const store = MeshRuntimeStore.getInstance();
+        const hash = missionSetHash(activeMissions);
+        const last = store.getIdleReminderState(meshId);
+        if (!shouldFireIdleReminder(last, hash, now)) return false;
+
+        const message = buildIdleReminderMessage(activeMissions);
+        coordinator.onEvent('send_message', {
+            input: { text: message, textFallback: message },
+        });
+        // Mark AFTER a successful inject so a mid-inject throw retries next edge rather
+        // than silently swallowing the only reminder.
+        store.setIdleReminderState(meshId, { emittedAt: now, missionSetHash: hash });
+        LOG.info(
+            'MeshIdleReminder',
+            `Injected idle reminder for mesh ${meshId} (${activeMissions.length} active mission(s), fully idle)`,
+        );
+        return true;
+    } catch (e: any) {
+        LOG.warn('MeshIdleReminder', `maybeInjectIdleActiveMissionReminder failed for mesh ${meshId}: ${e?.message || e}`);
+        return false;
+    }
+}

package/src/mesh/mesh-init.ts

@@ -0,0 +1,350 @@
+/**
+ * Mesh init / onboarding helper.
+ *
+ * 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. 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
+ *     execution source of truth; Refinery/bootstrap only ever read the saved
+ *     config. The suggestion functions never become the execution path.
+ *   - Writing is opt-in (`write: true`) and never clobbers an existing config
+ *     unless `overwrite: true` is set, so re-running init on an already-onboarded
+ *     repo is safe.
+ *   - The providerPriority recommendation is returned, not auto-applied to the
+ *     node policy — applying it mutates mesh policy, which is the coordinator's
+ *     decision.
+ */
+
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import {
+    MESH_REFINE_CONFIG_LOCATIONS,
+    loadMeshRefineConfig,
+    suggestMeshRefineConfig,
+    validateMeshRefineConfig,
+    type RepoMeshRefineConfig,
+    type RepoMeshRefineValidationCommandConfig,
+} from './refine-config.js';
+import {
+    MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS,
+    loadMeshWorktreeBootstrapConfig,
+    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.
+ * Only paths that actually exist in the workspace are recorded as staleInputs.
+ */
+const CANDIDATE_STALE_INPUTS = [
+    'package-lock.json',
+    'pnpm-lock.yaml',
+    'yarn.lock',
+    'bun.lockb',
+    'Cargo.lock',
+    'go.sum',
+    'poetry.lock',
+    'requirements.txt',
+];
+
+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 | ChangeImpactConfig;
+}
+
+/**
+ * Serialize a validated config to disk as pretty JSON, creating `.adhdev/` as
+ * needed. Returns the absolute path written. Never invoked unless the caller
+ * opted into writing.
+ */
+function writeConfigFile(workspace: string, relativePath: string, config: unknown): string {
+    const target = join(workspace, relativePath);
+    mkdirSync(dirname(target), { recursive: true });
+    writeFileSync(target, `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
+    return target;
+}
+
+/**
+ * Build a worktree_bootstrap scaffold from package scripts. Mirrors
+ * suggestMeshRefineConfig's "scaffold only" posture: prefers an `install`/`ci`
+ * style script, else falls back to `npm install`, and records existing
+ * lockfiles as staleInputs so a base merge that changes them re-runs bootstrap.
+ *
+ * Returns undefined when there is nothing meaningful to scaffold.
+ */
+export function suggestMeshWorktreeBootstrapConfig(
+    workspace: string,
+): { commands: RepoMeshRefineValidationCommandConfig[]; staleInputs: string[]; suggestedConfig?: RepoMeshWorktreeBootstrapConfig } {
+    const commands: RepoMeshRefineValidationCommandConfig[] = [];
+    const hasPackageJson = existsSync(join(workspace, 'package.json'));
+    const hasNpmLock = existsSync(join(workspace, 'package-lock.json'));
+
+    if (hasPackageJson) {
+        // `npm ci` requires a lockfile; otherwise fall back to `npm install`.
+        commands.push(
+            hasNpmLock
+                ? { command: 'npm', args: ['ci'] }
+                : { command: 'npm', args: ['install'] },
+        );
+    }
+
+    const staleInputs = CANDIDATE_STALE_INPUTS.filter((relative) => existsSync(join(workspace, relative)));
+
+    if (!commands.length) {
+        return { commands, staleInputs };
+    }
+
+    return {
+        commands,
+        staleInputs,
+        suggestedConfig: {
+            version: 1,
+            enabled: true,
+            runOnClone: true,
+            required: false,
+            commands,
+            ...(staleInputs.length ? { staleInputs } : {}),
+        },
+    };
+}
+
+/**
+ * Map detected CLI providers → an ordered node providerPriority list.
+ * Suggestion only: returned for the coordinator to apply to node policy, never
+ * written into mesh policy here.
+ *
+ * Ordering preference (most → least preferred) when installed:
+ *   claude-cli → codex-cli → gemini-cli → everything else (stable input order).
+ */
+const PROVIDER_PRIORITY_PREFERENCE = ['claude-cli', 'codex-cli', 'gemini-cli'];
+
+export function suggestNodeProviderPriority(detected: CLIInfo[]): {
+    providerPriority: string[];
+    installedProviders: Array<{ id: string; displayName: string; version?: string }>;
+} {
+    const installed = detected.filter((cli) => cli.installed);
+    const installedIds = installed.map((cli) => cli.id);
+
+    const preferred = PROVIDER_PRIORITY_PREFERENCE.filter((id) => installedIds.includes(id));
+    const rest = installedIds.filter((id) => !preferred.includes(id));
+    const providerPriority = [...preferred, ...rest];
+
+    return {
+        providerPriority,
+        installedProviders: installed.map((cli) => ({
+            id: cli.id,
+            displayName: cli.displayName,
+            ...(cli.version ? { version: cli.version } : {}),
+        })),
+    };
+}
+
+export interface RunMeshInitOptions {
+    /** When true, persist suggested configs to disk. Defaults to dry-run (false). */
+    write?: boolean;
+    /** 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<{ 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;
+}
+
+/**
+ * Orchestrate the full onboarding flow for one workspace:
+ *   detect installed CLIs → suggest refine + bootstrap configs → (optionally)
+ *   write them → recommend a node providerPriority.
+ *
+ * `detected` is injected (the caller resolves it via detectCLIs with its
+ * ProviderLoader) so this module stays free of provider-loader wiring and is
+ * trivially unit-testable.
+ */
+export function runMeshInit(
+    mesh: any,
+    workspace: string,
+    detected: CLIInfo[],
+    options: RunMeshInitOptions = {},
+): RunMeshInitResult {
+    const write = options.write === true;
+    const overwrite = options.overwrite === true;
+
+    const refine = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_REFINE_CONFIG_PATH,
+        existing: loadMeshRefineConfig(mesh, workspace).config,
+        suggestedConfig: suggestMeshRefineConfig(mesh, workspace).suggestedConfig,
+        validate: (config) => validateMeshRefineConfig(config, MESH_INIT_REFINE_CONFIG_PATH).valid,
+        write,
+        overwrite,
+    });
+
+    const bootstrapSuggestion = suggestMeshWorktreeBootstrapConfig(workspace);
+    const worktreeBootstrap = applyConfigSuggestion({
+        workspace,
+        relativePath: MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH,
+        existing: loadMeshWorktreeBootstrapConfig(mesh, workspace).config,
+        suggestedConfig: bootstrapSuggestion.suggestedConfig,
+        validate: (config) => validateMeshWorktreeBootstrapConfig(config, MESH_INIT_WORKTREE_BOOTSTRAP_CONFIG_PATH).valid,
+        write,
+        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. 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.',
+    };
+}
+
+/**
+ * Shared decision logic for a single config file: keep an existing config,
+ * skip when nothing was suggested, or (when allowed) write the validated
+ * suggestion to disk.
+ */
+function applyConfigSuggestion(input: {
+    workspace: string;
+    relativePath: string;
+    existing?: unknown;
+    suggestedConfig?: RepoMeshRefineConfig | RepoMeshWorktreeBootstrapConfig | ChangeImpactConfig;
+    validate: (config: unknown) => boolean;
+    write: boolean;
+    overwrite: boolean;
+}): MeshInitConfigFileResult {
+    const { workspace, relativePath, existing, suggestedConfig, validate, write, overwrite } = input;
+    const absolute = join(workspace, relativePath);
+
+    // An existing, valid config wins unless the caller explicitly opts into overwrite.
+    if (existing !== undefined && !overwrite) {
+        return { path: absolute, relativePath, written: false, skippedReason: 'already_exists', config: existing as any };
+    }
+
+    if (!suggestedConfig || !validate(suggestedConfig)) {
+        return { path: absolute, relativePath, written: false, skippedReason: 'no_suggestion' };
+    }
+
+    if (!write) {
+        return { path: absolute, relativePath, written: false, config: suggestedConfig };
+    }
+
+    const writtenPath = writeConfigFile(workspace, relativePath, suggestedConfig);
+    return { path: writtenPath, relativePath, written: true, config: suggestedConfig };
+}

package/src/mesh/mesh-ledger-reconciliation.ts

@@ -1,5 +1,12 @@
 import type { AppendRemoteLedgerResult, MeshLedgerSlice, MeshLedgerSummary } from './mesh-ledger.js';
 
+/** Minimal ledger slice shape accepted by buildMeshLedgerReplicaEvidence. Covers both JSONL and SQLite slices. */
+export interface AnyLedgerSlice {
+    entries: Array<{ id: string; meshId: string; timestamp: string; kind: string; nodeId?: string | null; sessionId?: string | null; providerType?: string | null; payload: unknown }>;
+    cursor: { afterId: string | null; nextAfterId: string | null; limit: number; hasMore: boolean };
+    summary?: MeshLedgerSummary;
+}
+
 export type MeshLedgerReplicaStatus = 'local' | 'queried' | 'imported' | 'failed';
 
 export interface MeshLedgerReplicaEvidence {
@@ -25,9 +32,8 @@ export interface MeshLedgerReconciliationEvidence {
     meshId: string;
     generatedAt: string;
     sourceOfTruth: {
-        kind: 'coordinator_local_jsonl';
+        kind: 'coordinator_local_sqlite';
         p2pOnly: true;
-        cloudD1LedgerSync: false;
         notes: string;
     };
     replicas: MeshLedgerReplicaEvidence[];
@@ -47,7 +53,7 @@ export interface MeshLedgerReconciliationEvidence {
     };
 }
 
-function lastTimestamp(slice?: MeshLedgerSlice): string | null {
+function lastTimestamp(slice?: AnyLedgerSlice): string | null {
     const entries = Array.isArray(slice?.entries) ? slice!.entries : [];
     return entries.length ? entries[entries.length - 1].timestamp : null;
 }
@@ -56,7 +62,7 @@ export function buildMeshLedgerReplicaEvidence(args: {
     nodeId: string;
     daemonId?: string;
     transport: 'local' | 'p2p_datachannel';
-    slice?: MeshLedgerSlice;
+    slice?: AnyLedgerSlice;
     importResult?: AppendRemoteLedgerResult;
     status?: MeshLedgerReplicaStatus;
     error?: string;
@@ -91,10 +97,9 @@ export function buildMeshLedgerReconciliationEvidence(meshId: string, replicas:
         meshId,
         generatedAt: new Date().toISOString(),
         sourceOfTruth: {
-            kind: 'coordinator_local_jsonl',
+            kind: 'coordinator_local_sqlite',
             p2pOnly: true,
-            cloudD1LedgerSync: false,
-            notes: 'Coordinator reconciles bounded slices from daemon-local JSONL ledgers over P2P DataChannel; Cloud/D1 is not a ledger source of truth.',
+            notes: 'Coordinator reconciles bounded slices from daemon-local SQLite event ledgers (mesh_event_ledger table) over P2P DataChannel; Cloud/D1 is not a ledger source of truth.',
         },
         replicas,
         totals: {