@adhdev/daemon-core 0.9.82-rc.376 → 0.9.82-rc.377

package/dist/mesh/mesh-event-classify.d.ts

@@ -0,0 +1,5 @@
+import type { MeshLedgerKind } from './mesh-ledger.js';
+export declare const EVENT_TO_LEDGER_KIND: Record<string, MeshLedgerKind>;
+export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
+export declare const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string>;
+export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;

package/dist/mesh/mesh-event-forwarding.d.ts

@@ -0,0 +1,18 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+export declare function resolveForwardEventMeshId(components: DaemonComponents, payload: Record<string, unknown>): string;
+export declare function __resetMeshWorkspaceCacheForTests(): void;
+export declare function buildRelayMetadataEvent(payload: Record<string, unknown>): Record<string, unknown>;
+export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
+    [extra: string]: unknown;
+    success: true;
+    forwarded: 0;
+    suppressed: true;
+} | {
+    success: boolean;
+    forwarded: number;
+    error?: undefined;
+} | {
+    success: boolean;
+    error: string;
+};
+export declare function setupMeshEventForwarding(components: DaemonComponents): void;

package/dist/mesh/mesh-events-coordinator.d.ts

@@ -1,92 +1,4 @@
-import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
-import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
-export declare function resolveForwardEventMeshId(components: DaemonComponents, payload: Record<string, unknown>): string;
-export declare function __resetIdleAutoFastForwardForTests(): void;
-export declare function __resetMeshWorkspaceCacheForTests(): void;
-export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
-/** Active assignments that hold the one-active-per-node / global-parallel invariant
- *  (everything except read-only diagnoses, which run unbounded by the write cap). */
-export declare function activeWriteAssignedCount(meshId: string): number;
-/** Active read-only (live_debug_readonly) assignments, for the read-only safety cap. */
-export declare function activeReadonlyAssignedCount(meshId: string): number;
-/**
- * Order eligible nodes for assignment per the mesh scheduling pipeline:
- *   PRIORITY (schedulingPriority desc) → TIE-BREAK (strategy).
- *
- * The caller has already applied the TAG hard-filter and is responsible for the
- * MAX-ALLOC capacity gate (the per-node launch/claim checks). This function only
- * decides the *preference order* among nodes that are otherwise eligible.
- *
- * - 'first_eligible' (default): returns the input order verbatim and does NOT touch
- *   the round-robin cursor — byte-for-byte the pre-feature behavior.
- * - 'priority_only': schedulingPriority desc, then input order (load ignored).
- * - 'least_loaded': schedulingPriority desc, then active load asc, then input order.
- * - 'round_robin': same as least_loaded, but among nodes tied at (priority, load)
- *   the input order is rotated by a per-mesh cursor that advances once per pass.
- *
- * `nodes` carries the original config/array index so the tie-break can fall back to
- * deterministic input order. `bumpCursor` advances the round-robin cursor exactly
- * once per scheduling pass (only consulted for 'round_robin').
- */
-interface RankableNode {
-    nodeId: string;
-    node: any;
-    index: number;
-}
-/** Test-only: the pure node-ordering stage (PRIORITY → TIE-BREAK). Exposed so the
- *  scheduling pipeline can be unit-tested without standing up live CLI sessions. */
-export declare function __orderEligibleNodesForTests(meshId: string, strategy: RepoMeshSchedulingStrategy, nodes: RankableNode[], opts?: {
-    bumpCursor?: boolean;
-}): RankableNode[];
-export interface MeshQueueTriggerResult {
-    success: true;
-    meshId: string;
-    pendingBefore: number;
-    assignedBefore: number;
-    pendingAfter: number;
-    assignedAfter: number;
-    claimed: boolean;
-    newlyAssignedTasks: Array<{
-        id: string;
-        nodeId?: string;
-        sessionId?: string;
-    }>;
-    localIdleSessionsChecked: number;
-    remoteIdleSessionsChecked: number;
-    skippedSessions: Array<{
-        nodeId?: string;
-        sessionId?: string;
-        reason: string;
-        status?: string;
-    }>;
-    autoLaunchStarted: boolean;
-    /**
-     * True when a worker session is already on its way to claim a still-pending task —
-     * either launched this tick (autoLaunchStarted) or launched on a prior tick and still
-     * booting/awaiting-claim. Callers MUST treat this as "wait, do not launch another
-     * session": a second launch double-edits the worktree. Mutually informative with
-     * `noIdleMeshSessionAvailable`, which is suppressed whenever this is true.
-     */
-    autoLaunchPending?: boolean;
-    noIdleMeshSessionAvailable?: boolean;
-}
-export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult>;
-export declare function isMeshCoordinatorEvent(eventName: unknown): eventName is string;
-export declare const MESH_FORCE_INJECT_EVENTS: ReadonlySet<string>;
-export declare function shouldForceInjectMeshEvent(eventName: unknown): boolean;
-export declare function buildRelayMetadataEvent(payload: Record<string, unknown>): Record<string, unknown>;
-export declare function handleMeshForwardEvent(components: DaemonComponents, payload: Record<string, unknown>): {
-    [extra: string]: unknown;
-    success: true;
-    forwarded: 0;
-    suppressed: true;
-} | {
-    success: boolean;
-    forwarded: number;
-    error?: undefined;
-} | {
-    success: boolean;
-    error: string;
-};
-export declare function setupMeshEventForwarding(components: DaemonComponents): void;
-export {};
+export { isMeshCoordinatorEvent, MESH_FORCE_INJECT_EVENTS, shouldForceInjectMeshEvent, } from './mesh-event-classify.js';
+export { __orderEligibleNodesForTests, __resetIdleAutoFastForwardForTests, activeReadonlyAssignedCount, activeWriteAssignedCount, triggerMeshQueue, tryAssignQueueTask, } from './mesh-queue-assignment.js';
+export type { MeshQueueTriggerResult } from './mesh-queue-assignment.js';
+export { __resetMeshWorkspaceCacheForTests, buildRelayMetadataEvent, handleMeshForwardEvent, resolveForwardEventMeshId, setupMeshEventForwarding, } from './mesh-event-forwarding.js';

