@adhdev/daemon-core 0.9.82-rc.473 → 0.9.82-rc.475

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

@@ -91,6 +91,18 @@ export declare const GOAL_PREVIEW_MAX = 120;
  * tighter than the dashboard / mesh_mission_list preview (GOAL_PREVIEW_MAX).
  */
 export declare const COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
+/**
+ * mesh_mission_list default fold sizes. Without an explicit `statuses` filter the
+ * tool returns non-terminal (active/paused) missions in full detail but folds the
+ * completed/abandoned history into counts + a capped newest-first id list — a mesh
+ * can accumulate hundreds of terminal missions and returning them all (each with a
+ * ledger-scanned stats rollup) blew past the tool payload / token budget and spilled
+ * to a file. When an explicit `statuses` filter IS given, the matching missions are
+ * returned in detail but still bounded by MESH_MISSION_LIST_STATUS_LIMIT so a
+ * status:["completed"] call on a huge history stays bounded (overflow → truncated).
+ */
+export declare const MESH_MISSION_LIST_HISTORY_ID_LIMIT = 30;
+export declare const MESH_MISSION_LIST_STATUS_LIMIT = 50;
 export declare function upsertMeshMission(meshId: string, input: {
     id?: string;
     title: string;
@@ -218,6 +230,49 @@ export declare function listMeshMissionSummaries(meshId: string, options?: {
     verbose?: boolean;
     includeMagi?: boolean;
 }): MeshMissionSummary[] | MeshMissionSlimSummary[];
+/** Shaped mesh_mission_list result: bounded detail list + optional folded history. */
+export interface MeshMissionListResult {
+    /** Detailed (slim or verbose) mission summaries — bounded, newest-first. */
+    missions: MeshMissionSummary[] | MeshMissionSlimSummary[];
+    /**
+     * Completed/abandoned missions folded to counts + ids. Present (default path)
+     * when no explicit status filter is given and terminal missions exist. Null when
+     * an explicit status filter is active (those missions go into `missions`).
+     */
+    historyFold: MeshStatusMissionsHistoryFold | null;
+    /** True when an explicit status filter matched more than `limit` missions. */
+    truncated: boolean;
+    /** Total missions matching the query BEFORE the detail-list cap was applied. */
+    matched: number;
+    /** Newest-first ids of missions dropped by the detail-list cap (truncated path). */
+    overflowIds?: string[];
+}
+/**
+ * mesh_mission_list projection: payload-bounded regardless of mesh mission count.
+ *
+ * Default (no explicit `statuses`): non-terminal missions (active/paused) return in
+ * detail; completed/abandoned missions are folded to counts + a capped id list
+ * (historyFold), NOT emitted one-by-one. This is what keeps the tool from returning
+ * hundreds of terminal missions (each with a ledger stats rollup) and overflowing the
+ * token budget.
+ *
+ * Explicit `statuses` (e.g. ["completed"]): the coordinator asked to see those
+ * missions, so they ARE returned in detail — but still bounded by `limit` (default
+ * MESH_MISSION_LIST_STATUS_LIMIT). Overflow beyond `limit` is reported via
+ * truncated:true + overflowIds rather than silently dropped.
+ *
+ * MAGI + verbose semantics match listMeshMissionSummaries. `withStats` opts each
+ * detailed mission into the ledger-scanned stats rollup (off by default — the tasks
+ * aggregate is enough for a list view).
+ */
+export declare function listMeshMissionsForTool(meshId: string, options?: {
+    statuses?: MeshMissionStatus[];
+    verbose?: boolean;
+    includeMagi?: boolean;
+    withStats?: boolean;
+    limit?: number;
+    historyIdLimit?: number;
+}): MeshMissionListResult;
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to

package/dist/providers/cli-provider-instance.d.ts

@@ -287,9 +287,21 @@ export declare class CliProviderInstance implements ProviderInstance {
     private pruneRecentUserInputAcks;
     /**
      * Owner token for this session in the antigravity conversation-claim
-     * registry. Derived identically to the dispatcher's read-side token
-     * (workspace + spawn time) so the claims the dispatcher records under this
-     * session are the ones dispose() releases.
+     * registry. Keyed on the daemon instance id — the SAME value the session
+     * registry stores as this session's `sessionId` (see cli-manager
+     * `sessionRegistry.register({ sessionId: cliInstance.instanceId })`) and the
+     * read side hands the dispatcher as `instanceId`. Both sides therefore
+     * derive the identical `iid:<instanceId>` token, so the claims the
+     * dispatcher records under this session are exactly the ones dispose()
+     * releases.
+     *
+     * This must NOT be derived from a spawn timestamp: the instance's
+     * `startedAt`, the adapter's `spawnedAtMs`, and the session registry's
+     * `spawnedAtMs` are three INDEPENDENT `Date.now()` samples for the one
+     * session, so a workspace+spawn-time token computed here would never equal
+     * the read side's — the claim isolation then silently collapses and two
+     * concurrent antigravity sessions cross-bind each other's conversation .db
+     * (coordinator+worker chat crosswire).
      */
     private antigravityClaimOwner;
     dispose(): void;

package/package.json

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

package/src/commands/chat-commands-read.ts

@@ -1095,6 +1095,13 @@ function readCliProviderNativeHistory(agentStr: string, args: {
     // the downstream hasSafeNativeHistoryMapping workspace-overlap gate. Only the
     // read_chat path opts in, and only with a concrete workspace.
     allowWorkspaceLatestFallback?: boolean;
+    // ADHDev session id of the reading session (== the session registry's
+    // sessionId == the provider instance's instanceId). Threaded to the
+    // native-history dispatcher so antigravity's conversation-claim owner token
+    // is keyed on this stable identity and matches the instance-side token —
+    // without it two concurrent antigravity sessions cross-bind each other's
+    // conversation .db.
+    instanceId?: string;
 }): ReturnType<typeof readProviderChatHistory> & { lookup: 'session' | 'workspace' } {
     const canBindFromLiveSession = !args.historySessionId
         && typeof args.sessionStartedAtMs === 'number'
@@ -1146,6 +1153,7 @@ function readCliProviderNativeHistory(agentStr: string, args: {
         excludeInProgressTurn: args.excludeInProgressTurn,
         sessionStartedAtMs: args.sessionStartedAtMs,
         envOverrides: args.envOverrides,
+        instanceId: args.instanceId,
     });
     const boundProviderSessionId = typeof (sessionHistory as any)?.providerSessionId === 'string'
         ? (sessionHistory as any).providerSessionId.trim()
@@ -1541,6 +1549,7 @@ export async function handleChatHistory(h: CommandHelpers, args: any): Promise<C
                 scripts: provider?.scripts as any,
                 sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
                 envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                 pinnedProviderSessionId: getBoundProviderSessionIdPin(args?.targetSessionId),
             })
             : readProviderChatHistory(agentStr, {
@@ -1772,6 +1781,9 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         excludeInProgressTurn: returnedStatus === 'waiting_approval',
                         sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
                         envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                        // Stable per-session identity for antigravity's conversation-claim
+                        // owner token (== session registry sessionId == instance instanceId).
+                        instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                         pinnedProviderSessionId: getBoundProviderSessionIdPin(targetSessionId),
                         // Last-resort only when no pin was ever recorded for this
                         // session; the downstream workspace-overlap safety gate
@@ -1847,6 +1859,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                         excludeInProgressTurn: returnedStatus === 'waiting_approval',
                         sessionStartedAtMs,
                         envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                        instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                     });
                     nativeHistoryError = undefined;
                     nativeMessages = nativeHistory && Array.isArray(nativeHistory.messages)
@@ -2145,6 +2158,7 @@ export async function handleReadChat(h: CommandHelpers, args: any): Promise<Comm
                     scripts: provider?.scripts as any,
                     sessionStartedAtMs: sessionStartedAtMsFromRegistry(h, args?.targetSessionId),
                     envOverrides: sessionSpawnEnvFromAdapter(h, args?.targetSessionId),
+                    instanceId: typeof args?.targetSessionId === 'string' ? args.targetSessionId : undefined,
                     pinnedProviderSessionId: pinnedProviderSessionIdForHistory,
                     // Last-resort only when no pin was ever recorded AND the
                     // runtime fallback did not resolve a real provider session.

package/src/config/chat-history.ts

@@ -1813,10 +1813,12 @@ function callProviderNativeHistoryRead(
     sessionStartedAtMs?: number,
     envOverrides?: Record<string, string>,
     forceRefresh?: boolean,
+    instanceId?: string,
 ): ProviderNativeHistoryReadResult | null {
     const fn = getProviderNativeHistoryScript(scripts, canonicalHistory, 'readSession');
     if (!fn) return null;
     const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId || '');
+    const normalizedInstanceId = typeof instanceId === 'string' ? instanceId.trim() : '';
     const result = fn({
         agentType,
         sessionId: normalizedSessionId,
@@ -1831,6 +1833,12 @@ function callProviderNativeHistoryRead(
         // which leaves the guard disarmed so discovery still works.
         providerSessionId: normalizedSessionId,
         historySessionId: normalizedSessionId,
+        // Stable per-session owner key for the antigravity conversation-claim
+        // registry (see dispatcher.resolveAntigravityPath / antigravityOwnerToken).
+        // Equals the session registry's sessionId and the provider instance's
+        // instanceId, so read side and instance side derive the identical claim
+        // owner token and two concurrent antigravity sessions never cross-bind.
+        instanceId: normalizedInstanceId || undefined,
         workspace,
         format: canonicalHistory?.format,
         watchPath: canonicalHistory?.watchPath,
@@ -1838,7 +1846,7 @@ function callProviderNativeHistoryRead(
         sessionStartedAtMs,
         envOverrides,
         forceRefresh: forceRefresh === true,
-        args: { sessionId: normalizedSessionId, historySessionId: normalizedSessionId, workspace, excludeInProgressTurn: excludeInProgressTurn === true, sessionStartedAtMs, envOverrides, forceRefresh: forceRefresh === true },
+        args: { sessionId: normalizedSessionId, historySessionId: normalizedSessionId, instanceId: normalizedInstanceId || undefined, workspace, excludeInProgressTurn: excludeInProgressTurn === true, sessionStartedAtMs, envOverrides, forceRefresh: forceRefresh === true },
     });
     if (!result || typeof result !== 'object') return null;
     const records = normalizeProviderNativeHistoryRecords(agentType, normalizedSessionId, (result as any).messages || (result as any).records);
@@ -1865,11 +1873,12 @@ function buildNativeHistoryReadResult(
     sessionStartedAtMs?: number,
     envOverrides?: Record<string, string>,
     forceRefresh?: boolean,
+    instanceId?: string,
 ): ProviderNativeHistoryReadResult | null {
     const normalizedSessionId = normalizeSavedHistorySessionId(historySessionId || '');
     const normalizedWorkspace = typeof workspace === 'string' ? workspace.trim() : '';
     if (!canonicalHistory || (!normalizedSessionId && !normalizedWorkspace) || !isNativeSourceCanonicalHistory(canonicalHistory)) return null;
-    return callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, normalizedSessionId, workspace, excludeInProgressTurn, sessionStartedAtMs, envOverrides, forceRefresh);
+    return callProviderNativeHistoryRead(agentType, canonicalHistory, scripts, normalizedSessionId, workspace, excludeInProgressTurn, sessionStartedAtMs, envOverrides, forceRefresh, instanceId);
 }
 
 function materializeNativeHistoryToMirror(
@@ -1929,6 +1938,13 @@ export function readProviderChatHistory(
         sessionStartedAtMs?: number;
         envOverrides?: Record<string, string>;
         forceRefresh?: boolean;
+        // Daemon instance id of the reading session (== the session registry's
+        // sessionId). Threaded to the native-history dispatcher so the
+        // antigravity conversation-claim owner token is keyed on this stable
+        // per-session identity — identical to the token the provider instance
+        // derives — instead of a spawn timestamp that differs across sample
+        // sites and silently breaks claim isolation.
+        instanceId?: string;
     } = {},
 ): {
     messages: HistoryMessage[];
@@ -1943,7 +1959,7 @@ export function readProviderChatHistory(
     unavailableReason?: string;
 } {
     if (isNativeSourceCanonicalHistory(options.canonicalHistory) && (options.historySessionId || options.workspace)) {
-        const nativeResult = buildNativeHistoryReadResult(agentType, options.canonicalHistory, options.scripts, options.historySessionId, options.workspace, options.excludeInProgressTurn, options.sessionStartedAtMs, options.envOverrides, options.forceRefresh);
+        const nativeResult = buildNativeHistoryReadResult(agentType, options.canonicalHistory, options.scripts, options.historySessionId, options.workspace, options.excludeInProgressTurn, options.sessionStartedAtMs, options.envOverrides, options.forceRefresh, options.instanceId);
         if (!nativeResult) return { messages: [], hasMore: false, source: 'native-unavailable' };
         return {
             ...pageHistoryRecords(agentType, nativeResult.records, options.offset || 0, options.limit || 30, options.excludeRecentCount || 0, options.historyBehavior),

package/src/index.ts

@@ -228,8 +228,8 @@ export type { CanonicalMeshToolName } from '@adhdev/mesh-shared';
 
 // ── Mesh Coordinator ──
 export { buildCoordinatorSystemPrompt } from './mesh/coordinator-prompt.js';
-export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, getMeshStatusMissionsCompact, listMeshMissionSummaries, buildMissionPromptSection, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';
-export type { MeshMissionRecord, MeshMissionStatus, MeshMissionSummary, MeshMissionSlimSummary, MeshMissionTaskAggregate, MeshStatusMissionsCompact, MeshStatusMissionsHistoryFold } from './mesh/mesh-missions.js';
+export { upsertMeshMission, getMeshMissions, getMeshMission, summarizeMissionTasks, summarizeMeshMission, getActiveMeshMissionSummaries, getMeshStatusMissionSummaries, getMeshStatusMissionsCompact, listMeshMissionSummaries, listMeshMissionsForTool, buildMissionPromptSection, GOAL_PREVIEW_MAX, COMPACT_STATUS_GOAL_PREVIEW_MAX, MESH_MISSION_LIST_HISTORY_ID_LIMIT, MESH_MISSION_LIST_STATUS_LIMIT, MESH_MISSION_STATUSES } from './mesh/mesh-missions.js';
+export type { MeshMissionRecord, MeshMissionStatus, MeshMissionSummary, MeshMissionSlimSummary, MeshMissionTaskAggregate, MeshStatusMissionsCompact, MeshStatusMissionsHistoryFold, MeshMissionListResult } from './mesh/mesh-missions.js';
 export { computeMeshTaskStats, computeMeshMissionStats } from './mesh/mesh-task-stats.js';
 export type { MeshTaskStats, MeshMissionStats } from './mesh/mesh-task-stats.js';
 export { deriveMeshReviewInboxItems } from './mesh/mesh-review-inbox.js';
@@ -303,6 +303,11 @@ export { buildMeshHostRequiredFailure, createDefaultMeshHostMetadata, isMeshHost
 // ── Mesh Events ──
 export { triggerMeshQueue, drainPendingMeshCoordinatorEvents, getPendingMeshCoordinatorEvents, clearPendingMeshCoordinatorEvents, queuePendingMeshCoordinatorEvent, requeueHeldMeshCoordinatorEvents, serializeV2EnvelopeToWire, readV2EnvelopeFromWire, reconcileDirectDispatchCompletionFromTranscript } from './mesh/mesh-events.js';
 export type { PendingMeshCoordinatorEvent, MeshHeldEventRequeueFilter, MeshHeldEventRequeueResult } from './mesh/mesh-events.js';
+// COORD-EVENT-MISROUTE: coordinator-identity helper so the mcp-server drain path can build a
+// session-scoped drainer identity (identityDeliversTo sibling-session filter) with the same
+// canonical builder daemon-core uses internally, instead of hand-rolling the identity shape.
+export { coordinatorIdentityFromEmitFields } from './mesh/contracts.js';
+export type { CoordinatorIdentity } from './mesh/contracts.js';
 // The coordinator-side preview surfaced from a worker's completion/status event
 // (finalSummary / workerResult.summary / lastMessagePreview). Same data the mobile
 // inbox is fed; reused by mesh_read_chat's cache fallback when the live P2P read path

package/src/mesh/mesh-completion-synthesis.ts

@@ -327,7 +327,23 @@ export async function reconcileUnterminatedDirectDispatches(
         }
 
         const providerSessionId = readNonEmptyString(payload.providerSessionId);
-        const coordinatorDaemonId = selfIds.find(id => !!id);
+        // COORD-EVENT-MISROUTE (anchor preservation): the coordinator DAEMON anchor for the
+        // synthesized completion is the daemon that DISPATCHED the task, NOT this reconcile
+        // runner's own daemon. On a REMOTE worker the reconcile loop runs on the WORKER's daemon,
+        // so `selfIds` is the worker daemon — stamping it as targetCoordinatorDaemonId corrupts the
+        // anchor and (when the real coordinator is on another machine) downgrades the completion to
+        // a cross-machine broadcast deliverable to any coordinator. Recover the true anchor:
+        //   1. the live worker session's meshCoordinatorDaemonId relay stamp (set at dispatch,
+        //      the same anchor the worker's own real-emit path reads in mesh-event-forwarding); then
+        //   2. leave it to reconcileDirectDispatchCompletionFromTranscript, which recovers the
+        //      DISPATCHING coordinator daemon from the task_dispatched ledger (authoritative).
+        // Only when NEITHER is available do we fall back to selfIds — a genuinely local,
+        // single-daemon dispatch where self IS the coordinator daemon (unchanged behaviour).
+        const workerSession = components.instanceManager.getInstance(sessionId);
+        const workerCoordinatorDaemonId = readNonEmptyString(
+            (workerSession?.getState()?.settings as Record<string, unknown> | undefined)?.meshCoordinatorDaemonId,
+        );
+        const coordinatorDaemonId = workerCoordinatorDaemonId || selfIds.find(id => !!id);
         try {
             const result = reconcileDirectDispatchCompletionFromTranscript({
                 meshId: mesh.id,
@@ -338,6 +354,8 @@ export async function reconcileUnterminatedDirectDispatches(
                 taskId,
                 finalSummary: evidence.finalSummary,
                 ...(evidence.transcriptMessageAt ? { transcriptMessageAt: evidence.transcriptMessageAt } : {}),
+                // The ledger-recovered dispatching-coordinator daemon (inside the reconcile fn)
+                // takes PRIORITY over this arg; this remains the best-available fallback.
                 ...(coordinatorDaemonId ? { targetCoordinatorDaemonId: coordinatorDaemonId } : {}),
                 source: 'daemon_reconcile_transcript_completion',
             });

package/src/mesh/mesh-events-stale.ts

@@ -345,6 +345,18 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
     // Absent on legacy rows → undefined → daemon-level routing (unchanged, no regression).
     const targetCoordinatorSessionId = readNonEmptyString(args.targetCoordinatorSessionId)
         || readNonEmptyString(dispatch?.payload?.coordinatorSessionId);
+    // COORD-EVENT-MISROUTE (anchor preservation): the DISPATCHING coordinator's daemon anchor.
+    // Prefer the DISPATCH LEDGER's `coordinatorDaemonId` (the daemon that ISSUED the task) over the
+    // caller-supplied arg — the synth caller (mesh-completion-synthesis) resolves the arg from its
+    // OWN selfIds, which on a remote worker's reconcile is the WORKER daemon, not the coordinator.
+    // Using the worker's self-daemon as the anchor makes coordinatorIdentityFromEmitFields treat
+    // the completion as addressed to the worker daemon; when the coordinator lives on a DIFFERENT
+    // machine that anchor never matches, selfFallback fires and stampPendingEventV2 broadcasts the
+    // completion to ANY coordinator (contracts.ts shouldDeliverPendingEventToCoordinator → true for
+    // broadcast), the cross-machine misroute. The ledger value is the authoritative issuing-daemon
+    // anchor. Absent on legacy rows → fall back to the arg → daemon-level routing (no regression).
+    const targetCoordinatorDaemonId = readNonEmptyString(dispatch?.payload?.coordinatorDaemonId)
+        || readNonEmptyString(args.targetCoordinatorDaemonId);
     queuePendingMeshCoordinatorEvent({
         event: eventName,
         meshId: args.meshId,
@@ -353,7 +365,7 @@ export function reconcileDirectDispatchCompletionFromTranscript(args: {
         metadataEvent,
         coordinatorMessage: buildMeshSystemMessage({ event: eventName, nodeLabel, metadataEvent }),
         queuedAt: Date.now(),
-        ...(readNonEmptyString(args.targetCoordinatorDaemonId) ? { targetCoordinatorDaemonId: readNonEmptyString(args.targetCoordinatorDaemonId) } : {}),
+        ...(targetCoordinatorDaemonId ? { targetCoordinatorDaemonId } : {}),
         ...(targetCoordinatorSessionId ? { targetCoordinatorSessionId } : {}),
     });
 

package/src/mesh/mesh-missions.ts

@@ -120,6 +120,19 @@ export const GOAL_PREVIEW_MAX = 120;
  */
 export const COMPACT_STATUS_GOAL_PREVIEW_MAX = 80;
 
+/**
+ * mesh_mission_list default fold sizes. Without an explicit `statuses` filter the
+ * tool returns non-terminal (active/paused) missions in full detail but folds the
+ * completed/abandoned history into counts + a capped newest-first id list — a mesh
+ * can accumulate hundreds of terminal missions and returning them all (each with a
+ * ledger-scanned stats rollup) blew past the tool payload / token budget and spilled
+ * to a file. When an explicit `statuses` filter IS given, the matching missions are
+ * returned in detail but still bounded by MESH_MISSION_LIST_STATUS_LIMIT so a
+ * status:["completed"] call on a huge history stays bounded (overflow → truncated).
+ */
+export const MESH_MISSION_LIST_HISTORY_ID_LIMIT = 30;
+export const MESH_MISSION_LIST_STATUS_LIMIT = 50;
+
 function normalizeMissionStatus(value: unknown): MeshMissionStatus {
     return MESH_MISSION_STATUSES.includes(value as MeshMissionStatus)
         ? value as MeshMissionStatus
@@ -542,6 +555,120 @@ export function listMeshMissionSummaries(
     return options?.verbose ? full : full.map(summary => slimMissionSummary(summary));
 }
 
+/** Shaped mesh_mission_list result: bounded detail list + optional folded history. */
+export interface MeshMissionListResult {
+    /** Detailed (slim or verbose) mission summaries — bounded, newest-first. */
+    missions: MeshMissionSummary[] | MeshMissionSlimSummary[];
+    /**
+     * Completed/abandoned missions folded to counts + ids. Present (default path)
+     * when no explicit status filter is given and terminal missions exist. Null when
+     * an explicit status filter is active (those missions go into `missions`).
+     */
+    historyFold: MeshStatusMissionsHistoryFold | null;
+    /** True when an explicit status filter matched more than `limit` missions. */
+    truncated: boolean;
+    /** Total missions matching the query BEFORE the detail-list cap was applied. */
+    matched: number;
+    /** Newest-first ids of missions dropped by the detail-list cap (truncated path). */
+    overflowIds?: string[];
+}
+
+/**
+ * mesh_mission_list projection: payload-bounded regardless of mesh mission count.
+ *
+ * Default (no explicit `statuses`): non-terminal missions (active/paused) return in
+ * detail; completed/abandoned missions are folded to counts + a capped id list
+ * (historyFold), NOT emitted one-by-one. This is what keeps the tool from returning
+ * hundreds of terminal missions (each with a ledger stats rollup) and overflowing the
+ * token budget.
+ *
+ * Explicit `statuses` (e.g. ["completed"]): the coordinator asked to see those
+ * missions, so they ARE returned in detail — but still bounded by `limit` (default
+ * MESH_MISSION_LIST_STATUS_LIMIT). Overflow beyond `limit` is reported via
+ * truncated:true + overflowIds rather than silently dropped.
+ *
+ * MAGI + verbose semantics match listMeshMissionSummaries. `withStats` opts each
+ * detailed mission into the ledger-scanned stats rollup (off by default — the tasks
+ * aggregate is enough for a list view).
+ */
+export function listMeshMissionsForTool(
+    meshId: string,
+    options?: {
+        statuses?: MeshMissionStatus[];
+        verbose?: boolean;
+        includeMagi?: boolean;
+        withStats?: boolean;
+        limit?: number;
+        historyIdLimit?: number;
+    },
+): MeshMissionListResult {
+    const explicitStatuses = options?.statuses && options.statuses.length > 0 ? options.statuses : undefined;
+    const includeMagi = options?.includeMagi === true;
+    const verbose = options?.verbose === true;
+    const withStats = options?.withStats === true;
+    const limit = Math.max(1, options?.limit ?? MESH_MISSION_LIST_STATUS_LIMIT);
+    const historyIdLimit = Math.max(0, options?.historyIdLimit ?? MESH_MISSION_LIST_HISTORY_ID_LIMIT);
+
+    const passesMagi = (m: MeshMissionRecord) => includeMagi || !(m.source === 'magi' && m.status === 'completed');
+    const byUpdatedDesc = (a: MeshMissionRecord, b: MeshMissionRecord) => (b.updatedAt || '').localeCompare(a.updatedAt || '');
+
+    const project = (mission: MeshMissionRecord): MeshMissionSummary | MeshMissionSlimSummary => {
+        let summary = summarizeMeshMission(meshId, mission);
+        if (withStats) {
+            try {
+                summary = { ...summary, stats: computeMeshMissionStats(meshId, mission.id) };
+            } catch { /* stats optional — omit on failure */ }
+        }
+        return verbose ? summary : slimMissionSummary(summary);
+    };
+
+    const foldHistory = (history: MeshMissionRecord[]): MeshStatusMissionsHistoryFold | null => {
+        if (history.length === 0) return null;
+        const byStatus: Record<string, number> = {};
+        for (const m of history) byStatus[m.status] = (byStatus[m.status] ?? 0) + 1;
+        return {
+            count: history.length,
+            byStatus,
+            missionIds: history.slice(0, historyIdLimit).map(m => m.id),
+            note: 'Completed/abandoned missions are folded to counts + ids. Pass status (e.g. status:["completed"]) to list them in detail.',
+        };
+    };
+
+    if (explicitStatuses) {
+        // Explicit filter: return matching missions in detail, capped at `limit`.
+        const matched = getMeshMissions(meshId, explicitStatuses)
+            .filter(passesMagi)
+            .sort(byUpdatedDesc);
+        const shown = matched.slice(0, limit);
+        const overflow = matched.slice(limit);
+        return {
+            missions: shown.map(project) as MeshMissionSummary[] | MeshMissionSlimSummary[],
+            historyFold: null,
+            truncated: overflow.length > 0,
+            matched: matched.length,
+            ...(overflow.length > 0 ? { overflowIds: overflow.map(m => m.id) } : {}),
+        };
+    }
+
+    // Default: detail for non-terminal missions, fold terminal history.
+    const all = getMeshMissions(meshId).filter(passesMagi);
+    const live = all
+        .filter(m => m.status === 'active' || m.status === 'paused')
+        .sort(byUpdatedDesc);
+    const history = all
+        .filter(m => m.status === 'completed' || m.status === 'abandoned')
+        .sort(byUpdatedDesc);
+    const shown = live.slice(0, limit);
+    const overflow = live.slice(limit);
+    return {
+        missions: shown.map(project) as MeshMissionSummary[] | MeshMissionSlimSummary[],
+        historyFold: foldHistory(history),
+        truncated: overflow.length > 0,
+        matched: live.length,
+        ...(overflow.length > 0 ? { overflowIds: overflow.map(m => m.id) } : {}),
+    };
+}
+
 /**
  * M3-3: render active missions as a prompt section for {{mission}}.
  * Empty string when no active mission — the prompt stays byte-identical to

package/src/providers/cli-provider-instance.ts

@@ -1089,12 +1089,24 @@ export class CliProviderInstance implements ProviderInstance {
 
     /**
      * Owner token for this session in the antigravity conversation-claim
-     * registry. Derived identically to the dispatcher's read-side token
-     * (workspace + spawn time) so the claims the dispatcher records under this
-     * session are the ones dispose() releases.
+     * registry. Keyed on the daemon instance id — the SAME value the session
+     * registry stores as this session's `sessionId` (see cli-manager
+     * `sessionRegistry.register({ sessionId: cliInstance.instanceId })`) and the
+     * read side hands the dispatcher as `instanceId`. Both sides therefore
+     * derive the identical `iid:<instanceId>` token, so the claims the
+     * dispatcher records under this session are exactly the ones dispose()
+     * releases.
+     *
+     * This must NOT be derived from a spawn timestamp: the instance's
+     * `startedAt`, the adapter's `spawnedAtMs`, and the session registry's
+     * `spawnedAtMs` are three INDEPENDENT `Date.now()` samples for the one
+     * session, so a workspace+spawn-time token computed here would never equal
+     * the read side's — the claim isolation then silently collapses and two
+     * concurrent antigravity sessions cross-bind each other's conversation .db
+     * (coordinator+worker chat crosswire).
      */
     private antigravityClaimOwner(): string {
-        return antigravityOwnerToken(this.workingDir, this.startedAt);
+        return antigravityOwnerToken(this.workingDir, this.startedAt, this.instanceId);
     }
 
     dispose(): void {