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

package/dist/commands/med-family/mesh-crud.d.ts

@@ -1,2 +1,29 @@
+import type { GitRepoIdentity } from '../../git/git-types.js';
 import type { MedFamilyHandler } from './types.js';
+/**
+ * Decision for syncing a freshly-cloned worktree's `oss` submodule to its clone
+ * source node, applying resolveWorktreeBaseStartPoint's origin-tip-priority
+ * policy to the submodule.
+ *
+ * On clone, `submodule update --init` checks the worktree's `oss` out at the
+ * gitlink recorded in the FRESH root base — which the root base-stale fix
+ * branches from origin/main, so it is the up-to-date origin tip. The clone
+ * source node's *working* `oss` SHA can lag that tip. The original sync blindly
+ * checked out the source SHA whenever it merely differed, which REWINDS the
+ * submodule back onto the stale source and re-introduces staleness.
+ *
+ * Guard policy (never rewind, mirror the base-start-point resolver):
+ *   - source SHA == worktree SHA            → `noop`
+ *   - source SHA is an ancestor of worktree → `skip_rewind`  (source is behind; keep fresh tip)
+ *   - worktree SHA is an ancestor of source → `advance`      (source strictly newer; safe fast-forward)
+ *   - neither is an ancestor (diverged)     → `skip_diverged` (keep fresh tip; coordinator reconciles)
+ *
+ * Both SHAs must already be resolvable in `ossCtx` (the caller fetches the
+ * source SHA first). A non-1 git exit (unresolvable SHA / real failure) is
+ * rethrown so the caller can fall back to keeping the fresh worktree HEAD.
+ */
+export type OssCloneSyncAction = 'noop' | 'advance' | 'skip_rewind' | 'skip_diverged';
+export declare function decideOssCloneSync(ossCtx: GitRepoIdentity, worktreeOssSha: string, sourceSha: string, rg: (ctx: GitRepoIdentity, argv: string[], opts?: {
+    timeoutMs?: number;
+}) => Promise<unknown>): Promise<OssCloneSyncAction>;
 export declare const meshCrudHandlers: Record<string, MedFamilyHandler>;

package/dist/config/mesh-json-config.d.ts

@@ -1,63 +1,36 @@
 /**
  * Repo-shared declarative mesh config — `.adhdev/mesh.json`
  *
- * A repo-committed, machine-independent BASE for mesh declarative settings
- * (policy + coordinator prompt override/append + operating notes). It is the
- * lowest layer of a LOCAL-WINS merge chain:
+ * A repo-committed, machine-independent file carrying ONLY the repo-shared
+ * coordinator-prompt config and operating notes:
  *
- *   DEFAULT_MESH_POLICY  →  .adhdev/mesh.json (repo base)  →  machine-local
- *   meshes.json / coordinator-prompt files (always win)
- *
- * The merge is **in-memory only**. The on-disk machine-local `meshes.json` is
- * NEVER mutated by this module — local config keeps winning and the merge is
- * applied transiently on the coordinator launch + display paths. This keeps the
- * repo file a shared default that a machine can always override without the
- * override being silently rewritten back to the repo shape.
- *
- * Three zones (scope = mesh-global in v1; per-node scope is not introduced):
- *   - policy            — RepoMeshPolicy fields; local fields that differ from
- *                         DEFAULT_MESH_POLICY win, otherwise the repo base shows
- *                         through (true per-field LOCAL-WINS).
  *   - coordinator       — systemPromptOverride (local wins, else repo) and
  *                         systemPromptAppend (repo append + local append BOTH
  *                         stack, repo first).
  *   - operatingNotes    — repo-declared baseline notes merged with the runtime
  *                         ledger notes; on duplicate text the ledger note wins.
+ *   - limits            — advisory-only (`maxNoteChars`, `maxNotes`,
+ *                         `coordinator.maxPromptChars`); recorded, never enforced in v1.
  *
- * Advisory-only fields (`coordinator.maxPromptChars`, `limits.maxNoteChars`,
- * `limits.maxNotes`) are accepted and preserved in the schema but NOT enforced
- * in v1 — they document operator intent only.
- *
- * SCHEDULING OVERLAY — this same `.adhdev/mesh.json` also carries the in-tree
- * scheduling product surface (`policy.scheduling`). Instead of the scattered
- * `schedulingStrategy` / `maxParallelTasks` knobs (each with its own default +
- * clamp), an operator declares one `policy.scheduling` block checked into the
- * repo. It layers ON TOP of the stored meshes.json policy with LOCAL-WINS — a
- * value present in the repo file overrides the persisted mesh policy, so the
- * repo is the source of truth for how its own work distributes. Absent keys
- * leave the stored policy untouched (a partial overlay, not a replacement).
- *
- *   .adhdev/mesh.json
- *   { "policy": { "scheduling": {
- *       "distribution": "spread" | "in_order",   // → schedulingStrategy
- *       "maxParallel": 1..8,                       // → maxParallelTasks (clamped)
- *       "readonlyMultiplier": 2                    // read-only cap multiplier (default 2)
- *   } } }
+ * POLICY IS NOT HERE. RepoMeshPolicy (the 15 scheduling/approval fields) is
+ * MACHINE-LOCAL only — it lives in meshes.json and is never sourced from, merged
+ * with, or overlaid by a repo file. There is no `policy` zone and no
+ * `policy.scheduling` overlay in mesh.json; the scheduler reads the stored
+ * machine-local policy directly. The repo file shapes the coordinator prompt and
+ * operating notes, nothing else.
  *
- * The raw 4-union schedulingStrategy escape hatch is preserved elsewhere: a
- * hand-edited meshes.json may still write any of the four raw strategies and the
- * scheduler honors it. The scheduling overlay exposes only the 2-mode
- * `distribution` façade, mapped through distributionToStrategy.
+ * The coordinator/operatingNotes merge is **in-memory only**: the on-disk
+ * machine-local `meshes.json` is never mutated by this module.
  *
- * The declarative-config loader (`loadRepoMeshJsonConfig`) and the scheduling
- * overlay loader (`loadMeshJsonConfig`) read the SAME file but resolve different
- * zones; they coexist intentionally — coordinator launch/display consume the
- * declarative zones, the scheduler consumes the scheduling overlay.
+ * FILE SEPARATION: refine / worktree-bootstrap / change-impact configs live in
+ * their OWN `.adhdev/*` files with their own loaders — they are NOT inlined into
+ * mesh.json. `loadRepoSettings` (config/repo-settings.ts) assembles all of them
+ * into one object for consumers.
  *
  * SECURITY: declarative only. JSON/YAML is parsed; arbitrary JS (.js) is NOT
  * supported, so loading a config can never execute code.
  */
