@adhdev/daemon-core 0.9.82-rc.261 → 0.9.82-rc.263

package/dist/build-info.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Daemon build stamp — single runtime source for "which commit is this running
+ * daemon built from?".
+ *
+ * The values are injected at BUILD time via tsup `define` (esbuild global
+ * replacement). Every build config that bundles daemon-core into a shippable
+ * daemon (daemon-core's own dist, daemon-standalone, daemon-cloud) replaces
+ * these `__DAEMON_BUILD_*` identifiers with the literal git commit/version that
+ * was current when the bundle was produced. See:
+ *   - oss/packages/daemon-core/tsup.config.ts      (standalone consumes this dist)
+ *   - packages/daemon-cloud/tsup.config.ts         (re-bundles daemon-core from source)
+ *
+ * If a bundle is produced WITHOUT the define (e.g. running src directly through
+ * tsx in dev, or a build env without git), the identifiers stay undefined and
+ * we fall back to `"unknown"` — never a ReferenceError, never a build failure.
+ *
+ * IMPORTANT (live-reflection caveat): a fresh local `daemon-core dist` rebuild +
+ * daemon restart is NOT enough to make a *cloud* daemon report a new commit —
+ * daemon-cloud ships its own re-bundle of daemon-core, so the build stamp only
+ * advances after the cloud daemon is rebuilt/redeployed and restarted. This is
+ * precisely the gap `mesh_status`'s `staleDaemonBuild` warning exists to surface.
+ */
+export interface DaemonBuildInfo {
+    /** Full 40-char git commit the daemon bundle was built from, or 'unknown'. */
+    commit: string;
+    /** Short (7-char) form of the same commit, or 'unknown'. */
+    commitShort: string;
+    /** package.json version baked in at build time, or 'unknown'. */
+    version: string;
+    /** ISO build timestamp if the build config injected one. */
+    builtAt?: string;
+}
+/**
+ * Resolve the build stamp baked into the running daemon bundle. Pure read of
+ * build-time constants — no I/O, safe to call from any runtime path. Cached.
+ */
+export declare function getDaemonBuildInfo(): DaemonBuildInfo;

package/dist/commands/router.d.ts

@@ -15,6 +15,87 @@ import type { ProviderLoader } from '../providers/provider-loader.js';
 import type { ProviderInstanceManager } from '../providers/provider-instance-manager.js';
 import { SessionRegistry } from '../sessions/registry.js';
 export declare function readCachedInlineMeshActiveSessionDetails(node: any): Array<Record<string, unknown>>;
+type MeshRefineStageStatus = 'passed' | 'failed' | 'skipped';
+type MeshRefineEffectiveDiffSummary = {
+    status: MeshRefineStageStatus;
+    /** True when there is at least one root-tree change between base and branch (incl. gitlink bumps). */
+    hasEffectiveDiff: boolean;
+    baseHead: string;
+    branchHead: string;
+    /** Root-level paths that differ between base and branch (capped). */
+    changedPaths?: string[];
+    /** Submodule paths with uncommitted/divergent commits but NO committed gitlink bump in the root tree. */
+    submoduleHints?: Array<{
+        path: string;
+        reason: string;
+    }>;
+    durationMs: number;
+    error?: string;
+    stdout?: string;
+    stderr?: string;
+};
+/**
+ * No-op guard: detect a "silent no-op" merge before the Refinery merge runs.
+ *
+ * A silent no-op occurs when the refine target branch's ROOT tree is byte-identical
+ * to the merge base (origin/main). This is the trap where a submodule (e.g. oss) has
+ * real commits but the root branch never committed the gitlink (oss-pointer) bump, so
+ * the root diff Refinery would merge is empty. Merging that produces a merge commit with
+ * no content change — reported as "success" while the actual work never reaches main.
+ *
+ * A committed gitlink bump (the legitimate oss-pointer bump) DOES show up in the root
+ * tree diff (as a 160000-mode entry), so this guard does NOT block legitimate refines —
+ * it only fires when the root tree diff vs base is COMPLETELY empty.
+ *
+ * Runs after the patch-equivalence gate; the "already merged via other path" case
+ * (branch has real changes already present in base) is handled upstream and never
+ * reaches here, so an empty root diff at this point is genuinely a no-op.
+ */
+export declare function runMeshRefineEffectiveDiffGate(repoRoot: string, baseHead: string, branchHead: string): Promise<MeshRefineEffectiveDiffSummary>;
+/**
+ * Result of evaluating whether a `git merge-tree --write-tree` submodule
+ * conflict is in fact a trivial gitlink fast-forward that should pass the
+ * patch-equivalence gate.
+ *
+ * `git merge-tree` (and `git merge` with the default recursive strategy)
+ * refuses to 3-way merge gitlinks unless the case is "trivial" — and it
+ * treats *any* gitlink that differs across merge-base/base/branch as
+ * non-trivial, even when the branch-side commit is a strict descendant of the
+ * base-side commit (i.e. a real fast-forward). Refinery only ever wants to
+ * accept the branch's recorded gitlink, so a fast-forwardable bump is safe to
+ * resolve to the branch side without any conflict.
+ */
+type GitlinkTrivialFastForwardEvaluation = {
+    /** True only when the merge-tree conflict is *fully* explained by trivial-ff gitlinks. */
+    trivial: boolean;
+    /** Why the evaluation declined to treat the conflict as trivial (set when trivial=false). */
+    reason?: string;
+    /** Per-path detail for the changed gitlinks that were inspected. */
+    gitlinks: Array<{
+        path: string;
+        baseCommit?: string;
+        branchCommit?: string;
+        fastForward: boolean;
+    }>;
+};
+/**
+ * Decide whether a merge-tree submodule conflict between base and branch is a
+ * trivial gitlink fast-forward (and nothing else).
+ *
+ * The conflict is treated as trivial ONLY when:
+ *   1. at least one changed gitlink exists,
+ *   2. every changed gitlink fast-forwards (base-commit is an ancestor of the
+ *      branch-commit inside that submodule's repo), and
+ *   3. the *only* paths that changed on both sides of the merge (i.e. the paths
+ *      that could possibly produce a 3-way conflict — the intersection of
+ *      mergeBase→base and mergeBase→branch changes) are gitlinks. Any
+ *      overlapping non-gitlink path means a genuine content conflict could be
+ *      hiding behind the submodule failure, so we keep the block.
+ *
+ * If any of these fail, the conflict is left as a genuine block. This never
+ * passes a regular-file conflict or a diverged (non-ff) gitlink.
+ */
+export declare function evaluateGitlinkTrivialFastForward(repoRoot: string, baseHead: string, branchHead: string): GitlinkTrivialFastForwardEvaluation;
 export interface SessionHostControlPlane {
     getDiagnostics(payload?: {
         includeSessions?: boolean;
@@ -96,6 +177,10 @@ export declare class DaemonCommandRouter {
     private runningRefineJobs;
     /** Terminal async Refinery jobs preserve a clear answer after the worktree node has been removed. */
     private terminalRefineJobs;
+    /** In-memory async batch Refinery jobs keyed by meshId (one batch convergence per mesh at a time). */
+    private runningRefineBatchJobs;
+    /** Terminal async batch Refinery jobs preserve the last batch outcome for late readers. */
+    private terminalRefineBatchJobs;
     constructor(deps: CommandRouterDeps);
     private cloneJsonValue;
     private hydrateCachedAggregateMeshStatusFromInline;
@@ -154,6 +239,36 @@ export declare class DaemonCommandRouter {
      * isolated as blocked_review while the rest of the batch proceeds.
      */
     private batchRefineMeshNodes;
+    /**
+     * 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>
+     * fresh, so each merged sibling advances the base before the next node's auto-rebase
+     * + patch-equivalence re-check. A blocked/failed node is isolated; the batch
+     * continues with the remaining nodes. Does NOT touch the per-node merge logic — it
+     * only sequences calls to executeMeshRefineNodeSynchronously and aggregates outcomes.
+     */
+    private runMeshRefineBatchConvergence;
+    private buildRefineBatchJobKey;
+    private buildRefineBatchJobHandle;
+    /**
+     * Emit a batch Refinery terminal/accepted event through the SAME pending-event +
+     * forward mechanism single-node refine uses (queueRefineJobEvent), so the
+     * coordinator's existing refine:accepted/completed/failed handling and message
+     * renderer apply unchanged. The aggregate per-node results ride along in `result`.
+     */
+    private queueRefineBatchJobEvent;
+    private appendRefineBatchJobLedger;
+    private finishMeshRefineBatchJob;
+    /**
+     * Async entry for the batch Refinery execute path. Mirrors startMeshRefineJob:
+     * resolves the plan synchronously (so target/ordering errors and the dry-run shape
+     * stay synchronous), then for execute=true registers an in-flight batch job, returns
+     * {async:true, status:'accepted', batch:true, ...plan} immediately, and runs the
+     * convergence loop in the background — emitting the same terminal refine event.
+     * Idempotent: a batch already in flight for this mesh returns the running handle
+     * with duplicate:true rather than spawning a second background job.
+     */
+    private startMeshRefineBatchJob;
     private finishMeshRefineJob;
     private startMeshRefineJob;
     /**
@@ -166,3 +281,4 @@ export declare class DaemonCommandRouter {
      */
     private stopIde;
 }
+export {};

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

@@ -1,4 +1,5 @@
 import type { GitRepoStatus } from './git-types.js';
+import { type DaemonBuildInfo } from '../build-info.js';
 export interface GitStatusOptions {
     timeoutMs?: number;
     /** When true, include submodule status in the result. Defaults to true. */
@@ -10,6 +11,12 @@ export interface GitStatusOptions {
      * Callers should opt into this only for convergence-critical surfaces.
      */
     refreshUpstream?: boolean;
+    /**
+     * Test/override seam for the daemon build stamp used by the stale-build
+     * detector. Production callers omit this so the real baked-in build commit
+     * (getDaemonBuildInfo) is used.
+     */
+    daemonBuildInfo?: DaemonBuildInfo;
 }
 export declare function getGitRepoStatus(workspace: string, options?: GitStatusOptions): Promise<GitRepoStatus>;
 interface ParsedPorcelainStatus {

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

@@ -54,9 +54,28 @@ export interface GitRepoStatus extends GitRepoIdentity {
     lastCheckedAt: number;
     /** Submodule statuses when auto-discover is enabled */
     submodules?: GitSubmoduleStatus[];
+    /**
+     * Set when the running daemon's build commit is a STRICT ancestor of this
+     * repo's HEAD (or a submodule HEAD) — i.e. the live daemon predates committed
+     * code in this workspace and is awaiting a deploy/restart to catch up.
+     * Omitted entirely when no staleness is provable (unknown build, commit not
+     * present in repo, or build commit == HEAD) to avoid over-warning.
+     */
+    daemonBuildBehind?: DaemonBuildBehind;
     error?: string;
     reason?: GitFailureReason;
 }
+export interface DaemonBuildBehind {
+    /** Full build commit baked into the running daemon. */
+    buildCommit: string;
+    /** Short build commit. */
+    buildCommitShort: string;
+    /** HEAD commit the build commit is behind (repo or submodule). */
+    head: string;
+    /** Where the comparison matched: 'root' or the submodule path. */
+    scope: string;
+    warning: string;
+}
 export type GitFileChangeStatus = 'added' | 'modified' | 'deleted' | 'renamed' | 'copied' | 'untracked' | 'conflict';
 export interface GitFileChange {
     path: string;

package/dist/index.d.ts

@@ -49,9 +49,10 @@ export { fastForwardMeshNode } from './mesh/mesh-fast-forward.js';
 export type { MeshFastForwardNodeArgs, MeshFastForwardPlannedStep, MeshFastForwardResult } from './mesh/mesh-fast-forward.js';
 export { buildMeshLedgerReconciliationEvidence, buildMeshLedgerReplicaEvidence } from './mesh/mesh-ledger-reconciliation.js';
 export type { AnyLedgerSlice, MeshLedgerReconciliationEvidence, MeshLedgerReplicaEvidence, MeshLedgerReplicaStatus } from './mesh/mesh-ledger-reconciliation.js';
-export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState } from './mesh/mesh-work-queue.js';
+export { enqueueTask, recordDirectDispatchTask, getQueue, claimNextTask, updateTaskStatus, updateSessionTaskStatus, cancelTask, requeueTask, getMeshQueueStats, getMeshQueueRevision, normalizeMeshTaskMode, validateMeshTaskModeRequest, buildMeshNodeCapabilityTags, nodeSatisfiesRequiredTags, normalizeMeshCapabilityTags, insertDirectDispatch, getActiveDirectDispatches, updateDirectDispatchStatus, cleanupTerminalDirectDispatches, markStaleDirectDispatches, deleteDirectDispatchesByTaskId, recordMeshToolCall, assertNoDependencyCycle, hasPendingDependents, describeTaskDependencyState } from './mesh/mesh-work-queue.js';
 export type { MeshWorkQueueEntry, MeshTaskStatus, MeshTaskMode, MeshWorkQueueStats, MeshQueueMutationOptions, MeshTaskModeValidationResult, DirectDispatchRecord, MeshToolCallRateResult } from './mesh/mesh-work-queue.js';
-export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary } from './mesh/mesh-active-work.js';
+export { buildCompactStaleDirectWorkSummary, buildMeshActiveWork, buildMeshActiveWorkSummary, classifyStaleDirectForPrune, PRUNABLE_ORPHAN_STALE_REASONS } from './mesh/mesh-active-work.js';
+export type { StaleDirectPruneClassification } from './mesh/mesh-active-work.js';
 export type { MeshActiveWorkRecord, MeshActiveWorkStatus, MeshActiveWorkSummary, MeshActiveWorkSource, MeshStaleDirectWorkSummary } from './mesh/mesh-active-work.js';
 export { buildMeshAsyncRefineJobs, summarizeMeshAsyncRefineJobs, STALE_TERMINAL_REFINE_WINDOW_MS, RECENT_TERMINAL_REFINE_CAP } from './mesh/mesh-refine-status.js';
 export type { MeshAsyncRefineJobStatus, MeshAsyncRefineJobSummary, MeshAsyncRefineJobsSummary } from './mesh/mesh-refine-status.js';
@@ -87,6 +88,8 @@ export type { DaemonUpgradeHelperPayload, CurrentGlobalInstallSurface, PinnedGlo
 export { DaemonStatusReporter } from './status/reporter.js';
 export { buildSessionEntries, findCdpManager, hasCdpManager, isCdpConnected } from './status/builders.js';
 export { buildStatusSnapshot, buildMachineInfo } from './status/snapshot.js';
+export { getDaemonBuildInfo } from './build-info.js';
+export type { DaemonBuildInfo } from './build-info.js';
 export { normalizeManagedStatus, isManagedStatusWorking, isManagedStatusWaiting, normalizeActiveChatData } from './status/normalize.js';
 export type { ManagedStatus } from './status/normalize.js';
 export type { StatusSnapshotOptions, StatusSnapshot } from './status/snapshot.js';