@adhdev/daemon-core 0.9.82-rc.523 → 0.9.82-rc.525

package/dist/commands/router-refine.d.ts

@@ -13,6 +13,23 @@ export declare function buildRefineJobHandle(self: DaemonCommandRouter, args: {
     retryOfJobId?: string;
     coordinatorDaemonId?: string;
 }): MeshRefineJobHandle;
+/**
+ * QW2: extract a compact failure diagnostic from a validation summary — the first
+ * failing command's name, its exit code, its failureKind, and a bounded output tail.
+ * Surfaced in BOTH the slim coordinator event and the ledger blockerContext so a
+ * coordinator can decide next-step without pulling and parsing the full ledger record.
+ *
+ * A command record carries `passed` (boolean), never `success` (see QW1) — the first
+ * record with passed===false is the gate's failing command. Returns undefined when the
+ * summary did not fail on a command (e.g. bootstrap-stage failure with no commandsRun
+ * entry), in which case the top-level failureCode/failureKind still describe the cause.
+ */
+export declare function extractValidationFailureDiagnostics(validationSummary: Record<string, unknown> | undefined): {
+    firstFailedCommand?: string;
+    exitCode?: unknown;
+    failureKind?: unknown;
+    outputTail?: string;
+} | undefined;
 /**
  * Slim the terminal-stage refine result down to the fields a coordinator needs to
  * decide next-step, dropping the heavy per-command / per-entry detail.
@@ -52,6 +69,26 @@ export declare function executeMeshRefineNodeSynchronously(self: DaemonCommandRo
  * branch head. Seeds the RefineContext consumed by every later stage.
  */
 export declare function refineResolveRefsStage(self: DaemonCommandRouter, meshId: string, nodeId: string, args: any, refineStages: Array<Record<string, unknown>>): Promise<RefineStageOutcome>;
+/**
+ * DS2 sync_base stage: bring the worktree branch up to the pinned baseHead BEFORE
+ * validation, so every later gate (validation, patch_equivalence, merge) sees the
+ * final rebased tree rather than a stale pre-rebase one.
+ *
+ * The old auto-rebase lived inside patch_equivalence and only fired when branchHead
+ * was a STRICT ANCESTOR of baseHead (`merge-base --is-ancestor`). A diverged laggard
+ * — the branch has its own commits AND base moved underneath it (ahead>0 AND behind>0)
+ * — failed that ancestor check, so it was never rebased and fell straight to
+ * patch_equivalence_failed / blocked_review even though a clean rebase would have
+ * converged it. Here we compute ahead/behind explicitly and rebase whenever behind>0
+ * (strictly-behind OR diverged), aborting to blocked_review only on a real conflict.
+ *
+ * On a successful rebase we recompute branchHead and re-derive changeImpact against
+ * the rebased tree (its baseHead..branchHead diff changed), and record the
+ * `patch_equivalence_after_auto_rebase` stage so the batch/ancestry assertions can see
+ * the rebase happened. When the branch is already up to date (behind===0), this is a
+ * no-op passed stage.
+ */
+export declare function refineSyncBaseStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
 /**
  * validation stage: run the refinery validation gate (typecheck / test /
  * lint / build per node config) and block on failure or when no allowlisted
@@ -59,11 +96,11 @@ export declare function refineResolveRefsStage(self: DaemonCommandRouter, meshId
  */
 export declare function refineValidationStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
 /**
- * patch_equivalence stage: preflight that the worktree branch's cumulative
- * patch is equivalent to base+branch. On a "behind base" branch, auto-rebase
- * once and re-check; on an empty merge-tree with real branch changes, treat as
- * already-merged-via-another-path and short-circuit to cleanup. Mutates the
- * context's branchHead (after rebase) and patchEquivalence (rebased gate).
+ * patch_equivalence stage: preflight that the worktree branch's cumulative patch is
+ * equivalent to base+branch. The DS2 sync_base stage already rebased any behind/diverged
+ * branch onto the pinned baseHead, so this is now a pure check: equivalent → continue;
+ * empty merge-tree with real branch changes → already-merged-via-another-path
+ * short-circuit to cleanup; otherwise → patch_equivalence_failed / blocked_review.
  */
 export declare function refinePatchEquivalenceStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
 /**
@@ -80,6 +117,33 @@ export declare function refineSubmoduleReachabilityStage(self: DaemonCommandRout
  * never committed, so the merge would land nothing real on main.
  */
 export declare function refineEffectiveDiffStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * DS3: after a successful Refinery push advanced origin/<baseBranch>, bring the
