@botiverse/raft-daemon 0.72.8 → 0.72.12

package/dist/{chunk-FNFNAY5B.js → chunk-LHJUHF42.js}

@@ -4032,6 +4032,55 @@ var CANONICAL_MESSAGE_MANIFEST = Object.freeze({
   excludedClientOnly: EXCLUDED_CLIENT_ONLY_MESSAGE_FIELDS
 });
 
+// ../shared/src/canonicalMessageV2.ts
+var CANONICAL_MESSAGE_V2_SCHEMA_VERSION = 5;
+var CANONICAL_MESSAGE_V2_ENVELOPE_KIND = "normalized-message-v2";
+var CANONICAL_REACTION_PREVIEW_LIMIT = 3;
+var CANONICAL_REACTION_LIMIT = 30;
+var CANONICAL_MESSAGE_V2_MANIFEST = Object.freeze({
+  schemaVersion: CANONICAL_MESSAGE_V2_SCHEMA_VERSION,
+  envelopeKind: CANONICAL_MESSAGE_V2_ENVELOPE_KIND,
+  legacyIngressManifestVersion: CANONICAL_MESSAGE_MANIFEST_VERSION,
+  soleApplyEligible: true,
+  reactions: Object.freeze({
+    mergePolicy: "present-overwrite",
+    maxItems: CANONICAL_REACTION_LIMIT,
+    fields: Object.freeze(["count", "emoji", "previewK"]),
+    previewFields: Object.freeze(["displayName", "id"]),
+    previewLimit: CANONICAL_REACTION_PREVIEW_LIMIT,
+    legacyCompatibilityPreviewPolicy: "empty-without-room-common-provenance",
+    deterministicOrder: "emoji-code-unit/actor-id-code-unit"
+  }),
+  viewerOverlayFields: Object.freeze(["reactions.reactedByMe"]),
+  readCacheRelations: Object.freeze(["Message.ReactionActors"]),
+  forbiddenCanonicalPaths: Object.freeze([
+    "reactions[].reactorIds",
+    "reactions[].reactorNames"
+  ])
+});
+
+// ../shared/src/discussionGraph.ts
+var DISCUSSION_RELATION_REGISTRY = Object.freeze({
+  messageReactionActors: Object.freeze({
+    rootKind: "message",
+    relation: "reaction-actors",
+    backing: "read-cache",
+    consistency: "read-page",
+    provenance: Object.freeze({ count: "shared-parent-fold", previewK: "shared-parent-fold" }),
+    invalidation: "parent-scope-epoch",
+    allowedCommands: Object.freeze(["set-interaction"])
+  }),
+  messageReplies: Object.freeze({
+    rootKind: "message",
+    relation: "replies",
+    backing: "sync-scope",
+    consistency: "sync-scope-window",
+    provenance: Object.freeze({ replyCount: "shared-parent-fold" }),
+    invalidation: "own-scope-rebaseline",
+    allowedCommands: Object.freeze(["reply"])
+  })
+});
+
 // ../shared/src/index.ts
 var COMPUTER_CAPABILITY_SUPERVISOR_MUTATIONS = "computer:supervisor-mutations-v1";
 var RUNTIME_CONFIG_VERSION = 1;
@@ -4558,7 +4607,7 @@ var TRIAL_DURATION_DAYS = (TRIAL_END_DATE.getTime() - TRIAL_START_DATE.getTime()
 
 // src/agentProcessManager.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync, writeFileSync as writeFileSync4 } from "fs";
-import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2, lstat, realpath, open } from "fs/promises";
+import { readdir as readdir2, stat as stat2, readFile, rm as rm2, lstat, realpath, open } from "fs/promises";
 import { createHash as createHash3, randomUUID as randomUUID6 } from "crypto";
 import path14 from "path";
 import { gzipSync } from "zlib";
@@ -4566,8 +4615,9 @@ import os6 from "os";
 
 // src/proxy.ts
 import { HttpsProxyAgent } from "https-proxy-agent";
-import { ProxyAgent } from "undici";
+import { Agent, ProxyAgent } from "undici";
 var fetchDispatcherCache = /* @__PURE__ */ new Map();
