@adhdev/daemon-standalone 0.9.82-rc.58 → 0.9.82-rc.59

package/dist/index.js

@@ -23390,6 +23390,7 @@ Follow these recovery rules:
       getSessionRecoveryContext: () => getSessionRecoveryContext,
       isIntentionalCleanupStopEntry: () => isIntentionalCleanupStopEntry,
       meshLedgerEvents: () => meshLedgerEvents,
+      normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
       readLedgerEntries: () => readLedgerEntries,
       readLedgerSlice: () => readLedgerSlice
     });
@@ -23413,6 +23414,86 @@ Follow these recovery rules:
       const safe = meshId.replace(/[^a-zA-Z0-9_-]/g, "_");
       return (0, import_path4.join)(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;
@@ -23429,6 +23510,7 @@ Follow these recovery rules:
           providerSessionId,
           finalSummaryAvailable: typeof opts.finalSummary === "string" && opts.finalSummary.trim().length > 0
         },
+        workerResult: resolveWorkerResult(opts),
         git: {
           status: "deferred",
           reason: "ordinary_completion_git_status_not_checked"
@@ -23734,16 +23816,45 @@ Follow these recovery rules:
     __export2(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
     });
+    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 (0, import_path5.join)(getLedgerDir(), `${safe}.queue.json`);
@@ -23794,6 +23905,10 @@ Follow these recovery rules:
     }
     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 = {
@@ -23801,6 +23916,7 @@ Follow these recovery rules:
           meshId,
           message,
           status: "pending",
+          taskMode: modeValidation.taskMode,
           targetNodeId: opts?.targetNodeId,
           targetSessionId: opts?.targetSessionId,
           createdAt: (/* @__PURE__ */ new Date()).toISOString(),
@@ -23967,6 +24083,8 @@ Follow these recovery rules:
     var import_crypto5;
     var ACTIVE_MESH_QUEUE_STATUSES;
     var HISTORICAL_MESH_QUEUE_STATUSES;
+    var MESH_TASK_MODES;
+    var LIVE_DEBUG_READONLY_FORBIDDEN;
     var init_mesh_work_queue = __esm2({
       "src/mesh/mesh-work-queue.ts"() {
         "use strict";
@@ -23977,6 +24095,14 @@ Follow these recovery rules:
         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 }
+        ];
       }
     });
     function parseVersion(raw) {
@@ -24357,6 +24483,9 @@ Follow these recovery rules:
       triggerMeshQueue: () => triggerMeshQueue,
       tryAssignQueueTask: () => tryAssignQueueTask
     });
+    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) {
@@ -24422,23 +24551,26 @@ Follow these recovery rules:
       } 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 ? readNonEmptyString(completionDiagnostic.blockReason) || "present" : "";
+      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);
@@ -24482,7 +24614,7 @@ Follow these recovery rules:
       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,
@@ -24560,7 +24692,7 @@ Follow these recovery rules:
       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";
     }
@@ -24569,15 +24701,15 @@ Follow these recovery rules:
     }
     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 = loadConfig2();
-      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;
@@ -24600,10 +24732,10 @@ Follow these recovery rules:
       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;
     }
@@ -24695,7 +24827,7 @@ Follow these recovery rules:
           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;
@@ -24754,7 +24886,7 @@ Follow these recovery rules:
               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);
@@ -24781,13 +24913,13 @@ Follow these recovery rules:
       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);
         }
@@ -24849,7 +24981,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,
@@ -24870,10 +25002,10 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           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) {
           LOG2.info("MeshEvents", `Suppressed duplicate completion for mesh ${args.meshId} session ${eventSessionId}`);
@@ -24883,8 +25015,8 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       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
@@ -24898,8 +25030,11 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         }
       } 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 };
@@ -24914,15 +25049,17 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
                 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
                 })
               }
             });