+ * ORIGINATING COORDINATOR daemon's own local base checkout up to the pushed commit so
+ * the coordinator isn't silently left behind (the "merged to main but my local main is
+ * stale" gap). Guarded and NON-destructive:
+ *
+ *   - If the coordinator's base node is hosted by THIS daemon and is reachable locally,
+ *     run fastForwardMeshNode(mode:'merge') on it directly. That helper is itself the
+ *     guard: it only ff-only-merges when the workspace is clean, ahead=0 and behind>0;
+ *     an ahead/diverged/dirty coordinator returns a structured block (never a rebase).
+ *   - If the coordinator is a DIFFERENT daemon (remote), we cannot touch its checkout
+ *     from here, so we queue a `coordinator_catchup` pending event targeted at that
+ *     coordinator daemon; its reconcile loop / next mesh-tool call drains it and runs the
+ *     same guarded fast-forward locally (busy → naturally deferred to the next idle edge).
+ *
+ * Best-effort and advisory: the caller never fails the refine on a catch-up problem. The
+ * refine's own repoRoot IS the base it just merged+pushed, so when the coordinator IS this
+ * daemon and IS repoRoot the ff is a no-op `already_up_to_date` — correct and harmless.
+ * Returns a compact summary for the stage record, or undefined when there's nothing to do.
+ */
+export declare function requestCoordinatorLocalCatchup(self: DaemonCommandRouter, params: {
+    meshId: string;
+    ctx: RefineContext;
+    mesh: any;
+    baseBranch: string;
+    repoRoot: string;
+}): Promise<Record<string, unknown> | undefined>;
 /**
  * merge + finalize stage: perform the --no-ff merge, align submodule
  * checkouts after merge, clean up (remove) the worktree node per policy,
@@ -87,6 +151,16 @@ export declare function refineEffectiveDiffStage(self: DaemonCommandRouter, ctx:
  * base branch. Always terminal — produces the final CommandRouterResult.
  */
 export declare function refineMergeAndFinalizeStage(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
+/**
+ * DS2 CAS + DS1 order: the base-lease-protected core of merge/finalize. Before the
+ * merge it re-fetches origin/<baseBranch> and compare-and-swaps the live origin SHA
+ * against the pinned baseHead from resolve_refs; if the base moved, it terminates
+ * retryable (base_moved) WITHOUT merging so a re-run rebases onto and validates the
+ * new base. DS1: on the auto-push path the order is merge → push → cleanup, so a push
+ * failure leaves the worktree/branch intact (cleanup withheld) and is reported as a
+ * terminal blocked state — the batch never counts an un-pushed node as merged.
+ */
+export declare function runRefineMergeAndFinalizeLocked(self: DaemonCommandRouter, ctx: RefineContext): Promise<RefineStageOutcome>;
 /**
  * Batch refinery: converge multiple sibling worktree nodes onto the base branch
  * in one sequential pipeline, absorbing the rebase + patch-equivalence churn that
@@ -101,6 +175,13 @@ export declare function refineMergeAndFinalizeStage(self: DaemonCommandRouter, c
  * isolated as blocked_review while the rest of the batch proceeds.
  */
 export declare function batchRefineMeshNodes(self: DaemonCommandRouter, meshId: string, requestedNodeIds: string[] | undefined, args: any): Promise<CommandRouterResult>;
+export type BatchNodeConvergence = 'merged_to_main' | 'blocked_review' | 'skipped_patch_equivalent' | 'not_mergeable';
+export declare function classifyBatchNodeConvergence(result: Record<string, unknown>): {
+    convergence: BatchNodeConvergence;
+    code: string;
+    stage?: string;
+    retryable: boolean;
+};
 /**
  * Convergence core shared by the synchronous batch entry and the async batch job.
  * Refines each node in order: the per-node refine pipeline fetches origin/<base>

package/dist/commands/router.d.ts

@@ -137,6 +137,15 @@ export declare class DaemonCommandRouter {
     runningRefineBatchJobs: Map<string, MeshRefineBatchJobHandle>;
     /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
     terminalRefineBatchJobs: Map<string, MeshRefineBatchTerminalJob>;
+    /**
+     * DS2: in-process refinement leases keyed by `${repoRoot}::${baseBranch}`. Serialize
+     * the base-mutating window (candidate-SHA pin → merge → push) of concurrent single-node
+     * refines that target the SAME base branch in the same repo, so two refines cannot both
+     * validate against one baseHead and then race their merges (the base-movement race). The
+     * batch path is already sequential, so this only matters for overlapping single-node
+     * async jobs. Value = the meshId:nodeId job key holding the lease (for diagnostics).
+     */
+    refineBaseLeases: Map<string, string>;
     constructor(deps: CommandRouterDeps);
     private hydrateCachedAggregateMeshStatusFromInline;
     private getCachedAggregateMeshStatus;

package/dist/git/git-status.d.ts

@@ -1,6 +1,6 @@
 import type { GitRepoStatus } from './git-types.js';
 import { type DaemonBuildInfo } from '../build-info.js';
-import { type ChangeImpactConfig } from './change-impact-config.js';
+import { type ChangeImpactConfig, type ChangeImpactKind } from './change-impact-config.js';
 /**
  * TTL for the happy-path result cache (C1). reconcile fires every 4s and mesh_status
  * is polled; a single getGitRepoStatus on a 1-submodule repo spawns ~13-15 git
@@ -71,6 +71,19 @@ export declare function getGitRepoStatus(workspace: string, options?: GitStatusO
 export interface ChangedPackageClassification {
     isDaemonAffecting: boolean;
     affectedPackages: string[];
+    /**
+     * DOCS-ROOT: three-way change area, refining the binary isDaemonAffecting so a
+     * docs-only branch is distinguishable from a code (web) branch:
+     *   'daemon' — a daemon-runtime package (or an unknown/ambiguous path) changed;
+     *              full validation + daemon rebuild/restart required.
+     *   'web'    — only web-only packages changed; web validation but no daemon restart.
+     *   'none'   — no package changed at all; every changed file is a benign non-runtime
+     *              root file (docs/markers). No code validation is meaningful — only an
+     *              explicit docs-scoped profile (e.g. docs:verify) should run.
+     * Derived from the same facts as isDaemonAffecting, so it never contradicts it
+     * (changeArea === 'daemon' ⇔ isDaemonAffecting === true).
+     */
+    changeArea: ChangeImpactKind;
 }
 /**
  * Ref-parameterized change-impact classification for a repo/worktree, reusing the