+var isolatedFetchDispatcherCache = /* @__PURE__ */ new Map();
 function getFetchPreResponseTimeoutMs(env) {
   const parsed = Number.parseInt(env.SLOCK_DAEMON_FETCH_PRE_RESPONSE_TIMEOUT_MS || "", 10);
   return Number.isFinite(parsed) && parsed > 0 ? parsed : 3e4;
@@ -4632,32 +4682,60 @@ function resolveProxyUrl(targetUrl, env) {
   if (shouldBypassProxy(targetUrl, env)) return void 0;
   return proxyUrl;
 }
+function createProxyDispatcher(proxyUrl, timeoutMs) {
+  return new ProxyAgent({
+    uri: proxyUrl,
+    connect: { timeout: timeoutMs },
+    requestTls: { timeout: timeoutMs },
+    headersTimeout: timeoutMs
+  });
+}
+function closeDispatcherBestEffort(dispatcher) {
+  void Promise.resolve().then(() => dispatcher.close()).catch(() => dispatcher.destroy?.(new Error("evicted"))).catch(() => {
+  });
+}
 function buildFetchDispatcher(targetUrl, env) {
   const proxyUrl = resolveProxyUrl(targetUrl, env);
   if (!proxyUrl) return void 0;
   const cached = fetchDispatcherCache.get(proxyUrl);
   if (cached) return cached;
   const timeoutMs = getFetchPreResponseTimeoutMs(env);
-  const dispatcher = new ProxyAgent({
-    uri: proxyUrl,
-    // All three are pre-response and body-agnostic (see getFetchPreResponseTimeoutMs):
-    // headersTimeout = headers-hang leg; requestTls.timeout = CONNECT-tunnel
-    // establish leg; connect.timeout = socket to the proxy itself (defensive).
+  const dispatcher = createProxyDispatcher(proxyUrl, timeoutMs);
+  fetchDispatcherCache.set(proxyUrl, dispatcher);
+  return dispatcher;
+}
+function getIsolatedDispatcherCacheKey(targetUrl, isolationKey, env) {
+  const proxyUrl = resolveProxyUrl(targetUrl, env);
+  const routeKey = proxyUrl ? `proxy:${proxyUrl}` : `direct:${new URL(targetUrl).origin}`;
+  return { cacheKey: `${isolationKey}\0${routeKey}`, proxyUrl };
+}
+function buildIsolatedFetchDispatcher(targetUrl, isolationKey, env) {
+  const { cacheKey, proxyUrl } = getIsolatedDispatcherCacheKey(targetUrl, isolationKey, env);
+  const cached = isolatedFetchDispatcherCache.get(cacheKey);
+  if (cached) return cached;
+  const timeoutMs = getFetchPreResponseTimeoutMs(env);
+  const dispatcher = proxyUrl ? createProxyDispatcher(proxyUrl, timeoutMs) : new Agent({
     connect: { timeout: timeoutMs },
-    requestTls: { timeout: timeoutMs },
     headersTimeout: timeoutMs
   });
-  fetchDispatcherCache.set(proxyUrl, dispatcher);
+  isolatedFetchDispatcherCache.set(cacheKey, dispatcher);
   return dispatcher;
 }
+function evictIsolatedFetchDispatcher(targetUrl, isolationKey, env) {
+  const { cacheKey } = getIsolatedDispatcherCacheKey(targetUrl, isolationKey, env);
+  const cached = isolatedFetchDispatcherCache.get(cacheKey);
+  if (!cached) return false;
+  isolatedFetchDispatcherCache.delete(cacheKey);
+  closeDispatcherBestEffort(cached);
+  return true;
+}
 function evictFetchDispatcher(targetUrl, env) {
   const proxyUrl = resolveProxyUrl(targetUrl, env);
   if (!proxyUrl) return false;
   const cached = fetchDispatcherCache.get(proxyUrl);
   if (!cached) return false;
   fetchDispatcherCache.delete(proxyUrl);
-  void Promise.resolve().then(() => cached.close()).catch(() => cached.destroy?.(new Error("evicted"))).catch(() => {
-  });
+  closeDispatcherBestEffort(cached);
   return true;
 }
 
@@ -4666,11 +4744,17 @@ function withDaemonFetchProxy(input, init = {}, env = process.env) {
   const dispatcher = buildFetchDispatcher(input.toString(), env);
   return dispatcher ? { ...init, dispatcher } : init;
 }
-async function daemonFetch(input, init, env = process.env) {
+async function daemonFetch(input, init, env = process.env, options = {}) {
+  const targetUrl = input.toString();
+  const fetchInit = options.isolationKey ? { ...init, dispatcher: buildIsolatedFetchDispatcher(targetUrl, options.isolationKey, env) } : withDaemonFetchProxy(input, init, env);
   try {
-    return await fetch(input, withDaemonFetchProxy(input, init, env));
+    return await fetch(input, fetchInit);
   } catch (err) {
-    evictFetchDispatcher(input.toString(), env);
+    if (options.isolationKey) {
+      evictIsolatedFetchDispatcher(targetUrl, options.isolationKey, env);
+    } else {
+      evictFetchDispatcher(targetUrl, env);
+    }
     throw err;
   }
 }
@@ -6499,6 +6583,7 @@ var HOP_BY_HOP_REQUEST_HEADERS = /* @__PURE__ */ new Set([
 var LOCAL_HELD_CONTEXT_LIMIT = 3;
 var AGENT_CREDENTIAL_PROXY_HOST = "127.0.0.1";
 var AGENT_CREDENTIAL_PROXY_BIND_MAX_ATTEMPTS = 3;
+var AGENT_CREDENTIAL_PROXY_FETCH_ISOLATION_KEY = "agent-credential-proxy";
 function createProxyRequestHandler() {
   return (req, res) => {
     void handleProxyRequest(req, res);
@@ -6653,11 +6738,16 @@ async function handleProxyRequest(req, res) {
       headers.set("content-type", "application/json");
       headers.delete("content-length");
     }
-    const upstream = await daemonFetch(target, {
-      method,
-      headers,
-      body
-    });
+    const upstream = await daemonFetch(
+      target,
+      {
+        method,
+        headers,
+        body
+      },
+      process.env,
+      { isolationKey: AGENT_CREDENTIAL_PROXY_FETCH_ISOLATION_KEY }
+    );
     if (upstream.status >= 500) {
       const transportError = transportNormalizedErrorForHttpStatus(target, upstream.status, registration.launchId);
       logger.warn(
@@ -11731,7 +11821,11 @@ function buildBuiltInAgentDir(workingDirectory) {
 async function buildPiSpawnEnv(ctx) {
   return (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
 }
-function seedBuiltInAuthStorage(authStorage, runtimeConfig) {
+function seedPiSessionAuthStorage(authStorage, runtimeConfig) {
+  if (runtimeConfig.runtime === "pi" && runtimeConfig.provider?.kind === "pi-builtin") {
+    authStorage.setRuntimeApiKey(runtimeConfig.provider.providerId, runtimeConfig.provider.apiKey);
+    return;
+  }
   if (runtimeConfig.runtime !== "builtin") return;
   if (runtimeConfig.provider.kind === "preset") {
     authStorage.setRuntimeApiKey(runtimeConfig.provider.providerId, runtimeConfig.provider.apiKey);
@@ -11744,11 +11838,12 @@ function seedBuiltInAuthStorage(authStorage, runtimeConfig) {
   }
 }
 function buildPiSessionCreateEnvPatch(runtimeConfig, envVars) {
-  if (runtimeConfig.runtime !== "builtin" || !envVars) return envVars;
-  const providerApiKeyEnvNames = /* @__PURE__ */ new Set([
+  if (!envVars) return null;
+  const providerApiKeyEnvNames = runtimeConfig.runtime === "builtin" ? /* @__PURE__ */ new Set([
     ...Object.values(BUILTIN_RUNTIME_PROVIDER_ENV_KEYS),
     ...Object.values(BUILTIN_RUNTIME_GATEWAY_PROVIDER_ENV_KEYS)
-  ]);
+  ]) : runtimeConfig.runtime === "pi" && runtimeConfig.provider?.kind === "pi-builtin" ? /* @__PURE__ */ new Set([PI_BUILTIN_PROVIDER_ENV_KEYS[runtimeConfig.provider.providerId]]) : /* @__PURE__ */ new Set();
+  if (providerApiKeyEnvNames.size === 0) return envVars;
   const filtered = Object.fromEntries(
     Object.entries(envVars).filter(([key]) => !providerApiKeyEnvNames.has(key))
   );
@@ -12106,7 +12201,7 @@ async function createPiAgentSessionForContext(ctx, sessionId, opts = {}) {
     const agentDir = opts.agentDir ?? spawnEnv.PI_CODING_AGENT_DIR ?? getAgentDir();
     mkdirSync3(agentDir, { recursive: true });
     const authStorage = AuthStorage.create(path12.join(agentDir, "auth.json"));
-    seedBuiltInAuthStorage(authStorage, runtimeConfig);
+    seedPiSessionAuthStorage(authStorage, runtimeConfig);
     const settingsManager = SettingsManager.create(ctx.workingDirectory, agentDir);
     const providerEnvScope = opts.isolateHostProviderEnv ? BUILTIN_BLOCKED_HOST_PROVIDER_ENV_KEYS : void 0;
     const sessionCreateEnvPatch = buildPiSessionCreateEnvPatch(runtimeConfig, launchRuntimeFields.envVars);
@@ -12229,22 +12324,17 @@ async function createPiAgentSessionForContext(ctx, sessionId, opts = {}) {
     throw error;
   }
 }
+var piPromptsInFlight = 0;
 var PiSdkRuntimeSession = class {
-  constructor(ctx, setCurrentSessionId, sessionFactory = createPiAgentSessionForContext, opts = {}) {
+  constructor(ctx, setCurrentSessionId, sessionFactory = createPiAgentSessionForContext) {
     this.ctx = ctx;
     this.setCurrentSessionId = setCurrentSessionId;
     this.sessionFactory = sessionFactory;
     this.mappingState = createPiSdkEventMappingState(ctx.config.sessionId || null);
-    const runtimeConfig = hydrateRuntimeConfig(ctx.config);
-    const launchRuntimeFields = runtimeConfigToLaunchFields(runtimeConfig);
-    this.sdkCallEnvPatch = buildPiSessionCreateEnvPatch(runtimeConfig, launchRuntimeFields.envVars);
-    this.sdkCallEnvRemoveFirst = opts.isolateHostProviderEnv ? BUILTIN_BLOCKED_HOST_PROVIDER_ENV_KEYS : void 0;
   }
   descriptor = PI_RUNTIME_SESSION_DESCRIPTOR;
   events = new EventEmitter2();
   mappingState;
-  sdkCallEnvPatch;
-  sdkCallEnvRemoveFirst;
   session = null;
   unsubscribe = null;
   started = false;
@@ -12377,10 +12467,41 @@ var PiSdkRuntimeSession = class {
     return !this.didClose && this.session === session && !session.isStreaming;
   }
   deferSdkCall(invoke) {
+    const queuedAt = currentTimeMs();
     setImmediate(() => {
       if (this.didClose) return;
+      const span = this.ctx.tracer?.startSpan("daemon.pi.prompt", {
+        surface: "daemon",
+        kind: "internal",
+        attrs: {
+          agentId: this.ctx.agentId,
+          launchId: this.ctx.launchId || void 0,
+          runtime: this.ctx.config.runtime
+        }
+      });
+      const startedAt = currentTimeMs();
+      piPromptsInFlight += 1;
+      span?.addEvent("daemon.pi.prompt.start", {
+        agentId: this.ctx.agentId,
+        queued_ms: startedAt - queuedAt,
+        prompts_in_flight: piPromptsInFlight
+      });
+      let settled = false;
+      const settle = (status) => {
+        if (settled) return;
+        settled = true;
+        piPromptsInFlight -= 1;
+        span?.end(status, {
+          attrs: {
+            queued_ms: startedAt - queuedAt,
+            duration_ms: currentTimeMs() - startedAt,
+            prompts_in_flight_after: piPromptsInFlight
+          }
+        });
+      };
       try {
-        void withProcessEnvPatch(this.sdkCallEnvPatch, invoke, { removeFirst: this.sdkCallEnvRemoveFirst }).catch((error) => {
+        void invoke().then(() => settle("ok")).catch((error) => {
+          settle("error");
           if (this.didClose) return;
           this.events.emit("runtime_event", {
             kind: "error",
@@ -12388,6 +12509,7 @@ var PiSdkRuntimeSession = class {
           });
         });
       } catch (error) {
+        settle("error");
         if (this.didClose) return;
         this.events.emit("runtime_event", {
           kind: "error",
@@ -12513,7 +12635,7 @@ var BuiltInDriver = class extends PiDriver {
       exposeLaunchTraceEvidence: true,
       exposeLaunchEnvToTools: false,
       isolateHostProviderEnv: true
-    }), { isolateHostProviderEnv: true });
+    }));
   }
   buildSystemPrompt(config, _agentId) {
     return buildCliTransportSystemPrompt(config, {
@@ -12778,8 +12900,27 @@ async function reapOrphanProcesses(pids, logger2, recordTrace) {
 }
 
 // src/workspaces.ts
-import { readdir, rm, stat } from "fs/promises";
+import { access, mkdir, readdir, rm, stat, writeFile } from "fs/promises";
 import path13 from "path";
+async function initializeAgentWorkspace(workspacePath, initialMemoryMd, seedFiles) {
+  await mkdir(workspacePath, { recursive: true });
+  const memoryMdPath = path13.join(workspacePath, "MEMORY.md");
+  try {
+    await access(memoryMdPath);
+  } catch {
+    await writeFile(memoryMdPath, initialMemoryMd);
+  }
+  await mkdir(path13.join(workspacePath, "notes"), { recursive: true });
+  for (const { relativePath, content } of seedFiles) {
+    const fullPath = path13.join(workspacePath, relativePath);
+    try {
+      await access(fullPath);
+    } catch {
+      await mkdir(path13.dirname(fullPath), { recursive: true });
+      await writeFile(fullPath, content);
+    }
+  }
+}
 function isValidWorkspaceDirectoryName(directoryName) {
   return !directoryName.includes("/") && !directoryName.includes("\\") && !directoryName.includes("..");
 }
@@ -17395,29 +17536,12 @@ var AgentProcessManager = class _AgentProcessManager {
     const originalLaunchId = launchId || null;
     try {
       const agentDataDir = path14.join(this.dataDir, agentId);
-      await mkdir(agentDataDir, { recursive: true });
       const initialRuntimeConfig = withLocalRuntimeContext(config, agentId, agentDataDir);
-      const memoryMdPath = path14.join(agentDataDir, "MEMORY.md");
-      try {
-        await access(memoryMdPath);
-      } catch {
-        const initialMemoryMd = buildInitialMemoryMd(initialRuntimeConfig);
-        await writeFile(memoryMdPath, initialMemoryMd);
-      }
-      const notesDir = path14.join(agentDataDir, "notes");
-      await mkdir(notesDir, { recursive: true });
-      if (getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE) {
-        const seedFiles = buildOnboardingSeedFiles();
-        for (const { relativePath, content } of seedFiles) {
-          const fullPath = path14.join(agentDataDir, relativePath);
-          try {
-            await access(fullPath);
-          } catch {
-            await mkdir(path14.dirname(fullPath), { recursive: true });
-            await writeFile(fullPath, content);
-          }
-        }
-      }
+      await initializeAgentWorkspace(
+        agentDataDir,
+        buildInitialMemoryMd(initialRuntimeConfig),
+        getOnboardingSeedMode(config) === FIRST_CINDY_SEED_MODE ? buildOnboardingSeedFiles() : []
+      );
       pendingStartRebind = this.lifecycleRecords.getPendingStartRebind(agentId);
       if (pendingStartRebind) {
         this.lifecycleRecords.deletePendingStartRebind(agentId);
@@ -18189,36 +18313,26 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
   async buildSpawnConfig(agentId, config) {
     const baseConfig = config.serverUrl === this.serverUrl ? config : { ...config, serverUrl: this.serverUrl };
     const runnerConfig = await this.ensureManagedRunnerCredential(agentId, baseConfig);
-    if (!this.defaultAgentEnvVarsProvider) {
-      return runnerConfig;
-    }
-    try {
-      const defaultEnvVars = await this.defaultAgentEnvVarsProvider({
-        runtime: runnerConfig.runtime,
-        model: runnerConfig.model,
-        envVars: runnerConfig.envVars
-      });
-      if (!defaultEnvVars || Object.keys(defaultEnvVars).length === 0) {
-        return runnerConfig;
-      }
-      const mergedEnvVars = {
-        ...defaultEnvVars,
-        ...runnerConfig.envVars ?? {}
-      };
-      if (this.sameEnvVars(mergedEnvVars, runnerConfig.envVars)) {
-        return runnerConfig;
+    let effectiveConfig = runnerConfig;
+    if (this.defaultAgentEnvVarsProvider) {
+      try {
+        const defaultEnvVars = await this.defaultAgentEnvVarsProvider({
+          runtime: runnerConfig.runtime,
+          model: runnerConfig.model,
+          envVars: runnerConfig.envVars
+        });
+        const mergedEnvVars = { ...defaultEnvVars ?? {}, ...runnerConfig.envVars ?? {} };
+        if (!this.sameEnvVars(mergedEnvVars, runnerConfig.envVars)) {
+          effectiveConfig = { ...runnerConfig, envVars: mergedEnvVars };
+        }
+      } catch (error) {
+        const reason = error instanceof Error ? error.message : String(error);
+        logger.warn(
+          `[Agent ${agentId}] Failed to resolve default runtime env vars \u2014 continuing without machine-level defaults (${reason})`
+        );
       }
-      return {
-        ...runnerConfig,
-        envVars: mergedEnvVars
-      };
-    } catch (error) {
-      const reason = error instanceof Error ? error.message : String(error);
-      logger.warn(
-        `[Agent ${agentId}] Failed to resolve default runtime env vars \u2014 continuing without machine-level defaults (${reason})`
-      );
-      return runnerConfig;
     }
+    return effectiveConfig;
   }
   async requestManagedRunnerCredentialOnce(agentId, config) {
     const url = new URL(`/internal/computer/runners/${encodeURIComponent(agentId)}/credentials`, this.serverUrl);
@@ -24580,6 +24694,17 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     },
     endAttrs: ["outcome", "models_count", "default_model_present", "verified_as", "error_class"]
   },
+  // task #510: per-prompt span. `prompts_in_flight` is the cross-agent concurrency
+  // observable — under the old process-env-patch lock it could never exceed 1
+  // (every Pi prompt serialized process-wide); > 1 proves the queue is gone.
+  // `queued_ms` is the queued -> prompt-start wait that users experienced as the
+  // 60-165s stall.
+  "daemon.pi.prompt": {
+    spanAttrs: ["agentId", "launchId", "runtime", "queued_ms", "duration_ms", "prompts_in_flight_after"],
+    eventAttrs: {
+      "daemon.pi.prompt.start": ["agentId", "queued_ms", "prompts_in_flight"]
+    }
+  },
   "daemon.pi.session.create": {
     spanAttrs: ["agentId", "launchId", "runtime", "model", "session_id_present", "requested_model"],
     eventAttrs: {
@@ -24780,7 +24905,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-54TOXXOV.js");
+  await import("./dist-ME3NQ5JP.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -26149,9 +26274,9 @@ var DaemonCore = class {
     });
   }
   emitReadyIfConnected() {
-    if (this.connection.connected) this.emitReady();
+    if (this.connection.connected) void this.emitReady();
   }
-  emitReady() {
+  async emitReady() {
     const { ids: runtimes, versions: runtimeVersions, diagnostics: runtimeDiagnostics = {} } = this.runtimeDetector();
     const runtimeInfo = runtimes.map((id) => runtimeVersions[id] ? `${id} (${runtimeVersions[id]})` : id);
     logger.info(`[Daemon] Detected runtimes: ${runtimeInfo.join(", ") || "none"}`);
@@ -26161,6 +26286,15 @@ var DaemonCore = class {
     const runningAgentIds = this.agentManager.getRunningAgentIds();
     const idleAgentSessions = this.agentManager.getIdleAgentSessionIds();
     const runtimeProfileReports = this.agentManager.getAgentRuntimeProfileReports();
+    let lifecycleAcks = this.options.getComputerLifecycleAcks?.() ?? [];
+    if (this.options.getComputerLifecycleReadyAcks) {
+      try {
+        lifecycleAcks = await this.options.getComputerLifecycleReadyAcks();
+      } catch (error) {
+        logger.warn(`[Daemon] Computer lifecycle attestation skipped: ${error instanceof Error ? error.message : String(error)}`);
+        lifecycleAcks = [];
+      }
+    }
     this.connection.send({
       type: "ready",
       capabilities: [
@@ -26177,7 +26311,7 @@ var DaemonCore = class {
       daemonVersion: this.daemonVersion,
       ...this.computerVersion ? { computerVersion: this.computerVersion } : {},
       migrationTransport: this.getMigrationTransportReady(),
-      ...this.options.getComputerLifecycleAcks ? { lifecycleAcks: this.options.getComputerLifecycleAcks() } : {}
+      ...this.options.getComputerLifecycleAcks || this.options.getComputerLifecycleReadyAcks ? { lifecycleAcks } : {}
     });
     this.recordDaemonTrace("daemon.ready.sent", {
       runtimes_count: runtimes.length,
@@ -26198,20 +26332,25 @@ var DaemonCore = class {
         logger.warn(`[Daemon] opencli wrapper refresh skipped: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-    this.emitReady();
+    void this.emitReady();
     const runningAgentIds = this.agentManager.getRunningAgentIds();
     const idleAgentSessions = this.agentManager.getIdleAgentSessionIds();
     const runtimeProfileReports = this.agentManager.getAgentRuntimeProfileReports();
     if (this.options.onComputerUpgradeReconcile) {
       void Promise.resolve().then(
-        () => this.options.onComputerUpgradeReconcile((done) => {
-          this.connection.send({ type: "computer:upgrade:done", ...done });
-          this.recordDaemonTrace("daemon.computer_upgrade.reconciled", {
-            request_id: done.requestId,
-            ok: done.ok,
-            ...done.newVersion ? { new_version: done.newVersion } : {}
-          });
-        })
+        () => this.options.onComputerUpgradeReconcile(
+          (done) => {
+            this.connection.send({ type: "computer:upgrade:done", ...done });
+            this.recordDaemonTrace("daemon.computer_upgrade.reconciled", {
+              request_id: done.requestId,
+              ok: done.ok,
+              ...done.newVersion ? { new_version: done.newVersion } : {}
+            });
+          },
+          (progress) => {
+            this.connection.send({ type: "computer:upgrade:progress", ...progress });
+          }
+        )
       ).catch((err) => {
         logger.error(
           `[Daemon] computer upgrade reconcile failed: ${err instanceof Error ? err.message : String(err)}`

package/dist/cli/index.js

@@ -45610,6 +45610,57 @@ var CANONICAL_MESSAGE_MANIFEST = Object.freeze({
   excludedClientOnly: EXCLUDED_CLIENT_ONLY_MESSAGE_FIELDS
 });
 
+// ../shared/src/canonicalMessageV2.ts
+init_esm_shims();
+var CANONICAL_MESSAGE_V2_SCHEMA_VERSION = 5;
+var CANONICAL_MESSAGE_V2_ENVELOPE_KIND = "normalized-message-v2";
+var CANONICAL_REACTION_PREVIEW_LIMIT = 3;
+var CANONICAL_REACTION_LIMIT = 30;
+var CANONICAL_MESSAGE_V2_MANIFEST = Object.freeze({
+  schemaVersion: CANONICAL_MESSAGE_V2_SCHEMA_VERSION,
+  envelopeKind: CANONICAL_MESSAGE_V2_ENVELOPE_KIND,
+  legacyIngressManifestVersion: CANONICAL_MESSAGE_MANIFEST_VERSION,
+  soleApplyEligible: true,
+  reactions: Object.freeze({
+    mergePolicy: "present-overwrite",
+    maxItems: CANONICAL_REACTION_LIMIT,
+    fields: Object.freeze(["count", "emoji", "previewK"]),
+    previewFields: Object.freeze(["displayName", "id"]),
+    previewLimit: CANONICAL_REACTION_PREVIEW_LIMIT,
+    legacyCompatibilityPreviewPolicy: "empty-without-room-common-provenance",
+    deterministicOrder: "emoji-code-unit/actor-id-code-unit"
+  }),
+  viewerOverlayFields: Object.freeze(["reactions.reactedByMe"]),
+  readCacheRelations: Object.freeze(["Message.ReactionActors"]),
+  forbiddenCanonicalPaths: Object.freeze([
+    "reactions[].reactorIds",
+    "reactions[].reactorNames"
+  ])
+});
+
+// ../shared/src/discussionGraph.ts
+init_esm_shims();
+var DISCUSSION_RELATION_REGISTRY = Object.freeze({
+  messageReactionActors: Object.freeze({
+    rootKind: "message",
+    relation: "reaction-actors",
+    backing: "read-cache",
+    consistency: "read-page",
+    provenance: Object.freeze({ count: "shared-parent-fold", previewK: "shared-parent-fold" }),
+    invalidation: "parent-scope-epoch",
+    allowedCommands: Object.freeze(["set-interaction"])
+  }),
+  messageReplies: Object.freeze({
+    rootKind: "message",
+    relation: "replies",
+    backing: "sync-scope",
+    consistency: "sync-scope-window",
+    provenance: Object.freeze({ replyCount: "shared-parent-fold" }),
+    invalidation: "own-scope-rebaseline",
+    allowedCommands: Object.freeze(["reply"])
+  })
+});
+
 // ../shared/src/index.ts
 var BUILTIN_RUNTIME_PROVIDER_ENV_KEYS = PI_BUILTIN_PROVIDER_API_KEY_ENV_KEYS_GENERATED;
 var BUILTIN_RUNTIME_PROVIDERS = Object.entries(BUILTIN_RUNTIME_PROVIDER_ENV_KEYS).map(([id, envKey]) => ({ id, envKey }));

package/dist/core.js

@@ -36,7 +36,7 @@ import {
   stageAgentMigrationObjectStoreBundle,
   subscribeDaemonLogs,
   verifyAgentMigrationAdoptPlan
-} from "./chunk-FNFNAY5B.js";
+} from "./chunk-LHJUHF42.js";
 export {
   AGENT_MIGRATION_BUNDLE_SCHEMA_VERSION,
   AGENT_MIGRATION_CONTROL_SEAM_ENV,

package/dist/{dist-54TOXXOV.js → dist-ME3NQ5JP.js}

@@ -45111,6 +45111,53 @@ var CANONICAL_MESSAGE_MANIFEST = Object.freeze({
   exclusions: CANONICAL_MESSAGE_EXCLUSIONS,
   excludedClientOnly: EXCLUDED_CLIENT_ONLY_MESSAGE_FIELDS
 });
+init_esm_shims();
+var CANONICAL_MESSAGE_V2_SCHEMA_VERSION = 5;
+var CANONICAL_MESSAGE_V2_ENVELOPE_KIND = "normalized-message-v2";
+var CANONICAL_REACTION_PREVIEW_LIMIT = 3;
+var CANONICAL_REACTION_LIMIT = 30;
+var CANONICAL_MESSAGE_V2_MANIFEST = Object.freeze({
+  schemaVersion: CANONICAL_MESSAGE_V2_SCHEMA_VERSION,
+  envelopeKind: CANONICAL_MESSAGE_V2_ENVELOPE_KIND,
+  legacyIngressManifestVersion: CANONICAL_MESSAGE_MANIFEST_VERSION,
+  soleApplyEligible: true,
+  reactions: Object.freeze({
+    mergePolicy: "present-overwrite",
+    maxItems: CANONICAL_REACTION_LIMIT,
+    fields: Object.freeze(["count", "emoji", "previewK"]),
+    previewFields: Object.freeze(["displayName", "id"]),
+    previewLimit: CANONICAL_REACTION_PREVIEW_LIMIT,
+    legacyCompatibilityPreviewPolicy: "empty-without-room-common-provenance",
+    deterministicOrder: "emoji-code-unit/actor-id-code-unit"
+  }),
+  viewerOverlayFields: Object.freeze(["reactions.reactedByMe"]),
+  readCacheRelations: Object.freeze(["Message.ReactionActors"]),
+  forbiddenCanonicalPaths: Object.freeze([
+    "reactions[].reactorIds",
+    "reactions[].reactorNames"
+  ])
+});
+init_esm_shims();
+var DISCUSSION_RELATION_REGISTRY = Object.freeze({
+  messageReactionActors: Object.freeze({
+    rootKind: "message",
+    relation: "reaction-actors",
+    backing: "read-cache",
+    consistency: "read-page",
+    provenance: Object.freeze({ count: "shared-parent-fold", previewK: "shared-parent-fold" }),
+    invalidation: "parent-scope-epoch",
+    allowedCommands: Object.freeze(["set-interaction"])
+  }),
+  messageReplies: Object.freeze({
+    rootKind: "message",
+    relation: "replies",
+    backing: "sync-scope",
+    consistency: "sync-scope-window",
+    provenance: Object.freeze({ replyCount: "shared-parent-fold" }),
+    invalidation: "own-scope-rebaseline",
+    allowedCommands: Object.freeze(["reply"])
+  })
+});
 var BUILTIN_RUNTIME_PROVIDER_ENV_KEYS = PI_BUILTIN_PROVIDER_API_KEY_ENV_KEYS_GENERATED;
 var BUILTIN_RUNTIME_PROVIDERS = Object.entries(BUILTIN_RUNTIME_PROVIDER_ENV_KEYS).map(([id, envKey]) => ({ id, envKey }));
 var PI_BUILTIN_PROVIDER_ENV_KEYS = {

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   DAEMON_CLI_USAGE,
   DaemonCore,
   parseDaemonCliArgs
-} from "./chunk-FNFNAY5B.js";
+} from "./chunk-LHJUHF42.js";
 
 // src/index.ts
 var parsedArgs = parseDaemonCliArgs(process.argv.slice(2));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botiverse/raft-daemon",
-  "version": "0.72.8",
+  "version": "0.72.12",
   "type": "module",
   "bin": {
     "raft-daemon": "dist/raft-daemon.js",