@@ -24945,13 +25082,13 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         }
       } 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}`);
         }
@@ -24962,16 +25099,20 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       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,
@@ -24982,8 +25123,9 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
               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
             }
@@ -24999,10 +25141,10 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           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",
@@ -25058,7 +25200,7 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
           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 } : {}
@@ -25084,14 +25226,14 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
       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,
@@ -25099,41 +25241,41 @@ Do NOT retry on this node. Consider reassigning to a different node or asking th
         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, {
@@ -28332,6 +28474,8 @@ ${lastSnapshot}`;
       buildChatTailDeliverySignature: () => buildChatTailDeliverySignature,
       buildCoordinatorSystemPrompt: () => buildCoordinatorSystemPrompt,
       buildMachineInfo: () => buildMachineInfo2,
+      buildMeshActiveWork: () => buildMeshActiveWork,
+      buildMeshActiveWorkSummary: () => buildMeshActiveWorkSummary,
       buildMeshHostRequiredFailure: () => buildMeshHostRequiredFailure,
       buildMeshLedgerReconciliationEvidence: () => buildMeshLedgerReconciliationEvidence,
       buildMeshLedgerReplicaEvidence: () => buildMeshLedgerReplicaEvidence,
@@ -28342,6 +28486,7 @@ ${lastSnapshot}`;
       buildSessionModalDeliverySignature: () => buildSessionModalDeliverySignature,
       buildStatusSnapshot: () => buildStatusSnapshot2,
       buildSystemChatMessage: () => buildSystemChatMessage,
+      buildTaskCompletionEvidence: () => buildTaskCompletionEvidence,
       buildTerminalChatMessage: () => buildTerminalChatMessage,
       buildThoughtChatMessage: () => buildThoughtChatMessage,
       buildToolChatMessage: () => buildToolChatMessage,
@@ -28452,6 +28597,8 @@ ${lastSnapshot}`;
       normalizeInputEnvelope: () => normalizeInputEnvelope,
       normalizeManagedStatus: () => normalizeManagedStatus,
       normalizeMeshDaemonRole: () => normalizeMeshDaemonRole,
+      normalizeMeshTaskMode: () => normalizeMeshTaskMode,
+      normalizeMeshWorkerResult: () => normalizeMeshWorkerResult,
       normalizeMessageParts: () => normalizeMessageParts,
       normalizeRepoIdentity: () => normalizeRepoIdentity,
       normalizeSessionModalFields: () => normalizeSessionModalFields,
@@ -28507,7 +28654,8 @@ ${lastSnapshot}`;
       updateSessionTaskStatus: () => updateSessionTaskStatus,
       updateTaskStatus: () => updateTaskStatus,
       upsertSavedProviderSession: () => upsertSavedProviderSession,
-      validateMeshRefineConfig: () => validateMeshRefineConfig
+      validateMeshRefineConfig: () => validateMeshRefineConfig,
+      validateMeshTaskModeRequest: () => validateMeshTaskModeRequest
     });
     module2.exports = __toCommonJS2(index_exports);
     init_repo_mesh_types();
@@ -30896,6 +31044,148 @@ ${lastSnapshot}`;
       };
     }
     init_mesh_work_queue();
+    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) };
+    }
     init_mesh_host_ownership();
     init_mesh_events();
     var NO_FALLBACK_REASON = "Repo Mesh command/data-plane is P2P-only; WS/REST command fallback is intentionally disabled to preserve the transport boundary.";
@@ -47251,6 +47541,9 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       const cachedNodes = Array.isArray(cached2.nodes) ? cached2.nodes : [];
       const incomingNodes = Array.isArray(incoming.nodes) ? incoming.nodes : [];
       if (!cachedNodes.length || !incomingNodes.length) return { ...cached2, ...incoming };
+      const cachedUpdatedAt = Date.parse(readStringValue(cached2.updatedAt, cached2.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);
@@ -47259,12 +47552,13 @@ ${(0, import_node_path.resolve)(workspace || os17.tmpdir())}`;
       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 {
         ...cached2,
         ...incoming,