@adhdev/daemon-core 0.9.82-rc.57 → 0.9.82-rc.59

package/dist/index.mjs

@@ -1264,6 +1264,7 @@ __export(mesh_ledger_exports, {
   getSessionRecoveryContext: () => getSessionRecoveryContext,
   isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
   meshLedgerEvents: () => meshLedgerEvents,
+  normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
   readLedgerEntries: () => readLedgerEntries,
   readLedgerSlice: () => readLedgerSlice
 });
@@ -1291,6 +1292,86 @@ function getRotatedPath(meshId, index) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   return join6(getLedgerDir(), `${safe}.${index}.jsonl`);
 }
+function readNonEmptyString(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function readStringArray(value) {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => readNonEmptyString(item)).filter(Boolean);
+}
+function extractJsonObjectFromSummary(summary) {
+  const text = readNonEmptyString(summary);
+  if (!text) return void 0;
+  const fenced = text.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  const candidates = [fenced?.[1], text].filter(Boolean);
+  for (const candidate of candidates) {
+    const trimmed = candidate.trim();
+    if (!trimmed.startsWith("{") || !trimmed.endsWith("}")) continue;
+    try {
+      const parsed = JSON.parse(trimmed);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return parsed;
+    } catch {
+    }
+  }
+  return void 0;
+}
+function normalizeValidationResults(value) {
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => item && typeof item === "object" && !Array.isArray(item)).map((item) => {
+    const status = ["passed", "failed", "skipped", "unknown"].includes(item.status) ? item.status : "unknown";
+    return {
+      ...readNonEmptyString(item.command) ? { command: readNonEmptyString(item.command) } : {},
+      status,
+      ...Number.isFinite(Number(item.durationMs)) ? { durationMs: Number(item.durationMs) } : {},
+      ...readNonEmptyString(item.outputPath) ? { outputPath: readNonEmptyString(item.outputPath) } : {},
+      ...readNonEmptyString(item.summary) ? { summary: readNonEmptyString(item.summary) } : {}
+    };
+  });
+}
+function normalizeProcessArtifacts(value) {
+  if (!Array.isArray(value)) return [];
+  const kinds = /* @__PURE__ */ new Set(["process", "log", "port", "window", "session", "file", "url", "other"]);
+  return value.filter((item) => item && typeof item === "object" && !Array.isArray(item)).map((item) => ({
+    kind: kinds.has(item.kind) ? item.kind : "other",
+    ...readNonEmptyString(item.id) ? { id: readNonEmptyString(item.id) } : {},
+    ...readNonEmptyString(item.label) ? { label: readNonEmptyString(item.label) } : {},
+    ...readNonEmptyString(item.locator) ? { locator: readNonEmptyString(item.locator) } : {},
+    ...Number.isFinite(Number(item.pid)) ? { pid: Number(item.pid) } : {},
+    ...Number.isFinite(Number(item.port)) ? { port: Number(item.port) } : {},
+    ...readNonEmptyString(item.url) ? { url: readNonEmptyString(item.url) } : {},
+    ...readNonEmptyString(item.path) ? { path: readNonEmptyString(item.path) } : {},
+    ...readNonEmptyString(item.sessionId) ? { sessionId: readNonEmptyString(item.sessionId) } : {},
+    ...typeof item.keepRunning === "boolean" ? { keepRunning: item.keepRunning } : {},
+    ...item.metadata && typeof item.metadata === "object" && !Array.isArray(item.metadata) ? { metadata: item.metadata } : {}
+  }));
+}
+function normalizeMeshWorkerResult(input, source = "explicit_metadata") {
+  const raw = input && typeof input === "object" ? input : {};
+  const status = ["completed", "failed", "blocked", "partial", "unknown"].includes(String(raw.status)) ? raw.status : "unknown";
+  const gitStatus = raw.gitStatus && typeof raw.gitStatus === "object" && !Array.isArray(raw.gitStatus) ? raw.gitStatus : void 0;
+  return {
+    status,
+    ...readNonEmptyString(raw.classification) ? { classification: readNonEmptyString(raw.classification) } : {},
+    changedFiles: readStringArray(raw.changedFiles),
+    validationResults: normalizeValidationResults(raw.validationResults),
+    ...gitStatus ? { gitStatus } : {},
+    processArtifacts: normalizeProcessArtifacts(raw.processArtifacts),
+    errors: readStringArray(raw.errors),
+    ...readNonEmptyString(raw.nextAction) ? { nextAction: readNonEmptyString(raw.nextAction) } : {},
+    requiresUserAction: raw.requiresUserAction === true,
+    source
+  };
+}
+function resolveWorkerResult(opts) {
+  if (opts.workerResult && typeof opts.workerResult === "object") {
+    return normalizeMeshWorkerResult(opts.workerResult, "explicit_metadata");
+  }
+  const parsed = extractJsonObjectFromSummary(opts.finalSummary);
+  if (parsed) {
+    return normalizeMeshWorkerResult(parsed, "final_summary_json");
+  }
+  return normalizeMeshWorkerResult(void 0, "default");
+}
 function buildTaskCompletionEvidence(opts) {
   const providerSessionId = opts.providerSessionId?.trim() || void 0;
   const providerType = opts.providerType?.trim() || void 0;
@@ -1307,6 +1388,7 @@ function buildTaskCompletionEvidence(opts) {
       providerSessionId,
       finalSummaryAvailable: typeof opts.finalSummary === "string" && opts.finalSummary.trim().length > 0
     },
+    workerResult: resolveWorkerResult(opts),
     git: {
       status: "deferred",
       reason: "ordinary_completion_git_status_not_checked"
@@ -1601,19 +1683,48 @@ var mesh_work_queue_exports = {};
 __export(mesh_work_queue_exports, {
   ACTIVE_MESH_QUEUE_STATUSES: () => ACTIVE_MESH_QUEUE_STATUSES,
   HISTORICAL_MESH_QUEUE_STATUSES: () => HISTORICAL_MESH_QUEUE_STATUSES,
+  MESH_TASK_MODES: () => MESH_TASK_MODES,
   cancelTask: () => cancelTask,
   claimNextTask: () => claimNextTask,
   enqueueTask: () => enqueueTask,
   getMeshQueueStats: () => getMeshQueueStats,
   getQueue: () => getQueue,
+  normalizeMeshTaskMode: () => normalizeMeshTaskMode,
   recordTaskAutoLaunch: () => recordTaskAutoLaunch,
   requeueTask: () => requeueTask,
   updateSessionTaskStatus: () => updateSessionTaskStatus,
-  updateTaskStatus: () => updateTaskStatus
+  updateTaskStatus: () => updateTaskStatus,
+  validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
 });
 import { existsSync as existsSync7, writeFileSync as writeFileSync3, readFileSync as readFileSync5, openSync, closeSync, unlinkSync } from "fs";
 import { join as join7 } from "path";
 import { randomUUID as randomUUID5 } from "crypto";
+function normalizeMeshTaskMode(value) {
+  if (typeof value !== "string") return void 0;
+  const normalized = value.trim();
+  return MESH_TASK_MODES.includes(normalized) ? normalized : void 0;
+}
+function validateMeshTaskModeRequest(mode, message) {
+  const taskMode = normalizeMeshTaskMode(mode);
+  if (!taskMode) {
+    return { valid: true, violations: [] };
+  }
+  if (taskMode !== "live_debug_readonly") {
+    return { valid: true, taskMode, violations: [] };
+  }
+  const violations = LIVE_DEBUG_READONLY_FORBIDDEN.filter((rule) => rule.pattern.test(message || "")).map((rule) => rule.label);
+  return {
+    valid: violations.length === 0,
+    taskMode,
+    violations,
+    allowedOperations: [
+      "process/log/window/port/session inspection",
+      "read-only filesystem listing/reading",
+      "status probes and keep-running handle reporting",
+      "diagnostic summaries without source edits, commits, checkpoints, pushes, deploys, resets, rebases, or destructive cleanups"
+    ]
+  };
+}
 function getQueuePath(meshId) {
   const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
   return join7(getLedgerDir(), `${safe}.queue.json`);
@@ -1664,6 +1775,10 @@ function writeQueue(meshId, queue) {
 }
 function enqueueTask(meshId, message, opts) {
   requireMeshHostQueueOwner(opts);
+  const modeValidation = validateMeshTaskModeRequest(opts?.taskMode, message);
+  if (!modeValidation.valid) {
+    throw new Error(`live_debug_readonly_guardrail_violation: forbidden operations (${modeValidation.violations.join(", ")})`);
+  }
   return withQueueLock(meshId, () => {
     const queue = readQueue(meshId);
     const entry = {
@@ -1671,6 +1786,7 @@ function enqueueTask(meshId, message, opts) {
       meshId,
       message,
       status: "pending",
+      taskMode: modeValidation.taskMode,
       targetNodeId: opts?.targetNodeId,
       targetSessionId: opts?.targetSessionId,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1832,7 +1948,7 @@ function getMeshQueueStats(meshId) {
     }))
   };
 }
-var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES;
+var ACTIVE_MESH_QUEUE_STATUSES, HISTORICAL_MESH_QUEUE_STATUSES, MESH_TASK_MODES, LIVE_DEBUG_READONLY_FORBIDDEN;
 var init_mesh_work_queue = __esm({
   "src/mesh/mesh-work-queue.ts"() {
     "use strict";
@@ -1840,6 +1956,14 @@ var init_mesh_work_queue = __esm({
     init_mesh_host_ownership();
     ACTIVE_MESH_QUEUE_STATUSES = ["pending", "assigned"];
     HISTORICAL_MESH_QUEUE_STATUSES = ["completed", "failed", "cancelled"];
+    MESH_TASK_MODES = ["code_change", "validation", "live_debug_readonly", "launch_app", "convergence"];
+    LIVE_DEBUG_READONLY_FORBIDDEN = [
+      { label: "source_edit", pattern: /\b(edit|modify|patch|apply\s+patch|write\s+(?:to\s+)?(?:file|source)|overwrite|delete\s+file|remove\s+file|create\s+file|touch\s+file)\b/i },
+      { label: "git_mutation", pattern: /\b(?:git\s+(?:add|commit|push|reset|rebase|clean|checkout|switch|merge|tag|restore|rm|mv)|push\b)/i },
+      { label: "checkpoint", pattern: /\b(checkpoint|mesh_checkpoint)\b/i },
+      { label: "deploy_or_version_bump", pattern: /\b(deploy|wrangler\s+deploy|version[-\s]?bump|npm\s+version|release)\b/i },
+      { label: "destructive_shell", pattern: /\b(rm\s+-rf|mv\s+\S+\s+\S+|truncate\s|tee\s+\S+|sed\s+-i)\b/i }
+    ];
   }
 });
 
@@ -2205,6 +2329,9 @@ __export(mesh_events_exports, {
 });
 import { appendFileSync as appendFileSync3, existsSync as existsSync10, readFileSync as readFileSync6, unlinkSync as unlinkSync3 } from "fs";
 import { join as join10 } from "path";
+function readWorkerResultMetadata(event) {
+  return readRecord(event.workerResult) || readRecord(event.meshWorkerResult) || readRecord(event.structuredResult);
+}
 function sweepExpiredRemoteIdleSessions() {
   const now = Date.now();
   for (const [key, session] of remoteIdleSessions) {
@@ -2270,20 +2397,28 @@ function clearPendingMeshCoordinatorEvents(meshId) {
   } catch {
   }
 }
-function readNonEmptyString(value) {
+function readNonEmptyString2(value) {
   return typeof value === "string" && value.trim() ? value.trim() : "";
 }
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
 function resolveEventSessionId(event, fallback) {
-  return readNonEmptyString(event.targetSessionId) || readNonEmptyString(event.sessionId) || readNonEmptyString(event.instanceId) || readNonEmptyString(fallback);
+  return readNonEmptyString2(event.targetSessionId) || readNonEmptyString2(event.sessionId) || readNonEmptyString2(event.instanceId) || readNonEmptyString2(fallback);
 }
 function isMeshCoordinatorEvent(eventName) {
   return typeof eventName === "string" && MESH_COORDINATOR_EVENTS.has(eventName);
 }
 function formatCompletionMetadata(event) {
+  const completionDiagnostic = event.completionDiagnostic && typeof event.completionDiagnostic === "object" ? event.completionDiagnostic : null;
+  const diagnosticReason = completionDiagnostic ? readNonEmptyString2(completionDiagnostic.blockReason) || "present" : "";
+  const finalAssistantPresent = typeof completionDiagnostic?.finalAssistantPresent === "boolean" ? String(completionDiagnostic.finalAssistantPresent) : "";
   const parts = [
-    readNonEmptyString(event.targetSessionId) ? `session_id=${readNonEmptyString(event.targetSessionId)}` : "",
-    readNonEmptyString(event.providerType) ? `provider=${readNonEmptyString(event.providerType)}` : "",
-    readNonEmptyString(event.providerSessionId) ? `provider_session_id=${readNonEmptyString(event.providerSessionId)}` : ""
+    readNonEmptyString2(event.targetSessionId) ? `session_id=${readNonEmptyString2(event.targetSessionId)}` : "",
+    readNonEmptyString2(event.providerType) ? `provider=${readNonEmptyString2(event.providerType)}` : "",
+    readNonEmptyString2(event.providerSessionId) ? `provider_session_id=${readNonEmptyString2(event.providerSessionId)}` : "",
+    diagnosticReason ? `completion_diagnostic=${diagnosticReason}` : "",
+    finalAssistantPresent ? `final_assistant=${finalAssistantPresent}` : ""
   ].filter(Boolean);
   return parts.length > 0 ? ` (${parts.join("; ")})` : "";
 }
@@ -2325,7 +2460,7 @@ function readEventTimestamp(value) {
   return null;
 }
 function buildMeshCompletionFingerprint(args) {
-  const timestampPart = Number.isFinite(args.timestamp) ? String(args.timestamp) : readNonEmptyString(args.finalSummary).slice(0, 200);
+  const timestampPart = Number.isFinite(args.timestamp) ? String(args.timestamp) : readNonEmptyString2(args.finalSummary).slice(0, 200);
   return [
     args.meshId,
     args.event,
@@ -2403,7 +2538,7 @@ function isTerminalSessionStatus(status) {
   return ["stopped", "failed", "terminated", "exited", "closed"].includes(status);
 }
 function isIdleSessionState(state) {
-  const status = readNonEmptyString(state?.status).toLowerCase();
+  const status = readNonEmptyString2(state?.status).toLowerCase();
   if (isTerminalSessionStatus(status)) return false;
   return status === "idle" || state?.activeChat?.status === "waiting_input";
 }
@@ -2412,15 +2547,15 @@ function isDirtyNode(node) {
 }
 function isLaunchableNode(node) {
   if (!node || node.status === "disabled" || node.status === "removed") return false;
-  const health = readNonEmptyString(node.health).toLowerCase();
+  const health = readNonEmptyString2(node.health).toLowerCase();
   if (!health) return true;
   return health === "online" || health === "unknown";
 }
 function localAutoLaunchSkipReason(node) {
-  const daemonId = readNonEmptyString(node?.daemonId);
-  const machineId = readNonEmptyString(node?.machineId);
+  const daemonId = readNonEmptyString2(node?.daemonId);
+  const machineId = readNonEmptyString2(node?.machineId);
   const appConfig = loadConfig();
-  const localMachineId = readNonEmptyString(appConfig.machineId) || readNonEmptyString(appConfig.registeredMachineId);
+  const localMachineId = readNonEmptyString2(appConfig.machineId) || readNonEmptyString2(appConfig.registeredMachineId);
   const cloudDaemonId = localMachineId ? `daemon_${localMachineId}` : "";
   const standaloneDaemonId = localMachineId ? `standalone_${localMachineId}` : "";
   const daemonMatchesLocal = !daemonId || daemonId === cloudDaemonId || daemonId === standaloneDaemonId;
@@ -2443,10 +2578,10 @@ function liveSessionCountForNode(components, meshId, nodeId) {
   return components.instanceManager.getByCategory("cli").filter((inst) => {
     const state = inst.getState();
     const settings = state.settings || {};
-    if (readNonEmptyString(settings.meshNodeFor) !== meshId) return false;
-    const instNodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+    if (readNonEmptyString2(settings.meshNodeFor) !== meshId) return false;
+    const instNodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
     if (instNodeId !== nodeId) return false;
-    const status = readNonEmptyString(state.status).toLowerCase();
+    const status = readNonEmptyString2(state.status).toLowerCase();
     return !isTerminalSessionStatus(status);
   }).length;
 }
@@ -2538,7 +2673,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
       continue;
     }
     for (const node of candidateNodes) {
-      const nodeId = readNonEmptyString(node?.id);
+      const nodeId = readNonEmptyString2(node?.id);
       if (!nodeId) continue;
       const launchKey = `${meshId}:${nodeId}`;
       const cooldownUntil = autoLaunchCooldownUntil.get(launchKey) || 0;
@@ -2597,7 +2732,7 @@ async function maybeAutoLaunchOneQueueSession(components, meshId, mesh) {
           autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
           return false;
         }
-        const sessionId = readNonEmptyString(launchResult.sessionId) || readNonEmptyString(launchResult.id) || readNonEmptyString(launchResult.runtimeSessionId);
+        const sessionId = readNonEmptyString2(launchResult.sessionId) || readNonEmptyString2(launchResult.id) || readNonEmptyString2(launchResult.runtimeSessionId);
         if (!sessionId) {
           markAutoLaunch(meshId, task.id, { status: "failed", reason: "launch_missing_session_id", nodeId, providerType: resolved.providerType });
           autoLaunchCooldownUntil.set(launchKey, Date.now() + AUTO_LAUNCH_COOLDOWN_MS);
@@ -2624,13 +2759,13 @@ async function triggerMeshQueue(components, meshId) {
   for (const inst of cliInstances) {
     const state = inst.getState();
     const settings = state.settings || {};
-    const instMeshId = readNonEmptyString(settings.meshNodeFor);
+    const instMeshId = readNonEmptyString2(settings.meshNodeFor);
     if (instMeshId !== meshId) continue;
-    const nodeId = readNonEmptyString(settings.meshNodeId) || readNonEmptyString(settings.nodeId);
+    const nodeId = readNonEmptyString2(settings.meshNodeId) || readNonEmptyString2(settings.nodeId);
     if (!nodeId) continue;
     if (!isIdleSessionState(state)) continue;
     const sessionId = state.instanceId;
-    const providerType = state.type || readNonEmptyString(settings.providerType);
+    const providerType = state.type || readNonEmptyString2(settings.providerType);
     if (providerType) {
       tryAssignQueueTask(components, meshId, nodeId, sessionId, providerType);
     }
@@ -2692,7 +2827,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
 }
 function injectMeshSystemMessage(components, args) {
   const eventSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
-  const eventNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+  const eventNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
   const intentionalCleanupStop = shouldSuppressIntentionalCleanupStop({
     event: args.event,
     meshId: args.meshId,
@@ -2713,10 +2848,10 @@ function injectMeshSystemMessage(components, args) {
       meshId: args.meshId,
       event: args.event,
       sessionId: eventSessionId,
-      providerType: readNonEmptyString(args.metadataEvent.providerType) || void 0,
-      providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
+      providerType: readNonEmptyString2(args.metadataEvent.providerType) || void 0,
+      providerSessionId: readNonEmptyString2(args.metadataEvent.providerSessionId) || void 0,
       timestamp: eventTimestamp,
-      finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+      finalSummary: readNonEmptyString2(args.metadataEvent.finalSummary) || void 0
     });
     if (duplicateCompletion) {
       LOG.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
@@ -2726,8 +2861,8 @@ function injectMeshSystemMessage(components, args) {
   let completedTaskForLedger = null;
   if (args.event === "agent:generating_completed") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
-    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
-    const providerType = readNonEmptyString(args.metadataEvent.providerType);
+    const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
+    const providerType = readNonEmptyString2(args.metadataEvent.providerType);
     if (sessionId) {
       const completedTask = updateSessionTaskStatus(args.meshId, sessionId, "completed", {
         occurredAt: eventTimestamp !== null ? new Date(eventTimestamp).toISOString() : void 0
@@ -2741,8 +2876,11 @@ function injectMeshSystemMessage(components, args) {
     }
   } else if (args.event === "agent:ready") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
-    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
-    const providerType = readNonEmptyString(args.metadataEvent.providerType);
+    const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
+    const providerType = readNonEmptyString2(args.metadataEvent.providerType);
+    const providerSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId) || void 0;
+    const finalSummary = readNonEmptyString2(args.metadataEvent.finalSummary) || void 0;
+    const workerResult = readWorkerResultMetadata(args.metadataEvent);
     const completedTask = sessionId ? updateSessionTaskStatus(args.meshId, sessionId, "completed") : null;
     if (completedTask) {
       completedTaskForLedger = { id: completedTask.id };
@@ -2757,15 +2895,17 @@ function injectMeshSystemMessage(components, args) {
             nodeLabel: args.nodeLabel,
             taskId: completedTask.id,
             completedViaReady: true,
-            providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
-            finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0,
+            providerSessionId,
+            finalSummary,
+            workerResult,
             evidence: buildTaskCompletionEvidence({
               event: "agent:ready",
               nodeId,
               sessionId,
               providerType: providerType || void 0,
-              providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
-              finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+              providerSessionId,
+              finalSummary,
+              workerResult
             })
           }
         });
@@ -2788,13 +2928,13 @@ function injectMeshSystemMessage(components, args) {
     }
   } else if (args.event === "agent:generating_started") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
-    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+    const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
     if (sessionId && nodeId) {
       remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
     }
   } else if (args.event === "agent:stopped") {
     const sessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId);
-    const nodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId);
+    const nodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId);
     if (sessionId && nodeId) {
       remoteIdleSessions.delete(`${nodeId}:${sessionId}`);
     }
@@ -2805,16 +2945,20 @@ function injectMeshSystemMessage(components, args) {
   const ledgerKind = EVENT_TO_LEDGER_KIND[args.event];
   if (ledgerKind) {
     try {
-      const ledgerNodeId = readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0;
+      const ledgerNodeId = readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId) || void 0;
       const ledgerSessionId = resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || void 0;
-      const ledgerProviderType = readNonEmptyString(args.metadataEvent.providerType) || void 0;
+      const ledgerProviderType = readNonEmptyString2(args.metadataEvent.providerType) || void 0;
+      const providerSessionId = readNonEmptyString2(args.metadataEvent.providerSessionId) || void 0;
+      const finalSummary = readNonEmptyString2(args.metadataEvent.finalSummary) || void 0;
+      const workerResult = readWorkerResultMetadata(args.metadataEvent);
       const completionEvidence = ledgerKind === "task_completed" && ledgerNodeId && ledgerSessionId ? buildTaskCompletionEvidence({
         event: "agent:generating_completed",
         nodeId: ledgerNodeId,
         sessionId: ledgerSessionId,
         providerType: ledgerProviderType,
-        providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
-        finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0
+        providerSessionId,
+        finalSummary,
+        workerResult
       }) : void 0;
       appendLedgerEntry(args.meshId, {
         kind: ledgerKind,
@@ -2825,8 +2969,10 @@ function injectMeshSystemMessage(components, args) {
           event: args.event,
           nodeLabel: args.nodeLabel,
           taskId: completedTaskForLedger?.id || void 0,
-          providerSessionId: readNonEmptyString(args.metadataEvent.providerSessionId) || void 0,
-          finalSummary: readNonEmptyString(args.metadataEvent.finalSummary) || void 0,
+          providerSessionId,
+          finalSummary,
+          workerResult,
+          completionDiagnostic: args.metadataEvent.completionDiagnostic && typeof args.metadataEvent.completionDiagnostic === "object" ? args.metadataEvent.completionDiagnostic : void 0,
           evidence: completionEvidence
         }
       });
@@ -2841,10 +2987,10 @@ function injectMeshSystemMessage(components, args) {
       const maxRetries = mesh?.policy?.maxTaskRetries ?? 1;
       recoveryContext = getSessionRecoveryContext(args.meshId, {
         sessionId: resolveEventSessionId(args.metadataEvent, args.sourceInstanceId) || void 0,
-        nodeId: readNonEmptyString(args.nodeId) || readNonEmptyString(args.metadataEvent.meshNodeId) || void 0,
+        nodeId: readNonEmptyString2(args.nodeId) || readNonEmptyString2(args.metadataEvent.meshNodeId) || void 0,
         maxRetries
       });
-      recoveryContext.failedProviderType = readNonEmptyString(args.metadataEvent.providerType) || null;
+      recoveryContext.failedProviderType = readNonEmptyString2(args.metadataEvent.providerType) || null;
       if (recoveryContext.retryRecommended && recoveryContext.consecutiveNodeFailures > 0) {
         appendLedgerEntry(args.meshId, {
           kind: "recovery_attempted",
@@ -2900,7 +3046,7 @@ function injectMeshSystemMessage(components, args) {
       meshId: args.meshId,
       nodeLabel: args.nodeLabel,
       nodeId: args.nodeId || void 0,
-      workspace: readNonEmptyString(args.metadataEvent.workspace),
+      workspace: readNonEmptyString2(args.metadataEvent.workspace),
       metadataEvent: {
         ...args.metadataEvent,
         ...recoveryContext ? { recoveryContext } : {}
@@ -2926,14 +3072,14 @@ function injectMeshSystemMessage(components, args) {
   return { success: true, forwarded: coordinatorInstances.length };
 }
 function handleMeshForwardEvent(components, payload) {
-  const eventName = readNonEmptyString(payload.event);
+  const eventName = readNonEmptyString2(payload.event);
   if (!isMeshCoordinatorEvent(eventName)) {
     return { success: false, error: "unsupported mesh event" };
   }
-  const meshId = readNonEmptyString(payload.meshId);
+  const meshId = readNonEmptyString2(payload.meshId);
   if (!meshId) return { success: false, error: "meshId required" };
-  const nodeId = readNonEmptyString(payload.nodeId);
-  const workspace = readNonEmptyString(payload.workspace);
+  const nodeId = readNonEmptyString2(payload.nodeId);
+  const workspace = readNonEmptyString2(payload.workspace);
   const nodeLabel = nodeId ? `Node '${nodeId}'` : workspace ? `Agent at ${workspace}` : "Remote agent";
   return injectMeshSystemMessage(components, {
     meshId,
@@ -2941,41 +3087,41 @@ function handleMeshForwardEvent(components, payload) {
     nodeLabel,
     event: eventName,
     metadataEvent: {
-      targetSessionId: readNonEmptyString(payload.targetSessionId) || readNonEmptyString(payload.sessionId) || readNonEmptyString(payload.instanceId),
-      providerType: readNonEmptyString(payload.providerType),
-      providerSessionId: readNonEmptyString(payload.providerSessionId),
-      finalSummary: readNonEmptyString(payload.finalSummary) || readNonEmptyString(payload.summary),
+      targetSessionId: readNonEmptyString2(payload.targetSessionId) || readNonEmptyString2(payload.sessionId) || readNonEmptyString2(payload.instanceId),
+      providerType: readNonEmptyString2(payload.providerType),
+      providerSessionId: readNonEmptyString2(payload.providerSessionId),
+      finalSummary: readNonEmptyString2(payload.finalSummary) || readNonEmptyString2(payload.summary),
       ...payload.timestamp !== void 0 ? { timestamp: payload.timestamp } : {},
       intentional: payload.intentional === true,
       intentionalStop: payload.intentionalStop === true,
       operatorCleanup: payload.operatorCleanup === true,
-      reason: readNonEmptyString(payload.reason),
-      stopReason: readNonEmptyString(payload.stopReason),
-      cleanupReason: readNonEmptyString(payload.cleanupReason),
-      source: readNonEmptyString(payload.source)
+      reason: readNonEmptyString2(payload.reason),
+      stopReason: readNonEmptyString2(payload.stopReason),
+      cleanupReason: readNonEmptyString2(payload.cleanupReason),
+      source: readNonEmptyString2(payload.source)
     }
   });
 }
 function setupMeshEventForwarding(components) {
   components.instanceManager.onEvent((event) => {
     if (!isMeshCoordinatorEvent(event.event)) return;
-    const instanceId = readNonEmptyString(event.instanceId);
+    const instanceId = readNonEmptyString2(event.instanceId);
     if (!instanceId) return;
     const sourceInstance = components.instanceManager.getInstance(instanceId);
     if (!sourceInstance || sourceInstance.category !== "cli") return;
     const state = sourceInstance.getState();
-    const workspace = readNonEmptyString(state.workspace);
+    const workspace = readNonEmptyString2(state.workspace);
     if (!workspace) return;
     const settings = state.settings && typeof state.settings === "object" ? state.settings : {};
-    if (readNonEmptyString(settings.meshCoordinatorFor)) return;
-    const meshIdFromRuntime = readNonEmptyString(settings.meshNodeFor);
+    if (readNonEmptyString2(settings.meshCoordinatorFor)) return;
+    const meshIdFromRuntime = readNonEmptyString2(settings.meshNodeFor);
     const isMeshDelegate = Boolean(meshIdFromRuntime || settings.launchedByCoordinator);
     if (!isMeshDelegate) return;
     const mesh = meshIdFromRuntime ? getMeshWithCache(components, meshIdFromRuntime) : getMeshByRepo(workspace);
-    const meshId = meshIdFromRuntime || readNonEmptyString(mesh?.id);
+    const meshId = meshIdFromRuntime || readNonEmptyString2(mesh?.id);
     if (!meshId) return;
     const targetNode = mesh?.nodes?.find((n) => n.workspace === workspace);
-    const runtimeNodeId = readNonEmptyString(settings.meshNodeId);
+    const runtimeNodeId = readNonEmptyString2(settings.meshNodeId);
     const resolvedNodeId = targetNode?.id || runtimeNodeId;
     const nodeLabel = targetNode ? `Node '${targetNode.id}'` : runtimeNodeId ? `Node '${runtimeNodeId}'` : `Agent at ${workspace}`;
     injectMeshSystemMessage(components, {
@@ -3912,7 +4058,9 @@ function resolveCliSpawnPlan(options) {
   const configuredCommand = typeof runtimeSettings.executablePath === "string" && runtimeSettings.executablePath.trim() ? runtimeSettings.executablePath.trim() : spawnConfig.command;
   const binaryPath = findBinary(configuredCommand);
   const isWin = os10.platform() === "win32";
-  const allArgs = [...spawnConfig.args, ...extraArgs];
+  const allArgs = [...spawnConfig.args, ...extraArgs].map(
+    (arg) => typeof arg === "string" ? arg.replace(/\{\{workingDir\}\}/g, workingDir) : arg
+  );
   let shellCmd;
   let shellArgs;
   const useShellUnix = !isWin && (!!spawnConfig.shell || !path15.isAbsolute(binaryPath) || isScriptBinary(binaryPath) || !looksLikeMachOOrElf(binaryPath));
@@ -8527,6 +8675,152 @@ function buildMeshLedgerReconciliationEvidence(meshId, replicas) {
 
 // src/index.ts
 init_mesh_work_queue();
+
+// src/mesh/mesh-active-work.ts
+var DIRECT_DISPATCH_VIA = /* @__PURE__ */ new Set(["p2p_direct", "local_direct", "mesh_send_task"]);
+var TERMINAL_LEDGER_KINDS = /* @__PURE__ */ new Set(["task_completed", "task_failed", "task_stalled"]);
+function readString2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function summarizeMessage(message) {
+  const oneLine = message.replace(/\s+/g, " ").trim();
+  const title = oneLine.length > 96 ? `${oneLine.slice(0, 93)}...` : oneLine;
+  return { title: title || "(untitled task)", summary: oneLine };
+}
+function elapsedSince(value, now) {
+  const started = value ? new Date(value).getTime() : Number.NaN;
+  return Number.isFinite(started) ? Math.max(0, now - started) : 0;
+}
+function sessionStatusFromNodes(nodes, nodeId, sessionId) {
+  if (!nodeId || !sessionId || !Array.isArray(nodes)) return void 0;
+  const node = nodes.find((item) => readString2(item?.id) === nodeId || readString2(item?.nodeId) === nodeId || readString2(item?.node_id) === nodeId);
+  if (!node) return void 0;
+  const candidates = [];
+  for (const value of [node.sessions, node.activeSessions, node.active_sessions, node.lastProbe?.sessions, node.last_probe?.sessions, node.lastProbe?.status?.sessions, node.last_probe?.status?.sessions]) {
+    if (Array.isArray(value)) candidates.push(...value);
+  }
+  for (const value of [node.activeSession, node.active_session, node.currentSession, node.current_session, node.runtimeSession, node.runtime_session, node.session]) {
+    if (value && typeof value === "object") candidates.push(value);
+  }
+  const session = candidates.find((item) => {
+    const id = readString2(item?.id) || readString2(item?.sessionId) || readString2(item?.session_id) || readString2(item?.runtimeSessionId) || readString2(item?.instanceId);
+    return id === sessionId;
+  });
+  if (!session) return void 0;
+  const raw = `${readString2(session.status) || ""} ${readString2(session.lifecycle) || ""} ${readString2(session.state) || ""} ${readString2(session.activeChat?.status) || ""}`.toLowerCase();
+  if (raw.includes("approval")) return "awaiting_approval";
+  if (raw.includes("generating") || raw.includes("running") || raw.includes("busy")) return "generating";
+  if (raw.includes("failed") || raw.includes("stopped") || raw.includes("terminated") || raw.includes("exited")) return "failed";
+  if (raw.includes("idle") || raw.includes("waiting_input") || raw.includes("ready")) return "idle";
+  return void 0;
+}
+function isDirectDispatch(entry) {
+  if (entry.kind !== "task_dispatched") return false;
+  const payload = entry.payload || {};
+  if (payload.source === "direct") return true;
+  const via = readString2(payload.via);
+  return Boolean(via && DIRECT_DISPATCH_VIA.has(via) && payload.source !== "queue");
+}
+function directDispatchTaskId(entry) {
+  return readString2(entry.payload?.taskId) || entry.id;
+}
+function terminalMatchesDispatch(terminal, dispatch, taskId) {
+  const terminalTaskId = readString2(terminal.payload?.taskId);
+  if (terminalTaskId && terminalTaskId === taskId) return true;
+  if (terminalTaskId && terminalTaskId !== taskId) return false;
+  if (dispatch.sessionId && terminal.sessionId === dispatch.sessionId) return true;
+  return Boolean(dispatch.nodeId && terminal.nodeId === dispatch.nodeId && !dispatch.sessionId);
+}
+function statusFromTerminal(entry) {
+  if (entry.kind === "task_approval_needed") return "awaiting_approval";
+  if (entry.kind === "task_completed") return "idle";
+  return "failed";
+}
+function buildMeshActiveWorkSummary(activeWork) {
+  const statusCounts = {
+    pending: 0,
+    assigned: 0,
+    generating: 0,
+    idle: 0,
+    failed: 0,
+    awaiting_approval: 0
+  };
+  const sourceCounts = { queue: 0, direct: 0 };
+  for (const item of activeWork) {
+    sourceCounts[item.source] += 1;
+    statusCounts[item.status] += 1;
+  }
+  return {
+    totalActiveCount: activeWork.length,
+    queueActiveCount: sourceCounts.queue,
+    directActiveCount: sourceCounts.direct,
+    awaitingApprovalCount: statusCounts.awaiting_approval,
+    generatingCount: statusCounts.generating,
+    failedCount: statusCounts.failed,
+    idleCount: statusCounts.idle,
+    sourceCounts,
+    statusCounts
+  };
+}
+function buildMeshActiveWork(opts) {
+  const now = opts.now ?? Date.now();
+  const records = [];
+  for (const task of opts.queue || []) {
+    if (task.status !== "pending" && task.status !== "assigned") continue;
+    const { title, summary } = summarizeMessage(task.message || "");
+    records.push({
+      taskId: task.id,
+      source: "queue",
+      status: task.status,
+      nodeId: task.assignedNodeId || task.targetNodeId,
+      sessionId: task.assignedSessionId || task.targetSessionId,
+      taskTitle: title,
+      taskSummary: summary,
+      message: task.message,
+      taskMode: task.taskMode,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      dispatchedAt: task.dispatchTimestamp,
+      elapsedMs: elapsedSince(task.dispatchTimestamp || task.createdAt, now)
+    });
+  }
+  const ledgerEntries = (opts.ledgerEntries || []).slice().sort((a, b) => new Date(a.timestamp).getTime() - new Date(b.timestamp).getTime());
+  const terminals = ledgerEntries.filter((entry) => TERMINAL_LEDGER_KINDS.has(entry.kind) || entry.kind === "task_approval_needed");
+  for (const dispatch of ledgerEntries.filter(isDirectDispatch)) {
+    const taskId = directDispatchTaskId(dispatch);
+    const terminal = terminals.filter((entry) => new Date(entry.timestamp).getTime() >= new Date(dispatch.timestamp).getTime()).find((entry) => terminalMatchesDispatch(entry, dispatch, taskId));
+    const terminalStatus = terminal ? statusFromTerminal(terminal) : void 0;
+    const liveStatus = sessionStatusFromNodes(opts.nodes, dispatch.nodeId, dispatch.sessionId);
+    const status = terminalStatus || liveStatus || "assigned";
+    const terminalRow = Boolean(terminal && terminal.kind !== "task_approval_needed");
+    if (terminalRow && opts.includeTerminalDirect !== true) continue;
+    const message = readString2(dispatch.payload?.message) || readString2(dispatch.payload?.summary) || "";
+    const { title, summary } = summarizeMessage(message);
+    records.push({
+      taskId,
+      source: "direct",
+      status,
+      nodeId: dispatch.nodeId,
+      sessionId: dispatch.sessionId,
+      providerType: dispatch.providerType || readString2(dispatch.payload?.providerType),
+      taskTitle: readString2(dispatch.payload?.taskTitle) || title,
+      taskSummary: readString2(dispatch.payload?.taskSummary) || summary,
+      message,
+      taskMode: readString2(dispatch.payload?.taskMode),
+      createdAt: dispatch.timestamp,
+      updatedAt: terminal?.timestamp || dispatch.timestamp,
+      dispatchedAt: dispatch.timestamp,
+      elapsedMs: elapsedSince(dispatch.timestamp, now),
+      terminal: terminalRow,
+      terminalKind: terminal?.kind,
+      terminalAt: terminal?.timestamp
+    });
+  }
+  records.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  return { activeWork: records, summary: buildMeshActiveWorkSummary(records) };
+}
+
+// src/index.ts
 init_mesh_host_ownership();
 init_mesh_events();
 
@@ -18526,6 +18820,44 @@ var CliProviderInstance = class {
     const content = lastVisible ? flattenContent(lastVisible.content).trim() : "";
     return role === "assistant" && !!content;
   }
+  buildCompletedFinalizationDiagnostic(args) {
+    let parsed = null;
+    let parseError;
+    try {
+      parsed = this.adapter.getScriptParsedStatus();
+    } catch (error) {
+      parseError = error?.message || String(error);
+    }
+    const visibleMessages = (Array.isArray(parsed?.messages) ? parsed.messages : []).filter((message) => isUserFacingChatMessage(message));
+    const lastVisible = visibleMessages[visibleMessages.length - 1];
+    const lastVisibleRole = typeof lastVisible?.role === "string" ? lastVisible.role.trim().toLowerCase() : null;
+    const lastVisibleKind = typeof lastVisible?.kind === "string" ? lastVisible.kind : null;
+    const lastVisibleContentLength = lastVisible ? flattenContent(lastVisible.content).trim().length : 0;
+    return {
+      providerType: this.type,
+      sessionId: this.instanceId,
+      providerSessionId: this.providerSessionId || null,
+      workspace: this.workingDir,
+      blockReason: args.blockReason,
+      emittedAfterFinalizationTimeout: args.emittedAfterFinalizationTimeout,
+      waitedMs: args.waitedMs,
+      maxWaitMs: COMPLETED_FINALIZATION_MAX_WAIT_MS,
+      adapterStatus: typeof args.latestStatus?.status === "string" ? args.latestStatus.status : null,
+      latestVisibleStatus: args.latestVisibleStatus,
+      parsedStatus: typeof parsed?.status === "string" ? parsed.status : parseError ? "parse_error" : "unknown",
+      parseError: parseError || void 0,
+      finalAssistantPresent: this.completionHasFinalAssistantMessage(parsed?.messages),
+      visibleMessageCount: visibleMessages.length,
+      lastVisibleRole,
+      lastVisibleKind,
+      lastVisibleContentLength,
+      pendingStartedAt: this.generatingStartedAt || null,
+      pendingFirstObservedAt: args.pending.firstObservedAt,
+      pendingTimestamp: args.pending.timestamp,
+      pendingDurationSec: args.pending.duration,
+      previousBlockReason: args.pending.loggedBlockReason || null
+    };
+  }
   hasAdapterPendingResponse() {
     const adapterAny = this.adapter;
     if (adapterAny?.isWaitingForResponse === true) return true;
@@ -18598,7 +18930,23 @@ var CliProviderInstance = class {
         this.scheduleCompletedDebounceFlush(COMPLETED_FINALIZATION_RETRY_MS);
         return;
       }
-      LOG.warn("CLI", `[${this.type}] suppressed completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+      const completionDiagnostic = this.buildCompletedFinalizationDiagnostic({
+        blockReason,
+        latestStatus,
+        latestVisibleStatus,
+        waitedMs,
+        pending,
+        emittedAfterFinalizationTimeout: true
+      });
+      LOG.warn("CLI", `[${this.type}] emitting completed event after ${waitedMs}ms without finalized assistant turn (${blockReason})`);
+      this.pushEvent({
+        event: "agent:generating_completed",
+        chatTitle: pending.chatTitle,
+        duration: pending.duration,
+        timestamp: pending.timestamp,
+        finalSummary: extractFinalSummaryFromMessages(this.adapter?.getScriptParsedStatus()?.messages),
+        completionDiagnostic
+      });
       this.completedDebouncePending = null;
       this.completedDebounceTimer = null;
       this.generatingStartedAt = 0;
@@ -24969,6 +25317,9 @@ function reconcileInlineMeshCache(cached, incoming) {
   const cachedNodes = Array.isArray(cached.nodes) ? cached.nodes : [];
   const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
   if (!cachedNodes.length || !incomingNodes.length) return { ...cached, ...incoming };
+  const cachedUpdatedAt = Date.parse(readStringValue(cached.updatedAt, cached.updated_at) || "");
+  const incomingUpdatedAt = Date.parse(readStringValue(incoming.updatedAt, incoming.updated_at) || "");
+  const preserveCachedMembership = Number.isFinite(cachedUpdatedAt) && (!Number.isFinite(incomingUpdatedAt) || cachedUpdatedAt > incomingUpdatedAt);
   const cachedById = /* @__PURE__ */ new Map();
   for (const node of cachedNodes) {
     const nodeId = readInlineMeshNodeId(node);
@@ -24977,12 +25328,13 @@ function reconcileInlineMeshCache(cached, incoming) {
   const nodes = incomingNodes.map((incomingNode) => {
     const nodeId = readInlineMeshNodeId(incomingNode);
     const cachedNode = nodeId ? cachedById.get(nodeId) : void 0;
+    if (!cachedNode && preserveCachedMembership) return null;
     if (!cachedNode) return incomingNode;
     if (hasInlineMeshTransientNodeState(incomingNode)) {
       return { ...cachedNode, ...incomingNode };
     }
     return { ...stripInlineMeshTransientNodeState(cachedNode), ...incomingNode };
-  });
+  }).filter(Boolean);
   return {
     ...cached,
     ...incoming,
@@ -36485,6 +36837,8 @@ export {
   buildChatTailDeliverySignature,
   buildCoordinatorSystemPrompt,
   buildMachineInfo,
+  buildMeshActiveWork,
+  buildMeshActiveWorkSummary,
   buildMeshHostRequiredFailure,
   buildMeshLedgerReconciliationEvidence,
   buildMeshLedgerReplicaEvidence,
@@ -36495,6 +36849,7 @@ export {
   buildSessionModalDeliverySignature,
   buildStatusSnapshot,
   buildSystemChatMessage,
+  buildTaskCompletionEvidence,
   buildTerminalChatMessage,
   buildThoughtChatMessage,
   buildToolChatMessage,
@@ -36605,6 +36960,8 @@ export {
   normalizeInputEnvelope,
   normalizeManagedStatus,
   normalizeMeshDaemonRole,
+  normalizeMeshTaskMode,
+  normalizeMeshWorkerResult,
   normalizeMessageParts,
   normalizeRepoIdentity,
   normalizeSessionModalFields,
@@ -36660,6 +37017,7 @@ export {
   updateSessionTaskStatus,
   updateTaskStatus,
   upsertSavedProviderSession,
-  validateMeshRefineConfig
+  validateMeshRefineConfig,
+  validateMeshTaskModeRequest
 };
 //# sourceMappingURL=index.mjs.map