@adhdev/daemon-standalone 1.0.28-rc.23 → 1.0.28-rc.25

package/dist/index.js

@@ -33311,10 +33311,10 @@ var require_dist3 = __commonJS({
     }
     function getDaemonBuildInfo() {
       if (cached2) return cached2;
-      const commit = readInjected(true ? "f130ad6e97683f23cd08e4296336ac70774146cf" : void 0) ?? "unknown";
-      const commitShort = readInjected(true ? "f130ad6e" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
-      const version2 = readInjected(true ? "1.0.28-rc.23" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
-      const builtAt = readInjected(true ? "2026-07-29T03:34:37.130Z" : void 0);
+      const commit = readInjected(true ? "ebb85401b79dca73fefef3c6d25259dd39a4f894" : void 0) ?? "unknown";
+      const commitShort = readInjected(true ? "ebb85401" : void 0) ?? (commit !== "unknown" ? commit.slice(0, 7) : "unknown");
+      const version2 = readInjected(true ? "1.0.28-rc.25" : void 0) ?? readInjected(typeof process !== "undefined" ? process.env?.ADHDEV_PKG_VERSION : void 0) ?? "unknown";
+      const builtAt = readInjected(true ? "2026-07-29T12:45:19.679Z" : void 0);
       cached2 = builtAt ? { commit, commitShort, version: version2, builtAt } : { commit, commitShort, version: version2 };
       return cached2;
     }
@@ -36902,16 +36902,31 @@ ${error48.message || ""}`;
       } catch {
       }
     }
+    function sizeRotationPath(logFile, generation) {
+      return logFile.replace(/\.log$/, `.${generation}.log`);
+    }
+    function rotateSizeGenerations(logFile, maxGenerations = MAX_SIZE_ROTATION_GENERATIONS) {
+      if (maxGenerations < 1) return;
+      const oldest = sizeRotationPath(logFile, maxGenerations);
+      try {
+        fs32.unlinkSync(oldest);
+      } catch {
+      }
+      for (let generation = maxGenerations - 1; generation >= 1; generation--) {
+        const source = sizeRotationPath(logFile, generation);
+        const destination = sizeRotationPath(logFile, generation + 1);
+        try {
+          fs32.renameSync(source, destination);
+        } catch {
+        }
+      }
+      fs32.renameSync(logFile, sizeRotationPath(logFile, 1));
+    }
     function rotateSizeIfNeeded() {
       try {
         const stat2 = fs32.statSync(currentLogFile);
         if (stat2.size > MAX_LOG_SIZE) {
-          const backup = currentLogFile.replace(".log", ".1.log");
-          try {
-            fs32.unlinkSync(backup);
-          } catch {
-          }
-          fs32.renameSync(currentLogFile, backup);
+          rotateSizeGenerations(currentLogFile);
         }
       } catch {
       }
@@ -37020,6 +37035,7 @@ ${error48.message || ""}`;
     var LOG_DIR;
     var MAX_LOG_SIZE;
     var MAX_LOG_DAYS;
+    var MAX_SIZE_ROTATION_GENERATIONS;
     var currentDate;
     var currentLogFile;
     var writeCount;
@@ -37045,6 +37061,7 @@ ${error48.message || ""}`;
         LOG_DIR = path9.join(ADHDEV_HOME, "logs");
         MAX_LOG_SIZE = 5 * 1024 * 1024;
         MAX_LOG_DAYS = 7;
+        MAX_SIZE_ROTATION_GENERATIONS = 3;
         try {
           fs32.mkdirSync(LOG_DIR, { recursive: true });
         } catch {
@@ -48671,6 +48688,9 @@ ${rendered}`, "utf-8");
         state: "connected",
         transport: transport && transport !== "unknown" ? transport : "direct",
         reported: true,
+        directPeerTruthSatisfied: true,
+        authority: "live_peer",
+        cached: false,
         reason: "Live peer git snapshot reported by the selected coordinator.",
         lastStateChangeAt: readStringValue(connection.lastStateChangeAt) ?? timestamp2
       };
@@ -49344,6 +49364,7 @@ ${rendered}`, "utf-8");
       const now = args.now ?? Date.now;
       const connection = readObjectRecord(status.connection);
       const connectionState = readStringValue(connection.state);
+      const directPeerTruthSatisfied = readBooleanValue(connection.directPeerTruthSatisfied);
       const git = readObjectRecord(status.git);
       const hasGit = readBooleanValue(git.isGitRepo) === true || !!readStringValue(git.branch, git.headCommit, git.head, git.upstream);
       const connectionFreshAt = toIsoTimestamp(connection.lastCommandAt ?? connection.lastConnectedAt ?? connection.lastStateChangeAt);
@@ -49365,12 +49386,12 @@ ${rendered}`, "utf-8");
       } else if (readBooleanValue(status.gitProbePending) === true) {
         dataSource = "pending";
         reachable = connectionReachable;
+      } else if (hasGit) {
+        dataSource = "cached";
+        reachable = directTruthUnavailable ? false : connectionReachable;
       } else if (directTruthUnavailable) {
         dataSource = "unreachable";
         reachable = false;
-      } else if (hasGit) {
-        dataSource = "cached";
-        reachable = connectionReachable;
       } else if (!daemonId) {
         dataSource = "unconfigured";
         reachable = null;
@@ -49392,6 +49413,8 @@ ${rendered}`, "utf-8");
         dataSource,
         probeOk,
         reachable,
+        directPeerTruthSatisfied: isSelfNode || liveTruthProbed ? true : directPeerTruthSatisfied ?? false,
+        projection: dataSource === "cached" ? "cached" : "live_or_absent",
         lastProbeAt: lastProbeAt ?? null,
         ageMs: ageMs2,
         staleness
@@ -67877,6 +67900,7 @@ ${lastSnapshot}`;
       MAGI_NEEDS_VERIFICATION_PREVIEW_CAP: () => MAGI_NEEDS_VERIFICATION_PREVIEW_CAP,
       MAGI_RAW_ANSWER_CAP: () => MAGI_RAW_ANSWER_CAP,
       MAX_LEDGER_SLICE_LIMIT: () => MAX_LEDGER_SLICE_LIMIT,
+      MAX_SIZE_ROTATION_GENERATIONS: () => MAX_SIZE_ROTATION_GENERATIONS,
       MESH_CONVERGE_FAST_FORWARD_TAG: () => MESH_CONVERGE_FAST_FORWARD_TAG,
       MESH_CONVERGE_REFINE_TAG: () => MESH_CONVERGE_REFINE_TAG,
       MESH_JSON_CONFIG_LOCATIONS: () => MESH_JSON_CONFIG_LOCATIONS,
@@ -69800,10 +69824,57 @@ ${lastSnapshot}`;
       }
       return String(error48 || "mesh relay command failed");
     }
+    function readStructuredFailure(error48) {
+      if (!error48 || typeof error48 !== "object") return {};
+      const value = error48;
+      return {
+        ...typeof value.code === "string" ? { code: value.code } : {},
+        ...typeof value.reason === "string" ? { reason: value.reason } : {},
+        ...value.transport === "p2p" || value.transport === "unknown" ? { transport: value.transport } : {},
+        ...typeof value.recoverable === "boolean" ? { recoverable: value.recoverable } : {},
+        ...typeof value.retryRecommended === "boolean" ? { retryRecommended: value.retryRecommended } : {},
+        ...typeof value.nextAction === "string" ? { nextAction: value.nextAction } : {},
+        ...typeof value.noFallbackReason === "string" ? { noFallbackReason: value.noFallbackReason } : {},
+        ...typeof value.meshCode === "string" ? { meshCode: value.meshCode } : {},
+        ...typeof value.connectionState === "string" ? { connectionState: value.connectionState } : {},
+        ...typeof value.nextRetryAt === "string" ? { nextRetryAt: value.nextRetryAt } : {},
+        ...typeof value.authEpoch === "number" ? { authEpoch: value.authEpoch } : {}
+      };
+    }
+    function reasonForCode(code) {
+      switch (code) {
+        case "p2p_timeout":
+          return "daemon_mesh_p2p_timeout";
+        case "p2p_not_connected":
+          return "daemon_mesh_p2p_not_connected";
+        case "p2p_datachannel_closed":
+          return "daemon_mesh_p2p_datachannel_closed";
+        case "p2p_no_route":
+          return "daemon_mesh_p2p_no_route";
+        case "p2p_daemon_offline":
+          return "daemon_mesh_target_offline";
+        case "p2p_unavailable":
+          return "daemon_mesh_p2p_transport_unavailable";
+        case "mesh_logic_or_provider_failure":
+          return "mesh_logic_or_provider_failure";
+      }
+    }
     function classifyP2pRelayFailure(error48, _context = {}) {
       const message = messageFromError(error48);
       const lower = message.toLowerCase();
-      const hasP2pSignal = /p2p|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
+      const structured = readStructuredFailure(error48);
+      if (structured.code && structured.code !== "mesh_logic_or_provider_failure" && structured.transport === "p2p") {
+        return {
+          code: structured.code,
+          reason: structured.reason || reasonForCode(structured.code),
+          transport: "p2p",
+          recoverable: structured.recoverable ?? true,
+          retryRecommended: structured.retryRecommended ?? true,
+          nextAction: structured.nextAction || P2P_NEXT_ACTION,
+          noFallbackReason: structured.noFallbackReason || NO_FALLBACK_REASON
+        };
+      }
+      const hasP2pSignal = /p2p|peer|datachannel|node-datachannel|webrtc|ice|mesh_relay_command|daemon_mesh_p2p_transport/i.test(message);
       const hasFailureSignal = /unavailable|missing|failed|failure|timeout|timed out|not connected|closed|disconnected|offline|no route|route unavailable|cannot send|cannot establish/i.test(message);
       if (/requires targetdaemonid and command|providerpriority|no inference provider|permission denied|read-only|not a member/i.test(message)) {
         return {
@@ -69830,7 +69901,7 @@ ${lastSnapshot}`;
       } else if (/closed|disconnected/i.test(message) && (hasP2pSignal || /state changed/i.test(message))) {
         code = "p2p_datachannel_closed";
         reason = "daemon_mesh_p2p_datachannel_closed";
-      } else if (/not connected|cannot send|cannot establish/i.test(message) && hasP2pSignal) {
+      } else if (/not connected|cannot send|cannot establish|probe gave up/i.test(message) && hasP2pSignal) {
         code = "p2p_not_connected";
         reason = "daemon_mesh_p2p_not_connected";
       } else if (hasP2pSignal && hasFailureSignal) {
@@ -69863,12 +69934,17 @@ ${lastSnapshot}`;
     }
     function buildP2pRelayFailurePayload(error48, context = {}) {
       const classification = classifyP2pRelayFailure(error48, context);
+      const structured = readStructuredFailure(error48);
       return {
         success: false,
         ...classification,
         error: messageFromError(error48),
         ...context.command ? { command: context.command } : {},
-        ...context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {}
+        ...context.targetDaemonId ? { targetDaemonId: context.targetDaemonId } : {},
+        ...context.meshCode || structured.meshCode ? { meshCode: context.meshCode || structured.meshCode } : {},
+        ...context.connectionState || structured.connectionState ? { connectionState: context.connectionState || structured.connectionState } : {},
+        ...context.nextRetryAt || structured.nextRetryAt ? { nextRetryAt: context.nextRetryAt || structured.nextRetryAt } : {},
+        ...(context.authEpoch ?? structured.authEpoch) !== void 0 ? { authEpoch: context.authEpoch ?? structured.authEpoch } : {}
       };
     }
     var P2pRelayFailureError = class extends Error {
@@ -69881,19 +69957,37 @@ ${lastSnapshot}`;
       noFallbackReason;
       command;
       targetDaemonId;
+      meshCode;
+      connectionState;
+      nextRetryAt;
+      authEpoch;
       constructor(message, context = {}) {
         super(message);
         this.name = "P2pRelayFailureError";
-        const payload = buildP2pRelayFailurePayload(message, context);
-        this.code = payload.code;
+        const payload = buildP2pRelayFailurePayload({
+          message,
+          ...context.code ? { code: context.code } : {},
+          ...context.recoverable !== void 0 ? { recoverable: context.recoverable } : {},
+          ...context.retryRecommended !== void 0 ? { retryRecommended: context.retryRecommended } : {},
+          transport: context.code ? "p2p" : void 0,
+          meshCode: context.meshCode,
+          connectionState: context.connectionState,
+          nextRetryAt: context.nextRetryAt,
+          authEpoch: context.authEpoch
+        }, context);
+        this.code = context.code ?? payload.code;
         this.reason = payload.reason;
         this.transport = payload.transport;
-        this.recoverable = payload.recoverable;
-        this.retryRecommended = payload.retryRecommended;
+        this.recoverable = context.recoverable ?? payload.recoverable;
+        this.retryRecommended = context.retryRecommended ?? payload.retryRecommended;
         this.nextAction = payload.nextAction;
         this.noFallbackReason = payload.noFallbackReason;
         this.command = context.command;
         this.targetDaemonId = context.targetDaemonId;
+        this.meshCode = context.meshCode;
+        this.connectionState = context.connectionState;
+        this.nextRetryAt = context.nextRetryAt;
+        this.authEpoch = context.authEpoch;
       }
     };
     init_state_store();
