@botiverse/raft-daemon 0.72.8 → 1.0.0

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

@@ -1359,6 +1359,71 @@ function randomHex(length) {
 }
 
 // ../shared/src/tracing/eventRows.ts
+var TRACE_EVENT_ROW_V2_PROJECTION_COLUMNS = [
+  ["row_kind", "string"],
+  ["service_name", "string"],
+  ["deployment_environment", "string"],
+  ["service_version", "string"],
+  ["service_revision", "string"],
+  ["service_instance_id", "string"],
+  ["deployment_instance_source", "string"],
+  ["deployment_identity_state", "string"],
+  ["ecs_task_id", "string"],
+  ["ecs_task_family", "string"],
+  ["ecs_task_revision", "string"],
+  ["trace_id", "string"],
+  ["span_id", "string"],
+  ["parent_span_id", "string"],
+  ["span_name", "string"],
+  ["span_kind", "string"],
+  ["span_surface", "string"],
+  ["span_status", "string"],
+  ["span_start_time_ms", "int"],
+  ["span_end_time_ms", "int"],
+  ["event_name", "string"],
+  ["event_kind", "string"],
+  ["event_time", "timestamp"],
+  ["event_time_ms", "int"],
+  ["event_index", "int"],
+  ["server_id", "string"],
+  ["machine_id", "string"],
+  ["agent_id", "string"],
+  ["launch_id", "string"],
+  ["session_id", "string"],
+  ["request_id", "string"],
+  ["route_pattern", "string"],
+  ["caller_kind", "string"],
+  ["outcome", "string"],
+  ["reason", "string"],
+  ["source", "string"],
+  ["authority", "string"],
+  ["activity_write_site", "string"],
+  ["activity_source", "string"],
+  ["hint_source", "string"],
+  ["resolved_activity", "string"],
+  ["previous_activity", "string"],
+  ["next_activity", "string"],
+  ["repair_kind", "string"],
+  ["action", "string"],
+  ["error_class", "string"],
+  ["status_bucket", "string"],
+  ["shadow_agent_id", "string"],
+  ["shadow_signal_site", "string"],
+  ["shadow_observation_class", "string"],
+  ["shadow_prior_projection", "string"],
+  ["shadow_projection", "string"],
+  ["shadow_legacy_outcome", "string"],
+  ["shadow_action", "string"],
+  ["shadow_reason", "string"],
+  ["shadow_direction", "string"],
+  ["shadow_plan_kind", "string"]
+];
+var TRACE_EVENT_ROW_V2_INGEST_STATEMENT = [
+  "SELECT",
+  TRACE_EVENT_ROW_V2_PROJECTION_COLUMNS.map(([column, type]) => `$0["${column}"]::${type} AS ${column}`).join(", "),
+  "INSERT INTO raft.trace_events_v2",
+  `(${TRACE_EVENT_ROW_V2_PROJECTION_COLUMNS.map(([column]) => column).join(", ")})`
+].join(" ");
 var PROMOTED_IDENTITY_ATTRS = [
   "server_id",
   "machine_id",
@@ -2020,7 +2085,7 @@ var integrationAppDraftFieldsSchema = z.object({
 var integrationRegisterAppOperationSchema = integrationAppDraftFieldsSchema.extend({
   type: z.literal("integration:register_app"),
   name: z.string().trim().min(1).max(120),
-  clientKey: z.string().trim().min(1).max(120),
+  clientKey: z.string().trim().min(1).max(120).optional(),
   returnUrl: z.string().trim().min(1).max(2e3),
   scopes: z.array(z.string().trim().min(1).max(120)).max(64).default([]),
   unsafeDemoUrlOverride: z.boolean().optional(),
@@ -2440,10 +2505,8 @@ var agentApiIntegrationLoginBodySchema = passthroughObject({
   scopes: optionalStringArraySchema,
   target: optionalStringSchema
 });
-var agentApiIntegrationAppPrepareBodySchema = passthroughObject({
-  mode: z3.enum(["register", "update"]),
+var agentApiIntegrationAppPrepareCommonBodyShape = {
   target: z3.string().trim().min(1),
-  clientKey: z3.string().trim().min(1),
   name: optionalStringSchema,
   description: optionalStringSchema,
   homepageUrl: optionalStringSchema,
@@ -2452,7 +2515,19 @@ var agentApiIntegrationAppPrepareBodySchema = passthroughObject({
   scopes: optionalStringArraySchema,
   unsafeDemoUrlOverride: optionalBooleanSchema,
   draftHint: optionalStringSchema
-});
+};
+var agentApiIntegrationAppPrepareBodySchema = z3.discriminatedUnion("mode", [
+  passthroughObject({
+    mode: z3.literal("register"),
+    ...agentApiIntegrationAppPrepareCommonBodyShape,
+    clientKey: optionalStringSchema
+  }),
+  passthroughObject({
+    mode: z3.literal("update"),
+    ...agentApiIntegrationAppPrepareCommonBodyShape,
+    clientKey: z3.string().trim().min(1)
+  })
+]);
 var agentApiIntegrationAppRotateSecretBodySchema = passthroughObject({
   clientKey: z3.string().trim().min(1)
 });
@@ -4032,6 +4107,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 +4682,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 +4690,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 +4757,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 +4819,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;
   }
 }
@@ -5051,14 +5210,14 @@ Threads are sub-conversations attached to a specific message. They let you discu
 - **Start a new thread**: Use the \`msg=\` field from the header as the thread suffix. For example, if you see \`[target=#general msg=00000000 ...]\`, reply with \`raft message send --target "#general:00000000" <<'${D}'\` followed by the message body and \`${D}\`. The thread will be auto-created if it doesn't exist yet. Example IDs like \`00000000\` are placeholders; real message IDs come from received messages.
 - When you send a message, the response includes the message ID. You can use it to start a thread on your own message.
 - You can read thread history: \`raft message read --target "#general:00000000"\`
-- You can stop receiving ordinary delivery for a thread with \`raft thread unfollow --target "#general:00000000"\`. Only do this when your work in that thread is clearly complete or no longer relevant.
+- Unfollowing a thread removes its follow record and stops its ordinary delivery while the parent channel is unmuted: \`raft thread unfollow --target "#general:00000000"\`. A parent channel mute already suppresses ordinary delivery from its threads, so do not unfollow solely to mute the parent channel. Only unfollow when your work in that thread is clearly complete or no longer relevant.
 - Threads cannot be nested \u2014 you cannot start a thread inside a thread.`;
 }
 function buildDiscoverySection() {
   return `### Discovering people and channels
 
 Call \`raft server info\` to see all channels in this server, which ones you have joined, other agents, and humans.
-Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`raft message read\` and \`raft channel members\`, but you cannot send messages there or receive ordinary channel delivery until you join with \`raft channel join --target "#channel-name"\`. Private channels require a human with access to add you. To leave a regular channel you have joined, use \`raft channel leave --target "#channel-name"\`. To mute ordinary Activity delivery without leaving a regular channel, use \`raft channel mute --target "#channel-name"\`; personal @mentions and DMs still pierce (a task pierces only when it personally @mentions you), and thread following is separate. To reverse that setting, use \`raft channel unmute --target "#channel-name"\`. To stop following a thread without leaving its parent channel, use \`raft thread unfollow --target "#channel-name:shortid"\`.
+Visible public channels may appear even when \`joined=false\`. In that state you can still inspect them with \`raft message read\` and \`raft channel members\`, but you cannot send messages there or receive ordinary channel delivery until you join with \`raft channel join --target "#channel-name"\`. Private channels require a human with access to add you. To leave a regular channel you have joined, use \`raft channel leave --target "#channel-name"\`. To mute ordinary Activity delivery from a regular channel and its threads without leaving, use \`raft channel mute --target "#channel-name"\`; personal @mentions and DMs still pierce (a task pierces only when it personally @mentions you), while existing thread follow records remain. To reverse that setting, use \`raft channel unmute --target "#channel-name"\`. To remove a thread's follow record without leaving its parent channel, use \`raft thread unfollow --target "#channel-name:shortid"\`.
 Private channels are membership-gated. If \`raft server info\` shows a channel as private, treat its name, members, and content as private to that channel; do not disclose that information in other channels, DMs, summaries, or task reports unless a human explicitly asks within an authorized context. In \`raft channel members\`, human role labels such as owner/admin show server-level authority; no role label means ordinary member.`;
 }
 function buildChannelAwarenessSection() {
@@ -6499,6 +6658,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);
@@ -6592,6 +6752,32 @@ async function handleProxyRequest(req, res) {
   const method = req.method ?? "GET";
   const correlationId = randomBytes(8).toString("hex");
   let target;
+  const inboundTraceparent = firstRequestHeader(req.headers.traceparent);
+  const parent = parseTraceparent(inboundTraceparent);
+  const traceContextState = parent ? "continued" : inboundTraceparent ? "malformed" : "new_root";
+  let localPathname = "unknown";
+  try {
+    localPathname = new URL2(req.url ?? "/", "http://agent-proxy.local").pathname;
+  } catch {
+  }
+  const proxySpan = registration.tracer.startSpan("daemon.agent_proxy.request", {
+    parent,
+    surface: "daemon",
+    kind: "client",
+    attrs: {
+      route_family: routeFamilyForPath(localPathname),
+      method: normalizedProxyMethod(method),
+      trace_context_state: traceContextState,
+      proxy_launch_id_present: registration.launchId !== null,
+      correlation_id: correlationId
+    }
+  });
+  let proxySpanStatus = "error";
+  let proxySpanEndAttrs = {
+    outcome: "proxy_failure",
+    normalized_code: "transport_failure",
+    response_started: false
+  };
   try {
     target = new URL2(req.url ?? "/", registration.serverUrl);
     const headers = new Headers();
@@ -6612,6 +6798,7 @@ async function handleProxyRequest(req, res) {
     headers.set("X-Agent-Id", registration.agentId);
     headers.set("X-Slock-Client", "cli");
     headers.set("X-Slock-Agent-Active-Capabilities", registration.activeCapabilities);
+    headers.set("traceparent", formatTraceparent(proxySpan.context));
     let body;
     let rawBodyBuffer;
     if (method !== "GET" && method !== "HEAD") {
@@ -6626,6 +6813,12 @@ async function handleProxyRequest(req, res) {
     if (method === "GET" && target.pathname === "/internal/agent-api/inbox") {
       const localInbox = localAgentApiInboxResponse(registration);
       if (localInbox) {
+        proxySpanStatus = "ok";
+        proxySpanEndAttrs = {
+          outcome: "local_response",
+          local_response_kind: "inbox",
+          http_status: localInbox.status
+        };
         res.writeHead(localInbox.status, { "content-type": "application/json" });
         res.end(JSON.stringify(localInbox.body));
         return;
@@ -6634,6 +6827,12 @@ async function handleProxyRequest(req, res) {
     if (method === "GET" && target.pathname === "/internal/agent-api/events") {
       const localEvents = localAgentApiEventsResponse(registration, target);
       if (localEvents) {
+        proxySpanStatus = "ok";
+        proxySpanEndAttrs = {
+          outcome: "local_response",
+          local_response_kind: "events",
+          http_status: localEvents.status
+        };
         res.writeHead(localEvents.status, { "content-type": "application/json" });
         res.end(JSON.stringify(localEvents.body));
         return;
@@ -6643,6 +6842,12 @@ async function handleProxyRequest(req, res) {
       const rawBody = rawBodyBuffer?.toString("utf8") ?? "";
       const prepared = await prepareAgentApiSideEffectForward(registration, headers, rawBody, sideEffectAction);
       if (prepared.localResponse) {
+        proxySpanStatus = "ok";
+        proxySpanEndAttrs = {
+          outcome: "local_response",
+          local_response_kind: "freshness_hold",
+          http_status: 200
+        };
         const responseText = JSON.stringify(prepared.localResponse);
         res.writeHead(200, { "content-type": "application/json" });
         res.end(responseText);
@@ -6653,17 +6858,35 @@ 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);
+      proxySpanStatus = "error";
+      proxySpanEndAttrs = {
+        outcome: "upstream_5xx",
+        http_status: upstream.status,
+        normalized_code: transportError.normalizedCode,
+        response_started: transportError.responseStarted
+      };
       logger.warn(
         `[Agent Credential Proxy] upstream returned HTTP ${upstream.status} (agent=${registration.agentId}, launch=${registration.launchId ?? "none"}, correlation=${correlationId}, method=${method}, path=${target.pathname}, route_family=${transportError.routeFamily}, target_host_class=${transportError.targetHostClass})`
       );
       registration.inboxCoordinator?.recordTransportNormalizedError?.(transportError);
+    } else {
+      proxySpanStatus = "ok";
+      proxySpanEndAttrs = {
+        outcome: "upstream_response",
+        http_status: upstream.status
+      };
     }
     if (shouldBufferJsonResponse(upstream, target.pathname, registration)) {
       const responseText = await upstream.text();
@@ -6695,8 +6918,28 @@ async function handleProxyRequest(req, res) {
     );
     registration.inboxCoordinator?.recordProxyFailure?.(failure);
     registration.inboxCoordinator?.recordTransportNormalizedError?.(transportError);
+    proxySpanStatus = "error";
+    proxySpanEndAttrs = {
+      outcome: "proxy_failure",
+      normalized_code: transportError.normalizedCode,
+      response_started: transportError.responseStarted,
+      ...transportError.upstreamStatus === void 0 ? {} : { http_status: transportError.upstreamStatus }
+    };
     writeProxyFailureResponse(res, failure);
+  } finally {
+    proxySpan.end(proxySpanStatus, { attrs: proxySpanEndAttrs });
+  }
+}
+function firstRequestHeader(value) {
+  if (typeof value === "string") return value;
+  return value?.[0];
+}
+function normalizedProxyMethod(method) {
+  const normalized = method.toUpperCase();
+  if (normalized === "GET" || normalized === "POST" || normalized === "PUT" || normalized === "PATCH" || normalized === "DELETE" || normalized === "HEAD" || normalized === "OPTIONS") {
+    return normalized;
   }
+  return "OTHER";
 }
 function writeProxyFailureResponse(res, failure) {
   if (res.writableEnded) return;
@@ -6997,7 +7240,12 @@ async function loadRecentTargetMessages(registration, headers, target) {
   const historyHeaders = new Headers(headers);
   historyHeaders.delete("content-length");
   historyHeaders.delete("content-type");
-  const res = await fetch(historyUrl, { method: "GET", headers: historyHeaders });
+  const res = await daemonFetch(
+    historyUrl,
+    { method: "GET", headers: historyHeaders },
+    process.env,
+    { isolationKey: AGENT_CREDENTIAL_PROXY_FETCH_ISOLATION_KEY }
+  );
   if (!res.ok) return [];
   const parsed = await res.json().catch(() => null);
   return Array.isArray(parsed?.messages) ? normalizeInboxVisibleMessages(parsed.messages, target) : [];
@@ -7113,7 +7361,8 @@ async function registerAgentCredentialProxy(input) {
     agentId: input.agentId,
     launchId: input.launchId ?? null,
     activeCapabilities: input.activeCapabilities,
-    inboxCoordinator: input.inboxCoordinator
+    inboxCoordinator: input.inboxCoordinator,
+    tracer: input.tracer ?? noopTracer
   });
   return {
     proxyUrl: server.proxyUrl,
@@ -7372,7 +7621,8 @@ async function prepareCliTransport(ctx, extraEnv = {}, platform = process.platfo
       serverUrl: ctx.config.serverUrl,
       apiKey: agentCredentialKey,
       activeCapabilities: DEFAULT_ACTIVE_CAPABILITIES,
-      inboxCoordinator: ctx.agentCredentialProxyInboxCoordinator
+      inboxCoordinator: ctx.agentCredentialProxyInboxCoordinator,
+      tracer: ctx.tracer
     });
     const launchPart = buildCliTransportLaunchPart(ctx.launchId);
     const proxyTokenDir = path2.join(slockHome, "agent-proxy-tokens", safePathPart(ctx.agentId));
@@ -11731,7 +11981,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 +11998,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 +12361,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 +12484,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 +12627,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 +12669,7 @@ var PiSdkRuntimeSession = class {
           });
         });
       } catch (error) {
+        settle("error");
         if (this.didClose) return;
         this.events.emit("runtime_event", {
           kind: "error",
@@ -12513,7 +12795,7 @@ var BuiltInDriver = class extends PiDriver {
       exposeLaunchTraceEvidence: true,
       exposeLaunchEnvToTools: false,
       isolateHostProviderEnv: true
-    }), { isolateHostProviderEnv: true });
+    }));
   }
   buildSystemPrompt(config, _agentId) {
     return buildCliTransportSystemPrompt(config, {
@@ -12778,8 +13060,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 +17696,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 +18473,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);
@@ -21788,6 +22062,10 @@ var systemClock = {
   clearTimeout: (timer) => clearTimeout(timer)
 };
 var INBOUND_WATCHDOG_MS = 7e4;
+var LEGACY_MACHINE_KEY_MIGRATED_REASON = "legacy_machine_key_migrated";
+function isTerminalMigratedKeyRejection(statusCode, reason) {
+  return statusCode === 401 && reason === LEGACY_MACHINE_KEY_MIGRATED_REASON;
+}
 function normalizeHandshakeReason(value) {
   const raw = Array.isArray(value) ? value[0] : value;
   if (typeof raw !== "string") return null;
@@ -21964,6 +22242,17 @@ var DaemonConnection = class {
         slock_reason_present: Boolean(reason),
         slock_reason: reason
       }, "error");
+      if (isTerminalMigratedKeyRejection(statusCode, reason)) {
+        this.shouldConnect = false;
+        logger.error(
+          '[Daemon] This legacy machine key was already migrated to Raft Computer. Reconnects are stopped because this key cannot authenticate again.\nStop and disable this legacy raft-daemon process. In Raft, open this offline Computer and choose "raft-computer: command not found? Install or re-run setup" to copy the install and setup commands for this server.'
+        );
+        this.trace("daemon.connection.reconnect_stopped", {
+          status_code: statusCode,
+          slock_reason: reason,
+          terminal: true
+        }, "error");
+      }
       this.options.onHandshakeRejected?.({ statusCode, reason });
       response.resume();
       try {
@@ -24556,6 +24845,22 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     },
     endAttrs: ["outcome", "ackSeq", "deliveryId", "error_class", "pending_count"]
   },
+  "daemon.agent_proxy.request": {
+    spanAttrs: [
+      "route_family",
+      "method",
+      "trace_context_state",
+      "proxy_launch_id_present",
+      "correlation_id"
+    ],
+    endAttrs: [
+      "outcome",
+      "local_response_kind",
+      "http_status",
+      "normalized_code",
+      "response_started"
+    ]
+  },
   "daemon.runtime_profile.control.received": {
     spanAttrs: ["agentId", "control_kind", "key_present", "launchId"],
     endAttrs: ["outcome", "error_class"]
@@ -24580,6 +24885,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 +25096,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-YLMDSQ55.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -26149,9 +26465,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 +26477,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 +26502,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 +26523,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)}`