-import { type RepoMeshPolicy, type RepoMeshCoordinatorConfig, type LocalMeshEntry, type RepoMeshDistribution, distributionToStrategy } from '../repo-mesh-types.js';
+import type { RepoMeshCoordinatorConfig, LocalMeshEntry } from '../repo-mesh-types.js';
 import type { CoordinatorOperatingNote } from '../mesh/coordinator-prompt.js';
 export interface RepoMeshDeclarativeCoordinatorConfig {
     /** Full mesh-level system prompt override. Same semantics as
@@ -77,11 +50,11 @@ export interface RepoMeshDeclarativeLimits {
 }
 /**
  * Parsed + normalized `.adhdev/mesh.json` shape. Every field is optional except
- * version so a repo can declare only the zone(s) it cares about.
+ * version so a repo can declare only the zone(s) it cares about. Policy is NOT a
+ * zone here — it is machine-local (meshes.json) only.
  */
 export interface RepoMeshDeclarativeConfig {
     version: 1;
-    policy?: Partial<RepoMeshPolicy>;
     coordinator?: RepoMeshDeclarativeCoordinatorConfig;
     operatingNotes?: CoordinatorOperatingNote[];
     limits?: RepoMeshDeclarativeLimits;
@@ -95,26 +68,6 @@ export interface RepoMeshJsonConfigLoadResult {
     path?: string;
     error?: string;
 }
-export interface MeshJsonSchedulingConfig {
-    /** User-facing distribution mode; mapped to schedulingStrategy on apply. */
-    distribution?: RepoMeshDistribution;
-    /** Global write-task parallel cap (clamped to [1, 8] on apply). */
-    maxParallel?: number;
-    /** Read-only diagnosis cap multiplier. Missing → 2. */
-    readonlyMultiplier?: number;
-}
-export interface MeshJsonConfig {
-    scheduling?: MeshJsonSchedulingConfig;
-}
-export interface MeshJsonConfigLoadResult {
-    config?: MeshJsonConfig;
-    source: string;
-    sourceType: 'repo_file' | 'unavailable' | 'invalid';
-    path?: string;
-    error?: string;
-    /** Cache key: path + mtime, or a sentinel for the missing/invalid case. */
-    sourceKey: string;
-}
 export declare const MESH_JSON_CONFIG_LOCATIONS: string[];
 export declare const MESH_JSON_CONFIG_SCHEMA: {
     readonly $schema: "https://json-schema.org/draft/2020-12/schema";
@@ -126,9 +79,6 @@ export declare const MESH_JSON_CONFIG_SCHEMA: {
         readonly version: {
             readonly const: 1;
         };
-        readonly policy: {
-            readonly type: "object";
-        };
         readonly coordinator: {
             readonly type: "object";
             readonly additionalProperties: false;
@@ -211,24 +161,6 @@ export declare function normalizeRepoMeshDeclarativeConfig(parsed: unknown): {
  * coordinator launch.
  */
 export declare function loadRepoMeshJsonConfig(workspace?: string): RepoMeshJsonConfigLoadResult;
-/**
- * Reduce a (fully-normalized) machine-local policy to ONLY the fields that
- * genuinely differ from DEFAULT_MESH_POLICY. A meshes.json policy is always
- * stored fully-defaulted, so a naive merge would let it shadow every repo-base
- * field — defeating the repo default. By keeping only the truly-overridden
- * fields, an untouched local field falls through to the repo base while a local
- * field the operator actually changed still wins. Optional fields absent from
- * DEFAULT_MESH_POLICY (e.g. allowedProviders, schedulingStrategy) count as an
- * override whenever present.
- */
-export declare function diffPolicyFromDefault(local: Partial<RepoMeshPolicy> | undefined): Partial<RepoMeshPolicy>;
-/**
- * Effective mesh policy = DEFAULT → repo base → local overrides (per-field
- * LOCAL-WINS). When `local` is all-default the repo base shows through entirely
- * (case i); when `local` overrides a field that field wins (case ii). Nested
- * objects (autoFastForward) are still merged per-field by mergeAndNormalizePolicy.
- */
-export declare function mergeEffectiveMeshPolicy(repoPolicy: Partial<RepoMeshPolicy> | undefined, localPolicy: RepoMeshPolicy | Partial<RepoMeshPolicy> | undefined): RepoMeshPolicy;
 /**
  * Effective coordinator config. systemPromptOverride: local wins, else repo.
  * systemPromptAppend: repo append + local append BOTH stack (repo first). Other
@@ -246,54 +178,22 @@ export declare function mergeEffectiveCoordinatorConfig(repoCoord: RepoMeshDecla
 export declare function mergeEffectiveOperatingNotes(repoNotes: CoordinatorOperatingNote[] | undefined, ledgerNotes: CoordinatorOperatingNote[] | undefined): CoordinatorOperatingNote[] | undefined;
 /**
  * Produce an in-memory effective mesh by layering the repo declarative config
- * UNDER the machine-local mesh entry (policy + coordinator zones). Returns a new
- * object; the input mesh and on-disk meshes.json are never mutated. operatingNotes
- * are merged separately at launch (they ride the prompt context, not the mesh).
+ * UNDER the machine-local mesh entry — coordinator zone ONLY. Policy is
+ * machine-local and is left exactly as the stored mesh carries it (never sourced
+ * from the repo file). Returns a new object; the input mesh and on-disk
+ * meshes.json are never mutated. operatingNotes are merged separately at launch
+ * (they ride the prompt context, not the mesh).
  */
-export declare function applyRepoMeshConfig<T extends Pick<LocalMeshEntry, 'policy' | 'coordinator'>>(mesh: T, repoConfig: RepoMeshDeclarativeConfig | null | undefined): T;
+export declare function applyRepoMeshConfig<T extends Pick<LocalMeshEntry, 'coordinator'>>(mesh: T, repoConfig: RepoMeshDeclarativeConfig | null | undefined): T;
 /**
  * Build a `.adhdev/mesh.json` DRAFT from a machine-local mesh entry. This is a
  * scaffold for the operator to review and commit — NOT an automatic migration.
- * It captures the local policy (fully normalized) plus any coordinator prompt
- * override/append so a repo can adopt the current machine's settings as the
- * shared base. Operating notes are intentionally NOT exported: those are runtime
- * ledger lessons, and a repo should declare baseline notes deliberately.
+ * It captures the coordinator prompt override/append so a repo can adopt the
+ * current machine's prompt customization as the shared base. Policy is NOT
+ * exported — it is machine-local only and has no place in mesh.json. Operating
+ * notes are intentionally NOT exported either: those are runtime ledger lessons,
+ * and a repo should declare baseline notes deliberately.
  */
-export declare function buildMeshJsonConfigScaffold(mesh: Pick<LocalMeshEntry, 'policy' | 'coordinator'>): RepoMeshDeclarativeConfig;
+export declare function buildMeshJsonConfigScaffold(mesh: Pick<LocalMeshEntry, 'coordinator'>): RepoMeshDeclarativeConfig;
 /** Serialize a scaffold to the canonical 2-space JSON draft text. */
 export declare function serializeMeshJsonConfigScaffold(config: RepoMeshDeclarativeConfig): string;
-/**
- * Validate a parsed `.adhdev/mesh.*` document into a MeshJsonConfig (scheduling
- * overlay). Tolerant of an empty/partial file (an empty object is valid and
- * yields no overlay); strict about malformed values so a typo surfaces as
- * `invalid` rather than silently no-op'ing.
- */
-export declare function validateMeshJsonConfig(raw: unknown, source?: string): {
-    valid: boolean;
-    errors: string[];
-    config?: MeshJsonConfig;
-};
-/**
- * Locate and load the `.adhdev/mesh.json` scheduling overlay for a repo root.
- * Declarative only — never executes config. Cached by path + mtime so repeated
- * scheduler reads are cheap.
- */
-export declare function loadMeshJsonConfig(repoRoot: string): MeshJsonConfigLoadResult;
-/** Test-only: drop the mtime cache so a per-run temp file is re-read. */
-export declare function __resetMeshJsonConfigCacheForTests(): void;
-/**
- * The effective scheduling knobs after layering the repo-local `.adhdev/mesh.json`
- * overlay on top of a stored mesh policy (LOCAL-WINS). This is the single resolution
- * point the scheduler reads, so the strategy/caps it acts on always reflect the
- * in-tree override when present and fall back to the persisted policy otherwise.
- */
-export interface EffectiveMeshScheduling {
-    /** Resolved raw strategy (override distribution → strategy, else stored policy). */
-    strategy: ReturnType<typeof distributionToStrategy> | RepoMeshPolicy['schedulingStrategy'];
-    /** Effective, clamped global write cap. */
-    maxParallelTasks: number;
-    /** Read-only cap multiplier (override, else default 2). */
-    readonlyMultiplier?: number;
-    /** True when an `.adhdev/mesh.json` overlay actually contributed a value. */
-    overrideApplied: boolean;
-}

package/dist/config/repo-settings.d.ts

@@ -0,0 +1,77 @@
+/**
+ * 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 { type RepoMeshDeclarativeCoordinatorConfig, type RepoMeshDeclarativeLimits, type RepoMeshJsonConfigLoadResult } from './mesh-json-config.js';
+import { type MeshRefineConfigLoadResult } from '../mesh/refine-config.js';
+import { type WorktreeBootstrapConfigLoadResult } from '../mesh/worktree-bootstrap-config.js';
+import { 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 declare function loadRepoSettings(opts: LoadRepoSettingsOptions): RepoSettings;

package/dist/index.d.ts

@@ -45,6 +45,8 @@ export type { CoordinatorRegistryEntry } from './mesh/coordinator-registry.js';
 export { MESH_REFINE_CONFIG_LOCATIONS, MESH_REFINE_CONFIG_SCHEMA, loadMeshRefineConfig, resolveMeshRefineValidationPlan, suggestMeshRefineConfig, validateMeshRefineConfig, } from './mesh/refine-config.js';
 export { MESH_WORKTREE_BOOTSTRAP_CONFIG_LOCATIONS, MESH_WORKTREE_BOOTSTRAP_CONFIG_SCHEMA, loadMeshWorktreeBootstrapConfig, runMeshWorktreeBootstrap, validateMeshWorktreeBootstrapConfig, type RepoMeshWorktreeBootstrapConfig, type WorktreeBootstrapState, } from './mesh/worktree-bootstrap-config.js';
 export type { MeshRefineValidationCategory, MeshRefineValidationCommandPlan, MeshRefineValidationPlan, RepoMeshRefineConfig, RepoMeshRefineValidationCommandConfig, } from './mesh/refine-config.js';
+export { loadRepoSettings } from './config/repo-settings.js';
+export type { RepoSettings, LoadRepoSettingsOptions } from './config/repo-settings.js';
 export { appendLedgerEntry, appendRemoteLedgerEntries, buildTaskCompletionEvidence, normalizeMeshWorkerResult, readLedgerEntries, readLedgerSlice, readLedgerSliceFromStore, getLedgerSummary, getLedgerDir, getSessionRecoveryContext, MAX_LEDGER_SLICE_LIMIT } from './mesh/mesh-ledger.js';
 export type { AppendRemoteLedgerResult, MeshLedgerEntry, MeshLedgerKind, MeshLedgerSlice, MeshLedgerSummary, ReadLedgerOptions, ReadLedgerSliceOptions, SessionRecoveryContext, MeshTaskCompletionEvidence, MeshWorkerResultArtifact, MeshProcessArtifact, MeshValidationResultArtifact } from './mesh/mesh-ledger.js';
 export { fastForwardMeshNode } from './mesh/mesh-fast-forward.js';