@@ -81195,6 +81289,12 @@ ${body}
       }
       return getCurrentDaemonLogPath();
     }
+    function sizeRotationPaths(primaryPath) {
+      return Array.from(
+        { length: MAX_SIZE_ROTATION_GENERATIONS },
+        (_, index) => primaryPath.replace(/\.log$/, `.${index + 1}.log`)
+      );
+    }
     function clampTailBytes(tailBytes) {
       if (!Number.isFinite(tailBytes) || tailBytes <= 0) return DEFAULT_TAIL_BYTES;
       return Math.min(Math.floor(tailBytes), MAX_TAIL_BYTES);
@@ -81303,17 +81403,17 @@ ${body}
       const platform10 = process.platform;
       const limitBytes = clampTailBytes(args.tailBytes);
       const primaryPath = resolveLogPath(args.date);
-      const backupPath = primaryPath.replace(/\.log$/, ".1.log");
+      const backupPaths = sizeRotationPaths(primaryPath);
       const primaryExists = fs16.existsSync(primaryPath);
-      const backupExists = fs16.existsSync(backupPath);
-      if (!primaryExists && !backupExists) {
+      const existingBackupPaths = backupPaths.filter((backupPath) => fs16.existsSync(backupPath));
+      if (!primaryExists && existingBackupPaths.length === 0) {
         return errorResult(
           `No daemon log file at ${primaryPath} (dir: ${getDaemonLogDir()})`,
           primaryPath,
           platform10
         );
       }
-      const logPath = primaryExists ? primaryPath : backupPath;
+      const logPath = primaryExists ? primaryPath : existingBackupPaths[0];
       const hasGrep = typeof args.grep === "string" && args.grep.trim().length > 0;
       const hasSince = Number.isFinite(args.sinceMs);
       const filterMode = hasGrep || hasSince;
@@ -81342,7 +81442,7 @@ ${body}
       let scannedBytes = 0;
       let allLines = [];
       try {
-        for (const p of [backupExists ? backupPath : null, primaryExists ? primaryPath : null]) {
+        for (const p of [...existingBackupPaths].reverse().concat(primaryExists ? [primaryPath] : [])) {
           if (!p) continue;
           const buf = fs16.readFileSync(p);
           scannedBytes += buf.length;
@@ -87520,6 +87620,11 @@ ${body}
         const finalAssistantEvidence = this.completionFinalAssistantEvidence(parsed?.messages, pending.turnStartedAt);
         const allowMissingAssistantTimeout = !!(this.settings.meshNodeFor || this.settings.meshActiveTaskId || this.settings.launchedByCoordinator);
         LOG2.debug("CLI", `[${this.type}] finalAssistantEvidence: present=${finalAssistantEvidence.present} source=${finalAssistantEvidence.source} adapterOwnsMessagesElsewhere=${adapterOwnsMessagesElsewhere} parsedStatus=${parsedStatus}`);
+        if (finalAssistantEvidence.present && finalAssistantEvidence.source !== "unavailable") {
+          pending.resolvedFinalMessages = Array.isArray(finalAssistantEvidence.messages) ? finalAssistantEvidence.messages : void 0;
+        } else {
+          pending.resolvedFinalMessages = void 0;
+        }
         if (!finalAssistantEvidence.present) {
           if (adapterOwnsMessagesElsewhere) {
             if (finalAssistantEvidence.source === "external-native") {
@@ -88479,13 +88584,35 @@ ${body}
           duration: pending.duration,
           timestamp: pending.timestamp,
           taskId: pending.taskId,
-          finalSummary: this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt)
+          finalSummary: this.cleanCompletionFinalSummary(pending)
         });
         this.completedDebouncePending = null;
         this.completedDebounceTimer = null;
         this.generatingStartedAt = 0;
         this.lastApprovalEventFingerprint = "";
       }
+      /**
+       * EMPTY-FINAL-CONTENT (kimi native-source TOCTOU): finalSummary for the CLEAN
+       * finalization path (getCompletedFinalizationBlock returned null — the turn is already
+       * proven done). Prefer extracting the summary from pending.resolvedFinalMessages, the
+       * EXACT message snapshot completionFinalAssistantEvidence just proved `present:true`
+       * from, instead of taking a brand-new independent read
+       * (adapter.getScriptParsedStatus() / a fresh readExternalCompletionMessages() inside
+       * completionFinalSummary). A native-source provider's on-disk transcript can be
+       * rewritten/truncated between the two reads, and a PTY-buffer scrape can lose the
+       * matched bubble to a repaint/scroll — either race can turn a proven-present turn into
+       * an emitted completion with an empty assistant bubble. Falls back to the live
+       * (pre-fix) read when no snapshot was cached (e.g. a code path that reaches the clean
+       * emit without going through getCompletedFinalizationBlock first), so no other provider
+       * class's behavior changes.
+       */
+      cleanCompletionFinalSummary(pending) {
+        if (Array.isArray(pending.resolvedFinalMessages)) {
+          const fromSnapshot = extractFinalSummaryFromMessagesAfter(pending.resolvedFinalMessages, pending.turnStartedAt);
+          if (fromSnapshot) return fromSnapshot;
+        }
+        return this.completionFinalSummary(this.adapter?.getScriptParsedStatus()?.messages, pending.turnStartedAt);
+      }
       /**
        * A-3 (CLI 완료판정 통합): single authoritative emit for a CLI turn's
        * `agent:generating_completed` event. The completion JUDGMENT — WHETHER and
@@ -101105,6 +101232,7 @@ ${ptyResult.output.slice(-2e3)}`);
             finalizeMeshNodeStatus({ status: fallback, node, daemonId, isSelfNode: false, directTruthUnavailable: directTruthUnavailableNodeIds.has(nodeId) });
             return fallback;
           });
+          const cachedProjectionNodeIds = nodeStatuses.filter((status) => status?.dataFreshness?.projection === "cached" && status?.dataFreshness?.directPeerTruthSatisfied === false).map((status) => readStringValue(status?.nodeId)).filter(Boolean);
           const callerCoordinatorDaemonId = typeof args?.coordinatorDaemonId === "string" && args.coordinatorDaemonId.trim() ? args.coordinatorDaemonId.trim() : ctx.deps.statusInstanceId || void 0;
           const pendingCoordinatorEvents = getPendingMeshCoordinatorEvents(meshId, callerCoordinatorDaemonId);
           const unroutableDeliveries = getRecentUnroutableDeliveries();
@@ -101165,7 +101293,8 @@ ${ptyResult.output.slice(-2e3)}`);
                   peerAttemptedCount: effectiveDirectTruth.peerAttemptedCount,
                   peerConfirmedCount: effectiveDirectTruth.peerConfirmedCount,
                   unavailableNodeIds: effectiveDirectTruth.unavailableNodeIds,
-                  partialNodeFailures: effectiveDirectTruth.unavailableNodeIds
+                  partialNodeFailures: effectiveDirectTruth.unavailableNodeIds,
+                  cachedProjectionNodeIds
                 }
               } : {},
               historicalEvidenceOnly: ["recoveryHints", "ledger.summary", "queue.summary", "historicalSessions"]