@adhdev/daemon-core 0.9.82-rc.411 → 0.9.82-rc.412

package/src/config/repo-settings.ts

@@ -0,0 +1,111 @@
+/**
+ * Repo Settings — one unified loader over the repo-committed `.adhdev/*` config
+ * files (the "single source" assembly point).
+ *
+ * DESIGN (option B — file separation preserved): the repo keeps its declarative
+ * config in SEPARATE files, each with its own dedicated loader:
+ *
+ *   .adhdev/mesh.json               → loadRepoMeshJsonConfig  (coordinator + operatingNotes)
+ *   .adhdev/refine.json             → loadMeshRefineConfig     (Refinery validation)
+ *   .adhdev/worktree_bootstrap.json → loadMeshWorktreeBootstrapConfig
+ *   .adhdev/change-impact.json      → loadChangeImpactConfig
+ *
+ * Nothing is inlined into mesh.json. `loadRepoSettings` simply CALLS each
+ * dedicated loader and assembles the results into one `RepoSettings` object so a
+ * consumer can read every repo-shared setting through a single call instead of
+ * threading four loaders. The per-file loaders remain the source of truth (and
+ * stay independently usable); this is a convenience aggregator, not a new schema.
+ *
+ * IMPORTANT — policy is NOT here. RepoMeshPolicy (the 15 scheduling/approval
+ * fields) is MACHINE-LOCAL only: it lives in meshes.json and is never sourced
+ * from or merged with a repo file. mesh.json carries only coordinator prompt
+ * config + operating notes (+ advisory limits).
+ *
+ * The refine/worktree-bootstrap loaders also honor a machine-local INLINE seam
+ * (mesh.refineConfig / mesh.policy.worktreeBootstrap, etc.) — that seam is for
+ * machine-local config and is unchanged here; mesh.json gains no such zone.
+ */
+
+import {
+    loadRepoMeshJsonConfig,
+    type RepoMeshDeclarativeCoordinatorConfig,
+    type RepoMeshDeclarativeLimits,
+    type RepoMeshJsonConfigLoadResult,
+} from './mesh-json-config.js';
+import {
+    loadMeshRefineConfig,
+    type MeshRefineConfigLoadResult,
+} from '../mesh/refine-config.js';
+import {
+    loadMeshWorktreeBootstrapConfig,
+    type WorktreeBootstrapConfigLoadResult,
+} from '../mesh/worktree-bootstrap-config.js';
+import {
+    loadChangeImpactConfig,
+    type ChangeImpactConfigLoadResult,
+} from '../git/change-impact-config.js';
+import type { CoordinatorOperatingNote } from '../mesh/coordinator-prompt.js';
+
+export interface LoadRepoSettingsOptions {
+    /** Workspace path whose `.adhdev/*` files are resolved (mesh.json / refine / bootstrap). */
+    workspace: string;
+    /**
+     * Machine-local mesh entry, consulted ONLY for the INLINE seam of the
+     * refine / worktree-bootstrap loaders (mesh.refineConfig etc.). Optional —
+     * omit it and only the repo files are considered. NEVER used to source policy.
+     */
+    mesh?: any;
+    /**
+     * Repo root for change-impact resolution. Defaults to `workspace` when omitted
+     * (change-impact compares the daemon build commit against the workspace HEAD).
+     */
+    repoRoot?: string;
+}
+
+/**
+ * The assembled repo-shared settings. Each sub-config carries its own load
+ * result (source / sourceType / error) so a consumer can tell "absent" from
+ * "invalid" per file. `coordinator` / `operatingNotes` / `limits` are lifted out
+ * of the mesh.json load result for convenience; `meshJson` keeps the full result
+ * (e.g. for the `sourceType === 'invalid'` warning on coordinator launch).
+ */
+export interface RepoSettings {
+    /** Repo-shared coordinator prompt config (override/append) from `.adhdev/mesh.json`. */
+    coordinator?: RepoMeshDeclarativeCoordinatorConfig;
+    /** Repo-declared baseline operating notes from `.adhdev/mesh.json`. */
+    operatingNotes?: CoordinatorOperatingNote[];
+    /** Advisory-only limits from `.adhdev/mesh.json` (recorded, not enforced in v1). */
+    limits?: RepoMeshDeclarativeLimits;
+    /** Full `.adhdev/mesh.json` declarative load result (coordinator/operatingNotes source). */
+    meshJson: RepoMeshJsonConfigLoadResult;
+    /** `.adhdev/refine.json` Refinery validation config load result. */
+    refine: MeshRefineConfigLoadResult;
+    /** `.adhdev/worktree_bootstrap.json` bootstrap config load result. */
+    worktreeBootstrap: WorktreeBootstrapConfigLoadResult;
+    /** `.adhdev/change-impact.json` change-impact config load result. */
+    changeImpact: ChangeImpactConfigLoadResult;
+}
+
+/**
+ * Load every repo-committed `.adhdev/*` setting for a workspace and assemble them
+ * into one object. Each dedicated loader degrades to an `unavailable`/`invalid`
+ * load result rather than throwing, so this never throws on a missing or broken
+ * file — a consumer inspects the per-sub-config `sourceType`.
+ */
+export function loadRepoSettings(opts: LoadRepoSettingsOptions): RepoSettings {
+    const workspace = typeof opts.workspace === 'string' ? opts.workspace : '';
+    const mesh = opts.mesh;
+    const repoRoot = typeof opts.repoRoot === 'string' && opts.repoRoot ? opts.repoRoot : workspace;
+
+    const meshJson = loadRepoMeshJsonConfig(workspace);
+
+    return {
+        coordinator: meshJson.config?.coordinator,
+        operatingNotes: meshJson.config?.operatingNotes,
+        limits: meshJson.config?.limits,
+        meshJson,
+        refine: loadMeshRefineConfig(mesh, workspace),
+        worktreeBootstrap: loadMeshWorktreeBootstrapConfig(mesh, workspace),
+        changeImpact: loadChangeImpactConfig(repoRoot),
+    };
+}