package/dist/mesh/mesh-events-utils.d.ts

@@ -52,6 +52,9 @@ export declare function resolveMeshSurfacedSessionPreview(metadataEvent: Record<
     role: 'assistant';
     receivedAt: number;
 } | undefined;
+export declare function isMissingFinalAssistantDiagnostic(record: Record<string, unknown> | undefined): boolean;
+export declare function isFalseIdleCompletion(record: Record<string, unknown>): boolean;
+export declare function isWeakCompletionEvidence(record: Record<string, unknown> | undefined): boolean;
 export declare function isWeakCompletionMetadata(metadataEvent: Record<string, unknown>): boolean;
 export declare function buildMeshSystemMessage(args: {
     event: string;

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

@@ -44,7 +44,6 @@ export interface MeshLedgerReconciliationEvidence {
     sourceOfTruth: {
         kind: 'coordinator_local_sqlite';
         p2pOnly: true;
-        cloudD1LedgerSync: false;
         notes: string;
     };
     replicas: MeshLedgerReplicaEvidence[];

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

@@ -0,0 +1,86 @@
+import type { DaemonComponents } from '../boot/daemon-lifecycle.js';
+import type { RepoMeshSchedulingStrategy } from '../repo-mesh-types.js';
+export declare function __resetIdleAutoFastForwardForTests(): void;
+export declare function getMeshWithCache(components: DaemonComponents, meshId: string): any | undefined;
+export declare function tryAssignQueueTask(components: DaemonComponents, meshId: string, nodeId: string, sessionId: string, providerType: string): boolean;
+/** Active assignments that hold the one-active-per-node / global-parallel invariant
+ *  (everything except read-only diagnoses, which run unbounded by the write cap). */
+export declare function activeWriteAssignedCount(meshId: string): number;
+/** Active read-only (live_debug_readonly) assignments, for the read-only safety cap. */
+export declare function activeReadonlyAssignedCount(meshId: string): number;
+/**
+ * Order eligible nodes for assignment per the mesh scheduling pipeline:
+ *   PRIORITY (schedulingPriority desc) → TIE-BREAK (strategy).
+ *
+ * The caller has already applied the TAG hard-filter and is responsible for the
+ * MAX-ALLOC capacity gate (the per-node launch/claim checks). This function only
+ * decides the *preference order* among nodes that are otherwise eligible.
+ *
+ * - 'first_eligible' (default): returns the input order verbatim and does NOT touch
+ *   the round-robin cursor — byte-for-byte the pre-feature behavior.
+ * - 'priority_only': schedulingPriority desc, then input order (load ignored).
+ * - 'least_loaded': schedulingPriority desc, then active load asc, then input order.
+ * - 'round_robin': same as least_loaded, but among nodes tied at (priority, load)
+ *   the input order is rotated by a per-mesh cursor that advances once per pass.
+ *
+ * `nodes` carries the original config/array index so the tie-break can fall back to
+ * deterministic input order. `bumpCursor` advances the round-robin cursor exactly
+ * once per scheduling pass (only consulted for 'round_robin').
+ */
+interface RankableNode {
+    nodeId: string;
+    node: any;
+    index: number;
+}
+/** Test-only: the pure node-ordering stage (PRIORITY → TIE-BREAK). Exposed so the
+ *  scheduling pipeline can be unit-tested without standing up live CLI sessions. */
+export declare function __orderEligibleNodesForTests(meshId: string, strategy: RepoMeshSchedulingStrategy, nodes: RankableNode[], opts?: {
+    bumpCursor?: boolean;
+}): RankableNode[];
+export declare function sessionHasActiveAssignment(meshId: string, sessionId: string): boolean;
+export interface MeshQueueTriggerResult {
+    success: true;
+    meshId: string;
+    pendingBefore: number;
+    assignedBefore: number;
+    pendingAfter: number;
+    assignedAfter: number;
+    claimed: boolean;
+    newlyAssignedTasks: Array<{
+        id: string;
+        nodeId?: string;
+        sessionId?: string;
+    }>;
+    localIdleSessionsChecked: number;
+    remoteIdleSessionsChecked: number;
+    skippedSessions: Array<{
+        nodeId?: string;
+        sessionId?: string;
+        reason: string;
+        status?: string;
+    }>;
+    autoLaunchStarted: boolean;
+    /**
+     * True when a worker session is already on its way to claim a still-pending task —
+     * either launched this tick (autoLaunchStarted) or launched on a prior tick and still
+     * booting/awaiting-claim. Callers MUST treat this as "wait, do not launch another
+     * session": a second launch double-edits the worktree. Mutually informative with
+     * `noIdleMeshSessionAvailable`, which is suppressed whenever this is true.
+     */
+    autoLaunchPending?: boolean;
+    noIdleMeshSessionAvailable?: boolean;
+}
+export declare function triggerMeshQueue(components: DaemonComponents, meshId: string): Promise<MeshQueueTriggerResult>;
+export declare function maybeAutoFastForwardIdleNode(components: DaemonComponents, args: {
+    meshId: string;
+    nodeId: string;
+    sessionId?: string;
+    providerType?: string;
+}): Promise<void>;
+export declare function runIdleMaintenanceThenAssignQueue(components: DaemonComponents, args: {
+    meshId: string;
+    nodeId: string;
+    sessionId: string;
+    providerType: string;
+}): void;
+export {};

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

@@ -19,9 +19,6 @@ export declare class MeshRuntimeStore {
     hasCompletionFingerprint(fingerprint: string): boolean;
     recordCompletionFingerprint(fingerprint: string, ttlMs: number): void;
     sweepExpiredFingerprints(): void;
-    recordDirectDelivered(coordinatorDaemonId: string, fingerprint: string, ttlMs: number): void;
-    wasDirectDelivered(coordinatorDaemonId: string, fingerprint: string): boolean;
-    sweepExpiredDirectDelivered(): void;
     private maybeCheckpointWal;
     private ensureLegacyQueueMigrated;
     getQueueEntries(meshId: string, statuses?: MeshTaskStatus[]): MeshWorkQueueEntry[];

package/dist/providers/native-history/constants.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Spawn-bind grace window: an on-disk rollout whose session_meta.timestamp
+ * lands within ±SPAWN_BIND_GRACE_MS of the daemon's spawnedAtMs is treated
+ * as belonging to that daemon session. 10s is long enough to absorb codex
+ * binary startup latency on cold caches and short enough that two
+ * back-to-back launches don't both fall inside the same window.
+ *
+ * Shared by the declarative executor (providers/spec/native-history-executor.ts)
+ * and the codex runtime disambiguator (providers/native-history/dispatcher.ts) —
+ * both apply the identical ±10s session-binding window.
+ */
+export declare const SPAWN_BIND_GRACE_MS = 10000;

package/dist/runtime-defaults.d.ts

@@ -9,3 +9,5 @@ export declare const MIN_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 500
 export declare const DEFAULT_SESSION_HOST_DIAGNOSTICS_SUBSCRIPTION_INTERVAL_MS = 10000;
 export declare const DEFAULT_SESSION_HOST_READY_TIMEOUT_MS = 15000;
 export declare const STANDALONE_CDP_SCAN_INTERVAL_MS = 15000;
+export declare function readMeshTimeoutEnvMs(names: string | string[], defaultMs: number): number;
+export declare const MESH_CONNECT_TIMEOUT_MS: number;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.376",
+  "version": "0.9.82-rc.377",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -46,7 +46,7 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.376",
+    "@adhdev/mesh-shared": "0.9.82-rc.377",
     "@adhdev/session-host-core": "*",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",