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

package/dist/mesh/mesh-active-work.d.ts

@@ -83,6 +83,24 @@ export declare function buildMeshActiveWork(opts: BuildMeshActiveWorkOptions): {
     terminalDirectWork: MeshActiveWorkRecord[];
     summary: MeshActiveWorkSummary;
 };
+/**
+ * staleReason strings (produced by sessionStatusFromNodes above) that indicate the original
+ * node/session is GONE from the live mesh — i.e. the staleDirect record is an orphaned ledger
+ * artifact, not active or recoverable work. These are the only reasons safe to prune from the
+ * active staleDirect surface. The "no provider acknowledgement" reason is deliberately excluded:
+ * those entries have a still-live node/session (staleDispatchUnacknowledged) and represent
+ * recoverable dispatch failures, never orphans.
+ */
+export declare const PRUNABLE_ORPHAN_STALE_REASONS: ReadonlySet<string>;
+export type StaleDirectPruneClassification = 'prunable_orphan' | 'prunable_terminal' | 'preserve_unacknowledged' | 'preserve_active';
+/**
+ * Classify a direct-work record for the staleDirect prune path. Pure function — the prune tool
+ * uses this so the safety rules (never touch active work or recoverable unacknowledged dispatches)
+ * live next to the staleReason producers and are independently testable.
+ */
+export declare function classifyStaleDirectForPrune(record: Pick<MeshActiveWorkRecord, 'staleReason' | 'staleDispatchUnacknowledged' | 'terminal'>, opts?: {
+    includeTerminal?: boolean;
+}): StaleDirectPruneClassification;
 export declare function buildCompactStaleDirectWorkSummary(staleDirectWork: MeshActiveWorkRecord[], opts?: {
     sampleLimit?: number;
     detailHint?: string;

package/dist/mesh/mesh-fast-forward.d.ts

@@ -10,19 +10,50 @@ export interface MeshFastForwardNodeArgs {
     submoduleIgnorePaths?: string[];
     timeoutMs?: number;
     trigger?: 'manual' | 'idle_auto' | string;
+    /**
+     * Operation mode. 'merge' (default) absorbs upstream commits into the local
+     * branch via git merge --ff-only (requires ahead=0, behind>0). 'push' publishes
+     * local commits to origin via a strict ff-only push (requires HEAD to be a
+     * descendant of origin/<branch>); it never force-pushes, resets, or rebases.
+     */
+    mode?: 'merge' | 'push';
+    /**
+     * When mode='push', also fast-forward push submodule (e.g. oss) HEADs to their
+     * origin main branch. Gated by allowAutoPublishSubmoduleMainCommits — skipped
+     * unless that policy is true. Each submodule must still pass the descendant gate.
+     * Defaults false (root push only).
+     */
+    pushSubmodules?: boolean;
+    /**
+     * Mesh policy flag mirrored from RepoMeshPolicy.allowAutoPublishSubmoduleMainCommits.
+     * Submodule pushes are refused unless this is true.
+     */
+    allowAutoPublishSubmoduleMainCommits?: boolean;
 }
 export interface MeshFastForwardPlannedStep {
-    operation: 'refresh_upstream' | 'verify_clean_worktree' | 'verify_fast_forward' | 'merge_ff_only' | 'submodule_update' | 'verify_post_status';
+    operation: 'refresh_upstream' | 'verify_clean_worktree' | 'verify_fast_forward' | 'merge_ff_only' | 'submodule_update' | 'verify_post_status' | 'verify_push_descendant' | 'push_ff_only' | 'push_submodules_ff_only';
     description: string;
     safe: true;
     willMutateWorktree: boolean;
 }
+export interface MeshFastForwardSubmodulePushResult {
+    path: string;
+    commit?: string;
+    remote: string;
+    remoteBranch: string;
+    pushed: boolean;
+    skipped: boolean;
+    code: string;
+    refspec?: string;
+    error?: string;
+}
 export interface MeshFastForwardResult {
     success: boolean;
     code: string;
     nodeId?: string;
     meshId?: string;
     workspace: string;
+    mode: 'merge' | 'push';
     allowed: boolean;
     dryRun: boolean;
     willRun: boolean;
@@ -33,9 +64,18 @@ export interface MeshFastForwardResult {
     current?: GitRepoStatus;
     preStatus?: GitRepoStatus;
     postStatus?: GitRepoStatus;
+    /** Push target derived from the tracked upstream (mode='push'). */
+    pushTarget?: {
+        remote: string;
+        remoteBranch: string;
+        refspec: string;
+    };
+    /** Submodule ff-only push outcomes (mode='push' with pushSubmodules). */
+    submodulePushes?: MeshFastForwardSubmodulePushResult[];
     finalBranchConvergenceState?: Record<string, unknown>;
     operationError?: string;
     ledgerError?: string;
+    nextStep?: string;
     trigger?: string;
 }
 export declare function fastForwardMeshNode(args: MeshFastForwardNodeArgs): Promise<MeshFastForwardResult>;

package/dist/mesh/mesh-ledger.d.ts

@@ -14,7 +14,7 @@
  */
 import { EventEmitter } from 'events';
 import { MeshRuntimeStore } from './mesh-runtime-store.js';
-export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable';
+export type MeshLedgerKind = 'task_dispatched' | 'task_completed' | 'task_failed' | 'task_stalled' | 'task_approval_needed' | 'p2p_dispatch_failed' | 'session_launched' | 'session_auto_launch' | 'session_stopped' | 'checkpoint_created' | 'node_cloned' | 'node_joined' | 'node_removed' | 'coordinator_started' | 'recovery_attempted' | 'ledger_replicated' | 'ledger_reconciled' | 'direct_fast_forward' | 'delivery_unroutable' | 'direct_dispatch_pruned';
 export interface MeshLedgerEntry {
     id: string;
     meshId: string;

package/dist/mesh/mesh-runtime-store.d.ts

@@ -72,6 +72,12 @@ export declare class MeshRuntimeStore {
     updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
     cleanupTerminalDirectDispatches(olderThanMs: number): void;
     deleteDirectDispatches(meshId: string): void;
+    /**
+     * Delete specific direct dispatch rows by taskId for a mesh. Used by the staleDirect prune
+     * path to remove orphaned/terminal dispatch records whose node/session is no longer in the
+     * live mesh. Returns the number of rows actually deleted. No-op for an empty taskId list.
+     */
+    deleteDirectDispatchesByTaskId(meshId: string, taskIds: string[]): number;
     markStaleDirectDispatches(meshId: string, olderThanMs: number): void;
     setRemoteIdleSession(nodeId: string, sessionId: string, providerType: string, expiresAt: number, metadata?: any): void;
     getRemoteIdleSessions(): Array<{

package/dist/mesh/mesh-work-queue.d.ts

@@ -243,6 +243,12 @@ export declare function getActiveDirectDispatches(meshId: string): DirectDispatc
 export declare function updateDirectDispatchStatus(meshId: string, sessionId: string, status: 'acked' | 'completed' | 'failed' | 'stale'): void;
 export declare function cleanupTerminalDirectDispatches(olderThanMs?: number): void;
 export declare function markStaleDirectDispatches(meshId: string, olderThanMs?: number): void;
+/**
+ * Delete specific direct dispatch rows by taskId. Returns the number of rows deleted.
+ * Used by the staleDirect prune path to evict orphaned/terminal dispatch records from the
+ * active staleDirect surface while leaving the append-only mesh ledger (audit history) intact.
+ */
+export declare function deleteDirectDispatchesByTaskId(meshId: string, taskIds: string[]): number;
 export type MeshToolCallRateResult = {
     rateLimitExceeded: boolean;
     callsInWindow: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.261",
+  "version": "0.9.82-rc.263",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/build-info.ts

@@ -0,0 +1,73 @@
+/**
+ * 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.
+ */
+
+// These are replaced at build time by tsup `define`. `typeof` guards keep this
+// safe when the define is absent (the identifiers are simply not declared).
+declare const __DAEMON_BUILD_COMMIT__: string | undefined;
+declare const __DAEMON_BUILD_COMMIT_SHORT__: string | undefined;
+declare const __DAEMON_BUILD_VERSION__: string | undefined;
+declare const __DAEMON_BUILD_AT__: string | undefined;
+
+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;
+}
+
+function readInjected(value: string | undefined): string | undefined {
+    if (typeof value !== 'string') return undefined;
+    const trimmed = value.trim();
+    if (!trimmed || trimmed === 'unknown') return undefined;
+    return trimmed;
+}
+
+let cached: DaemonBuildInfo | undefined;
+
+/**
+ * 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 function getDaemonBuildInfo(): DaemonBuildInfo {
+    if (cached) return cached;
+
+    const commit =
+        readInjected(typeof __DAEMON_BUILD_COMMIT__ !== 'undefined' ? __DAEMON_BUILD_COMMIT__ : undefined)
+        ?? 'unknown';
+    const commitShort =
+        readInjected(typeof __DAEMON_BUILD_COMMIT_SHORT__ !== 'undefined' ? __DAEMON_BUILD_COMMIT_SHORT__ : undefined)
+        ?? (commit !== 'unknown' ? commit.slice(0, 7) : 'unknown');
+    const version =
+        readInjected(typeof __DAEMON_BUILD_VERSION__ !== 'undefined' ? __DAEMON_BUILD_VERSION__ : undefined)
+        // Fall back to the runtime-injected package version env used elsewhere.
+        ?? readInjected(typeof process !== 'undefined' ? process.env?.ADHDEV_PKG_VERSION : undefined)
+        ?? 'unknown';
+    const builtAt = readInjected(typeof __DAEMON_BUILD_AT__ !== 'undefined' ? __DAEMON_BUILD_AT__ : undefined);
+
+    cached = builtAt ? { commit, commitShort, version, builtAt } : { commit, commitShort, version };
+    return cached;
+}