package/src/index.ts

@@ -237,6 +237,11 @@ export type {
   RepoMeshRefineConfig,
   RepoMeshRefineValidationCommandConfig,
 } from './mesh/refine-config.js';
+// Unified repo-settings loader: assembles the separate `.adhdev/*` config files
+// (mesh.json coordinator/operatingNotes, refine, worktree-bootstrap, change-impact)
+// into one object. Policy is machine-local and not part of repo settings.
+export { loadRepoSettings } from './config/repo-settings.js';
+export type { RepoSettings, LoadRepoSettingsOptions } from './config/repo-settings.js';
 
 // ── Mesh Task Ledger ──
 export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';

package/src/mesh/mesh-ledger.ts

@@ -49,6 +49,16 @@ export type MeshLedgerKind =
     // the ledger so it survives coordinator restarts and is provider-neutral.
     // payload: { text, category?, createdAt?, sourceCoordinator? }
     | 'coordinator_operating_note'
+    // Mission audit trail: mission record mutations (mesh_mission_upsert) so the
+    // ledger captures mission lifecycle, not just task events. Without these a
+    // mission create / goal rewrite / status transition left no ledger trace,
+    // breaking audit continuity and post-restart recovery.
+    // mission_created       payload: { missionId, title, goalSummary, goalLength, goalTruncated, status }
+    // mission_status_changed payload: { missionId, title, fromStatus, toStatus }
+    // mission_goal_updated  payload: { missionId, title, prevGoalSummary, nextGoalSummary, prevGoalLength, nextGoalLength, goalTruncated }
+    | 'mission_created'
+    | 'mission_status_changed'
+    | 'mission_goal_updated'
     ;
 
 export interface MeshLedgerEntry {

package/src/mesh/mesh-missions.ts

@@ -16,6 +16,19 @@ import { randomUUID } from 'crypto';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { getQueue } from './mesh-work-queue.js';
 import { computeMeshMissionStats, type MeshMissionStats } from './mesh-task-stats.js';
+import { appendLedgerEntry } from './mesh-ledger.js';
+
+/**
+ * Max chars of mission goal text written into a ledger entry payload. Mission
+ * goals can be hundreds–thousands of chars; the ledger is an append-only audit
+ * stream, so we store a bounded summary (+ a length/truncated flag) rather than
+ * the full text to keep the ledger from bloating on repeated goal rewrites.
+ */
+const LEDGER_GOAL_SUMMARY_MAX = 200;
+
+function summarizeGoalForLedger(goal: string): string {
+    return goal.length > LEDGER_GOAL_SUMMARY_MAX ? goal.slice(0, LEDGER_GOAL_SUMMARY_MAX) : goal;
+}
 
 export type MeshMissionStatus = 'active' | 'paused' | 'completed' | 'abandoned';
 
@@ -102,6 +115,8 @@ export function upsertMeshMission(meshId: string, input: {
     const id = typeof input.id === 'string' && input.id.trim() ? input.id.trim() : randomUUID();
     const store = MeshRuntimeStore.getInstance();
     const existing = store.getMission(meshId, id);
+    const prevStatus = existing ? normalizeMissionStatus(existing.status) : null;
+    const prevGoal = existing?.goal ?? '';
     const record = {
         id,
         meshId,
@@ -111,7 +126,77 @@ export function upsertMeshMission(meshId: string, input: {
     };
     store.upsertMission(record);
     const saved = store.getMission(meshId, id)!;
-    return { ...saved, status: normalizeMissionStatus(saved.status) };
+    const result: MeshMissionRecord = { ...saved, status: normalizeMissionStatus(saved.status) };
+
+    // Mission audit trail: record this mutation in the mesh ledger so mission
+    // lifecycle (create, goal rewrite, status transition) is auditable alongside
+    // task events and survives a coordinator restart. Best-effort: a ledger
+    // failure must never break the primary mission write.
+    appendMissionLedgerEntries(meshId, {
+        isCreate: !existing,
+        record: result,
+        prevStatus,
+        prevGoal,
+    });
+
+    return result;
+}
+
+/**
+ * Append the relevant ledger entries for a mission upsert. Emits at most one
+ * entry per distinct change:
+ *  - new mission                       → mission_created
+ *  - status differs from prior         → mission_status_changed
+ *  - goal text differs from prior      → mission_goal_updated (no-op rewrites skipped)
+ */
+function appendMissionLedgerEntries(
+    meshId: string,
+    args: { isCreate: boolean; record: MeshMissionRecord; prevStatus: MeshMissionStatus | null; prevGoal: string },
+): void {
+    const { isCreate, record, prevStatus, prevGoal } = args;
+    try {
+        if (isCreate) {
+            const goal = record.goal ?? '';
+            appendLedgerEntry(meshId, {
+                kind: 'mission_created',
+                payload: {
+                    missionId: record.id,
+                    title: record.title,
+                    goalSummary: summarizeGoalForLedger(goal),
+                    goalLength: goal.length,
+                    goalTruncated: goal.length > LEDGER_GOAL_SUMMARY_MAX,
+                    status: record.status,
+                },
+            });
+            return;
+        }
+        if (prevStatus !== null && prevStatus !== record.status) {
+            appendLedgerEntry(meshId, {
+                kind: 'mission_status_changed',
+                payload: {
+                    missionId: record.id,
+                    title: record.title,
+                    fromStatus: prevStatus,
+                    toStatus: record.status,
+                },
+            });
+        }
+        const nextGoal = record.goal ?? '';
+        if (nextGoal !== prevGoal) {
+            appendLedgerEntry(meshId, {
+                kind: 'mission_goal_updated',
+                payload: {
+                    missionId: record.id,
+                    title: record.title,
+                    prevGoalSummary: summarizeGoalForLedger(prevGoal),
+                    nextGoalSummary: summarizeGoalForLedger(nextGoal),
+                    prevGoalLength: prevGoal.length,
+                    nextGoalLength: nextGoal.length,
+                    goalTruncated: prevGoal.length > LEDGER_GOAL_SUMMARY_MAX || nextGoal.length > LEDGER_GOAL_SUMMARY_MAX,
+                },
+            });
+        }
+    } catch { /* audit trail is best-effort; never break the mission write */ }
 }
 
 export function getMeshMissions(meshId: string, statuses?: MeshMissionStatus[]): MeshMissionRecord[] {

package/src/mesh/mesh-queue-assignment.ts

@@ -13,9 +13,8 @@ import { createSessionDelivery, updateSessionDeliveryStatus } from './mesh-deliv
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
 import { traceMeshEventDrop } from './mesh-event-trace.js';
 import { awaitWithWarmupDeadline, resolveWarmupDeadlineOpts } from './mesh-warmup-deadline.js';
-import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks, distributionToStrategy } from '../repo-mesh-types.js';
+import { resolveDelegatedWorkerAutoApprove, resolveProviderMaxParallel, resolveNodeSchedulingPriority, normalizeMeshSchedulingStrategy, resolveMaxParallelTasks, resolveMaxReadonlyParallelTasks } from '../repo-mesh-types.js';
 import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-import { loadMeshJsonConfig, type MeshJsonSchedulingConfig } from '../config/mesh-json-config.js';
 import { normalizeMeshNodeId, meshNodeIdMatches, daemonIdsEquivalent, normalizeMeshWorkspaceForCompare, meshWorkspacesEquivalent, type MeshNodeIdentified } from '@adhdev/mesh-shared';
 import { findTerminalLedgerEvidenceForTask, hasUnterminalDirectDispatchLedgerEntry } from './mesh-events-stale.js';
 import { readNonEmptyString } from './mesh-events-utils.js';
@@ -825,46 +824,15 @@ function nodeActiveLoad(meshId: string, nodeId: string): number {
 }
 
 /**
- * Resolve the canonical repo root for reading a mesh's in-tree `.adhdev/mesh.json`
- * overlay. Prefers a base (non-worktree) node's repoRoot/workspace — the canonical
- * checkout that carries the repo file — and falls back to any node so a worktree-only
- * mesh still resolves a root. Returns '' when no node declares a path.
- */
-function resolveMeshRepoRootForScheduling(mesh: any): string {
-    const nodes = Array.isArray(mesh?.nodes) ? mesh.nodes : [];
-    const pickRoot = (n: any) => readNonEmptyString(n?.repoRoot) || readNonEmptyString(n?.workspace);
-    const base = nodes.find((n: any) => n?.isLocalWorktree !== true && pickRoot(n));
-    if (base) return pickRoot(base);
-    const anyNode = nodes.find((n: any) => pickRoot(n));
-    return anyNode ? pickRoot(anyNode) : '';
-}
-
-/**
- * The repo-local `.adhdev/mesh.json` `policy.scheduling` overlay for this mesh, when
- * present and valid. LOCAL-WINS: a value here overrides the stored mesh policy. Cached
- * by mtime in the loader, so calling this on every reconcile tick is cheap.
- */
-function resolveMeshSchedulingOverride(mesh: any): MeshJsonSchedulingConfig | undefined {
-    const repoRoot = resolveMeshRepoRootForScheduling(mesh);
-    if (!repoRoot) return undefined;
-    try {
-        return loadMeshJsonConfig(repoRoot).config?.scheduling;
-    } catch {
-        return undefined;
-    }
-}
-
-/**
- * The mesh-wide scheduling strategy. Resolution order (LOCAL-WINS):
- *   1. `.adhdev/mesh.json` policy.scheduling.distribution (2-mode → strategy), then
- *   2. the stored mesh policy schedulingStrategy raw 4-union (escape hatch), then
- *   3. 'first_eligible' (strict no-change default).
- * Only governs the final tie-break; eligibility, capacity, and priority gates apply
- * identically to every strategy.
+ * The mesh-wide scheduling strategy, read from the MACHINE-LOCAL stored mesh
+ * policy. Resolution order:
+ *   1. the stored mesh policy schedulingStrategy raw 4-union, then
+ *   2. 'first_eligible' (strict no-change default).
+ * Policy is machine-local only — there is no repo-file (`.adhdev/mesh.json`)
+ * overlay. Only governs the final tie-break; eligibility, capacity, and priority
+ * gates apply identically to every strategy.
  */
 function resolveSchedulingStrategy(mesh: any): RepoMeshSchedulingStrategy {
-    const override = resolveMeshSchedulingOverride(mesh);
-    if (override?.distribution) return distributionToStrategy(override.distribution);
     return normalizeMeshSchedulingStrategy(mesh?.policy?.schedulingStrategy);
 }
 
@@ -1131,19 +1099,15 @@ async function maybeAutoLaunchOneQueueSession(components: DaemonComponents, mesh
     const pending = queue.filter(task => task.status === 'pending');
     if (!pending.length) return false;
 
-    // Write cap + read-only cap resolved through the shared helpers, with the
-    // repo-local `.adhdev/mesh.json` overlay winning over the stored policy
-    // (LOCAL-WINS). Both the cap value and the read-only multiplier route through
-    // the same resolvers the observability projection uses, so the enforced and
-    // exposed caps can never drift.
-    const schedulingOverride = resolveMeshSchedulingOverride(mesh);
-    const maxParallelTasks = resolveMaxParallelTasks(
-        schedulingOverride?.maxParallel ?? mesh?.policy?.maxParallelTasks,
-    );
+    // Write cap + read-only cap resolved through the shared helpers from the
+    // MACHINE-LOCAL stored mesh policy (no repo-file overlay). These are the same
+    // resolvers the observability projection uses, so the enforced and exposed
+    // caps can never drift.
+    const maxParallelTasks = resolveMaxParallelTasks(mesh?.policy?.maxParallelTasks);
     // Read-only diagnoses carry no isolation/merge cost, so they are exempt from the
     // write-task parallel cap. To prevent runaway auto-launch they get their own,
-    // higher safety cap (readonlyMultiplier × the write cap, default 2×).
-    const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks, schedulingOverride?.readonlyMultiplier);
+    // higher safety cap (default 2× the write cap).
+    const maxReadonlyParallelTasks = resolveMaxReadonlyParallelTasks(maxParallelTasks);
     for (const task of pending) {
         const isReadonly = isTaskReadonly(task);
         if (isReadonly) {