@adhdev/daemon-core 0.9.82-rc.43 → 0.9.82-rc.430

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

@@ -0,0 +1,73 @@
+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;
+}
+
+export function resolveMeshHostStatus(mesh: unknown): 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,
+    };
+    const hostDaemonId = readString(raw?.hostDaemonId);
+    const hostNodeId = readString(raw?.hostNodeId);
+    const hostAddress = readString(raw?.hostAddress);
+    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-init.ts

@@ -0,0 +1,260 @@
+/**
+ * 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. recommend a node providerPriority from the installed CLI providers
+ *
+ * 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 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];
+
+/**
+ * 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;
+}
+
+/**
+ * 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;
+}
+
+export interface RunMeshInitResult {
+    success: true;
+    workspace: string;
+    dryRun: boolean;
+    refine: MeshInitConfigFileResult;
+    worktreeBootstrap: MeshInitConfigFileResult;
+    providers: {
+        providerPriority: string[];
+        installedProviders: Array<{ id: string; displayName: string; version?: string }>;
+    };
+    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,
+    });
+
+    const providers = suggestNodeProviderPriority(detected);
+
+    return {
+        success: true,
+        workspace,
+        dryRun: !write,
+        refine,
+        worktreeBootstrap,
+        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 — 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.',
+    };
+}
+
+/**
+ * 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;
+    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: {