@botiverse/raft-daemon 0.69.0 → 0.70.0-play.20260706142959

package/dist/{chunk-URPIDKXK.js → chunk-KBLDM5DN.js}

@@ -1,5 +1,5 @@
 // src/core.ts
-import path19 from "path";
+import path20 from "path";
 import os8 from "os";
 import { createRequire as createRequire3 } from "module";
 import { accessSync } from "fs";
@@ -1105,6 +1105,7 @@ function projectTraceScopeAttrs(scope) {
   addOptionalStringAttr(attrs, "route_pattern", scope.request?.routePattern);
   addOptionalStringAttr(attrs, "method", scope.request?.method);
   addOptionalStringAttr(attrs, "caller_kind", scope.request?.callerKind);
+  addOptionalStringAttr(attrs, "user_id", scope.request?.userId);
   if (typeof scope.request?.userIdPresent === "boolean") {
     attrs.user_id_present = scope.request.userIdPresent;
   }
@@ -1280,10 +1281,24 @@ var RecordingActiveSpan = class {
   }
   addEvent(name, attrs) {
     if (this.ended) return;
-    this.events.push({
+    const event = {
       name,
       timeMs: this.clock(),
       ...attrs ? { attrs } : {}
+    };
+    const eventIndex = this.events.length;
+    this.events.push(event);
+    this.sink.recordEvent?.({
+      span: {
+        context: this.context,
+        name: this.name,
+        surface: this.surface,
+        kind: this.kind,
+        startTimeMs: this.startTimeMs,
+        ...this.attrs ? { attrs: this.attrs } : {}
+      },
+      event,
+      eventIndex
     });
   }
   end(status = "ok", options = {}) {
@@ -1291,7 +1306,7 @@ var RecordingActiveSpan = class {
     this.ended = true;
     const endTimeMs = this.clock();
     const attrs = mergeAttrs(this.attrs, options.attrs);
-    this.sink.record({
+    const completed = {
       context: this.context,
       name: this.name,
       surface: this.surface,
@@ -1302,7 +1317,9 @@ var RecordingActiveSpan = class {
       durationMs: Math.max(0, endTimeMs - this.startTimeMs),
       ...attrs ? { attrs } : {},
       events: [...this.events]
-    });
+    };
+    this.sink.recordSpanFact?.({ span: completed });
+    this.sink.record(completed);
   }
 };
 function mergeAttrs(base, extra) {
@@ -1337,6 +1354,125 @@ function randomHex(length) {
   return [...bytes].map((byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 
+// ../shared/src/tracing/eventRows.ts
+var PROMOTED_IDENTITY_ATTRS = [
+  "server_id",
+  "machine_id",
+  "agent_id",
+  "launch_id",
+  "session_id",
+  "request_id",
+  "route_pattern",
+  "caller_kind"
+];
+var PROMOTED_CLOSED_ATTRS = [
+  "outcome",
+  "reason",
+  "event_kind",
+  "source",
+  "authority",
+  "activity_write_site",
+  "activity_source",
+  "hint_source",
+  "resolved_activity",
+  "previous_activity",
+  "next_activity",
+  "repair_kind",
+  "action",
+  "error_class",
+  "status_bucket",
+  "shadow_agent_id",
+  "shadow_signal_site",
+  "shadow_observation_class",
+  "shadow_prior_projection",
+  "shadow_projection",
+  "shadow_legacy_outcome",
+  "shadow_action",
+  "shadow_reason",
+  "shadow_direction",
+  "shadow_plan_kind"
+];
+var TRACE_EVENT_ROW_PROMOTED_ATTRS = [
+  ...PROMOTED_IDENTITY_ATTRS,
+  ...PROMOTED_CLOSED_ATTRS
+];
+
+// ../shared/src/tracing/fields.ts
+function defineTraceFields(definitions) {
+  for (const definition of definitions) {
+    if (definition.fieldClass === "content_safety" && !definition.contentRule) {
+      throw new Error(`Trace content-safety field "${definition.key}" must define a contentRule`);
+    }
+    if ((definition.fieldClass === "query_axis" || definition.fieldClass === "family_query_axis") && definition.valueKind === "content") {
+      throw new Error(`Trace query-axis field "${definition.key}" cannot be content`);
+    }
+    if (definition.fieldClass === "family_query_axis" && !definition.scope) {
+      throw new Error(`Trace family query-axis field "${definition.key}" must define a family scope`);
+    }
+  }
+  return definitions;
+}
+var TRACE_B0_FIELD_DEFINITIONS = defineTraceFields([
+  { key: "row_kind", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "stable" },
+  { key: "trace_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "span_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "parent_span_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "span_name", fieldClass: "query_axis", placement: "span", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "span_surface", fieldClass: "query_axis", placement: "span", valueKind: "closed_enum", enumBinding: "stable" },
+  { key: "span_kind", fieldClass: "query_axis", placement: "span", valueKind: "closed_enum", enumBinding: "stable" },
+  { key: "span_status", fieldClass: "query_axis", placement: "span", valueKind: "closed_enum", enumBinding: "stable" },
+  { key: "event_name", fieldClass: "query_axis", placement: "event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "event_kind", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "event_index", fieldClass: "query_axis", placement: "event", valueKind: "identity" },
+  { key: "event_time", fieldClass: "query_axis", placement: "event", valueKind: "timestamp" },
+  { key: "event_time_ms", fieldClass: "query_axis", placement: "event", valueKind: "numeric" },
+  { key: "lifecycle_observed_at_ms", fieldClass: "query_axis", placement: "span_or_event", valueKind: "numeric" },
+  { key: "activity_observed_at_ms", fieldClass: "query_axis", placement: "span_or_event", valueKind: "numeric" },
+  { key: "advances_observed_clock", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "duration_ms", fieldClass: "query_axis", placement: "span_or_event", valueKind: "numeric" },
+  { key: "request_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "route_pattern", fieldClass: "query_axis", placement: "span", valueKind: "route" },
+  { key: "caller_kind", fieldClass: "query_axis", placement: "span", valueKind: "closed_enum", enumBinding: "stable" },
+  { key: "server_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "machine_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "agent_id", fieldClass: "query_axis", placement: "span_or_event", valueKind: "identity", highCardinality: true },
+  { key: "launch_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "session_id", fieldClass: "query_axis", placement: "span", valueKind: "identity", highCardinality: true },
+  { key: "observation_class", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "action", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "source", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "served_from", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "authority", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "decided_by", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "error_class", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "query_name", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "query_registry" },
+  { key: "phase", fieldClass: "query_axis", placement: "span_or_event", valueKind: "closed_enum", enumBinding: "pending_457" },
+  { key: "hint_source", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "resolved_activity", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "previous_activity", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "next_activity", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "repair_kind", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "activity_write_site", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "activity_source", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "status_bucket", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:activity" },
+  { key: "shadow_agent_id", fieldClass: "family_query_axis", placement: "event", valueKind: "identity", scope: "family:lifecycle_shadow", highCardinality: true },
+  { key: "shadow_signal_site", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_observation_class", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_prior_projection", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_projection", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_legacy_outcome", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_action", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_reason", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_direction", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "shadow_plan_kind", fieldClass: "family_query_axis", placement: "event", valueKind: "closed_enum", scope: "family:lifecycle_shadow", enumBinding: "pending_457" },
+  { key: "row_count", fieldClass: "detail", placement: "span_or_event", valueKind: "detail" },
+  { key: "retry_count", fieldClass: "detail", placement: "span_or_event", valueKind: "detail" },
+  { key: "error_message", fieldClass: "detail", placement: "span_or_event", valueKind: "detail", contentRule: "scrub_and_short_retention" },
+  { key: "query_text", fieldClass: "content_safety", placement: "span_or_event", valueKind: "content", contentRule: "scrub_and_short_retention" },
+  { key: "raw_payload", fieldClass: "content_safety", placement: "span_or_event", valueKind: "content", contentRule: "drop" },
+  { key: "token", fieldClass: "content_safety", placement: "span_or_event", valueKind: "content", contentRule: "drop" }
+]);
+
 // ../shared/src/toolDisplay.ts
 var TOOL_DISPLAY_METADATA = {
   send_message: { logLabel: "Sending message", activityLabel: "Sending message\u2026", summaryKind: "message_target" },
@@ -1986,7 +2122,8 @@ var agentApiResolveChannelResponseSchema = passthroughObject({
   channelId: z2.string().trim().min(1)
 });
 var agentApiThreadUnfollowBodySchema = passthroughObject({
-  thread: z2.string().trim().min(1)
+  thread: z2.string().trim().min(1),
+  reason: z2.string().trim().min(1).max(200).optional()
 });
 var agentApiTaskClaimBodySchema = passthroughObject({
   channel: z2.string().trim().min(1),
@@ -2146,6 +2283,7 @@ var agentApiServerInfoResponseSchema = passthroughObject({
     serverId: z2.string(),
     machineId: z2.string().nullable().optional(),
     machineName: z2.string().nullable().optional(),
+    machineDescription: z2.string().nullable().optional(),
     machineHostname: z2.string().nullable().optional(),
     machineOs: z2.string().nullable().optional(),
     daemonVersion: z2.string().nullable().optional(),
@@ -2225,7 +2363,12 @@ var agentApiIntegrationLoginResponseSchema = passthroughObject({
   status: z2.enum(["logged_in", "already_logged_in", "approval_required"]),
   service: agentApiIntegrationServiceSchema,
   scopes: z2.array(z2.string()),
-  requestId: z2.string(),
+  requestId: z2.string().optional(),
+  session: passthroughObject({
+    status: z2.literal("stored"),
+    source: z2.enum(["cache", "fresh"]),
+    path: nullableStringSchema
+  }).optional(),
   approval: passthroughObject({
     requestId: z2.string(),
     target: nullableStringSchema,
@@ -3003,6 +3146,14 @@ var daemonApiContract = {
   })
 };
 
+// ../shared/src/authRefreshTiming.ts
+var AUTH_REFRESH_ROTATED_REPLAY_GRACE_MS = 1e4;
+var AUTH_REFRESH_ROTATION_DISCOVERY_LAG_BUDGET_MS = 1e3;
+var AUTH_REFRESH_ROTATED_TOKEN_WAIT_MS = 4e3;
+var AUTH_REFRESH_ROTATION_RETRY_RTT_BUDGET_MS = 1e3;
+var AUTH_REFRESH_ROTATION_LOSER_WORST_CHAIN_MS = AUTH_REFRESH_ROTATION_DISCOVERY_LAG_BUDGET_MS + AUTH_REFRESH_ROTATED_TOKEN_WAIT_MS + AUTH_REFRESH_ROTATION_RETRY_RTT_BUDGET_MS;
+var AUTH_REFRESH_ROTATION_REPLAY_GRACE_MARGIN_MS = AUTH_REFRESH_ROTATED_REPLAY_GRACE_MS - AUTH_REFRESH_ROTATION_LOSER_WORST_CHAIN_MS;
+
 // ../shared/src/agentInbox.ts
 function formatAgentInboxDelta(rows, options = {}) {
   const totalPendingMessages = options.totalPendingMessages;
@@ -3182,6 +3333,55 @@ var SUPPORTED_TRANSLATION_LANGUAGE_SET = new Set(
   SUPPORTED_TRANSLATION_LANGUAGE_CODES
 );
 
+// ../shared/src/oauthScopes.ts
+var RAFT_OAUTH_SCOPE_CATALOG = {
+  openid: {
+    phase: "identity",
+    defaultAllowed: true,
+    publicDiscovery: true,
+    requiresResource: false,
+    label: "OpenID identity"
+  },
+  profile: {
+    phase: "identity",
+    defaultAllowed: true,
+    publicDiscovery: true,
+    requiresResource: false,
+    label: "Basic profile"
+  },
+  identity: {
+    phase: "identity",
+    defaultAllowed: true,
+    publicDiscovery: true,
+    requiresResource: false,
+    label: "Raft identity card"
+  },
+  "agent:event:write": {
+    phase: "agent_inbound",
+    defaultAllowed: false,
+    publicDiscovery: true,
+    requiresResource: true,
+    label: "Send structured events to an agent"
+  },
+  "agent:notification:write": {
+    phase: "agent_inbound",
+    defaultAllowed: false,
+    publicDiscovery: true,
+    requiresResource: true,
+    label: "Send notifications to an agent"
+  },
+  "agent:action_request:write": {
+    phase: "agent_inbound",
+    defaultAllowed: false,
+    publicDiscovery: false,
+    requiresResource: true,
+    label: "Request agent action"
+  }
+};
+var RAFT_OAUTH_SCOPES_SUPPORTED = Object.keys(RAFT_OAUTH_SCOPE_CATALOG);
+var RAFT_OAUTH_DEFAULT_ALLOWED_SCOPES = RAFT_OAUTH_SCOPES_SUPPORTED.filter((scope) => RAFT_OAUTH_SCOPE_CATALOG[scope].defaultAllowed);
+var RAFT_OAUTH_PUBLIC_DISCOVERY_SCOPES = RAFT_OAUTH_SCOPES_SUPPORTED.filter((scope) => RAFT_OAUTH_SCOPE_CATALOG[scope].publicDiscovery);
+
 // ../shared/src/testing/failpoints.ts
 var NoopFailpointRegistry = class {
   get enabled() {
@@ -3739,6 +3939,8 @@ var DISPLAY_PLAN_CONFIG = {
   }
 };
 var FREE_MONTHLY_FILE_UPLOAD_LIMIT_BYTES = 100 * 1024 * 1024;
+var FREE_SINGLE_FILE_UPLOAD_LIMIT_BYTES = 50 * 1024 * 1024;
+var PRO_SINGLE_FILE_UPLOAD_LIMIT_BYTES = 200 * 1024 * 1024;
 var TRIAL_START_DATE = /* @__PURE__ */ new Date("2026-04-18T00:00:00Z");
 var TRIAL_END_DATE = /* @__PURE__ */ new Date("2026-06-23T12:00:00Z");
 var TRIAL_DURATION_DAYS = (TRIAL_END_DATE.getTime() - TRIAL_START_DATE.getTime()) / (24 * 60 * 60 * 1e3);
@@ -4018,8 +4220,8 @@ async function executeResponseRequest(url, init, {
 }
 
 // src/directUploadCapability.ts
-function joinUrl(base, path20) {
-  return `${base.replace(/\/+$/, "")}${path20}`;
+function joinUrl(base, path21) {
+  return `${base.replace(/\/+$/, "")}${path21}`;
 }
 function jsonHeaders(apiKey) {
   return {
@@ -4237,7 +4439,7 @@ Threads are sub-conversations attached to a specific message. They let you discu
 - When you receive a message from a thread (the target has a \`:shortid\` suffix), **always reply using that same target** to keep the conversation in the thread.
 - **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 --channel "#general:00000000"\`
+- 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.
 - Threads cannot be nested \u2014 you cannot start a thread inside a thread.`;
 }
@@ -4245,7 +4447,7 @@ 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 "#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 "#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 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"\`.
 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() {
@@ -4259,9 +4461,9 @@ Each channel has a **name** and optionally a **description** that define its pur
 function buildReadingHistorySection() {
   return `### Reading history
 
-\`raft message read --channel "#channel-name"\` or \`raft message read --channel dm:@peer-name\` or \`raft message read --channel "#channel:shortid"\`
+\`raft message read --target "#channel-name"\` or \`raft message read --target dm:@peer-name\` or \`raft message read --target "#channel:shortid"\`
 
-To jump directly to a specific hit with nearby context, use \`raft message read --channel "..." --around "messageId"\` or \`raft message read --channel "..." --around 12345\`.`;
+To jump directly to a specific hit with nearby context, use \`raft message read --target "..." --around "messageId"\` or \`raft message read --target "..." --around 12345\`.`;
 }
 function buildHistoricalReferencesSection() {
   return `### Historical references
@@ -4290,7 +4492,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 **Assignee** is independent from status \u2014 a task can be claimed or unclaimed at any status except \`done\`.
 
 **Workflow:**
-1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message). Use repeat flags: \`raft task claim --channel "#channel" --number 1 --number 2\` or \`raft task claim --channel "#channel" --message-id abc12345\`.
+1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message). Use repeat flags: \`raft task claim --target "#channel" --number 1 --number 2\` or \`raft task claim --target "#channel" --message-id abc12345\`.
 2. If the claim fails, someone else is working on it \u2014 do not work on that task unless an owner/admin explicitly redirects it to you
 3. Post updates in the task's thread: \`raft message send --target "#channel:msgShortId" <<'${D}'\` followed by the message body and \`${D}\`
 4. When done, set status to \`in_review\` so a human can validate via \`raft task update\`
@@ -4302,7 +4504,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 - \`raft task create\` only creates the task \u2014 to own it, call \`raft task claim\` afterward.
 - Typical uses for \`raft task create\` are breaking down a larger task into parallel subtasks, or batch-creating genuinely new work for others to claim.
 - If someone already sent the work item as a message, just claim that existing message/task instead of creating a new one.
-- If the work already exists as a message, reuse it via \`raft task claim --channel "#channel" --message-id abc12345\`.
+- If the work already exists as a message, reuse it via \`raft task claim --target "#channel" --message-id abc12345\`.
 
 **Creating new tasks:**
 - The task system exists to prevent duplicate work. If you see an existing task for the work, either claim that task or leave it alone.
@@ -4521,7 +4723,7 @@ function buildPrompt(config, opts) {
   const channelAwarenessSection = cliGuideSections.channelAwareness;
   const thirdPartyIntegrationsSection = `### Third-party integrations
 
-If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first run \`raft integration list\` and match the app to a listed service before browsing the app. Use \`raft integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes manifest-backed HTTP API actions, prefer \`raft integration invoke --service <service> --list-actions\` and then \`raft integration invoke --service <service> --action <name>\`; the CLI performs the stateless Agent Login callback handoff and service-session setup for you. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`raft integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides; for HTTP API action services, use \`raft integration invoke\` instead. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute local commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When \`raft integration login\` returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes a service callback handoff URL, treat it as a stateless Login with Raft API-action session handoff URL; prefer \`raft integration invoke\` over manually opening or curling it. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes outside the documented CLI flow, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`raft profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.`;
+If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first run \`raft integration list\` and match the app to a listed service before browsing the app. Use \`raft integration login --service <service>\` to provision or reuse your agent login for that service; the CLI consumes the one-time Agent Login handoff internally and stores the service-owned session for this agent, so the successful output should be \`Agent login ready\` / \`Already logged in\`, not a raw request code you need to keep. If the service exposes manifest-backed HTTP API actions, prefer \`raft integration invoke --service <service> --list-actions\` and then \`raft integration invoke --service <service> --action <name>\`; the CLI uses the stored service session or refreshes it internally. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`raft integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides; for HTTP API action services, use \`raft integration invoke\` instead. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute local commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. Do not store or reuse raw \`oauth_access_request\` request codes; those are one-time compatibility handoffs for services to exchange once for their own session/token. Prefer \`raft integration invoke\` over manually opening or curling callback URLs. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes outside the documented CLI flow, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`raft profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.`;
   const readingHistorySection = cliGuideSections.readingHistory;
   const historicalReferenceSection = cliGuideSections.historicalReferences;
   const tasksSection = cliGuideSections.tasks;
@@ -4709,6 +4911,19 @@ function listLegacySlockStatePaths(slockHome = resolveSlockHome(), homeDir = os.
   return candidates.filter((candidate) => existsSync(candidate.path));
 }
 
+// src/authEnv.ts
+var DAEMON_API_KEY_ENV = "SLOCK_MACHINE_API_KEY";
+var SLOCK_AGENT_TOKEN_ENV = "SLOCK_AGENT_TOKEN";
+function scrubDaemonAuthEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  return env;
+}
+function scrubDaemonChildEnv(env) {
+  delete env[DAEMON_API_KEY_ENV];
+  delete env[SLOCK_AGENT_TOKEN_ENV];
+  return env;
+}
+
 // src/agentCredentialProxy.ts
 import { randomBytes } from "crypto";
 import http from "http";
@@ -5652,7 +5867,7 @@ function shortMessageId2(value) {
   return value.slice(0, 8);
 }
 function normalizeSenderType(value) {
-  return value === "human" || value === "agent" || value === "system" ? value : void 0;
+  return value === "human" || value === "agent" || value === "system" || value === "third_party_app" ? value : void 0;
 }
 function nonEmptyString(value) {
   return typeof value === "string" && value.trim().length > 0 ? value : void 0;
@@ -6040,6 +6255,10 @@ async function readRequestBody(req) {
 function messageSeq3(message) {
   return Number(message.seq ?? 0);
 }
+function isThirdPartyAgentEvent(message) {
+  const thirdPartyEvent = message.third_party_event;
+  return typeof thirdPartyEvent?.id === "string" && thirdPartyEvent.id.length > 0;
+}
 function localAgentApiInboxResponse(registration) {
   const coordinator = registration.inboxCoordinator;
   if (!coordinator) return void 0;
@@ -6090,6 +6309,7 @@ function localAgentApiEventsResponse(registration, target) {
   const normalized = sortInboxMessagesBySeq(normalizeInboxVisibleMessages(pending));
   const filtered = parsedQuery.sinceSeq !== null ? normalized.filter((message) => {
     const seq = messageSeq3(message);
+    if ((!Number.isFinite(seq) || seq <= 0) && isThirdPartyAgentEvent(message)) return true;
     return Number.isFinite(seq) && seq > parsedQuery.sinceSeq;
   }) : normalized;
   const events = filtered.slice(0, parsedQuery.limit);
@@ -6283,7 +6503,9 @@ var LOOPBACK_NO_PROXY = "127.0.0.1,localhost";
 var CLI_TRANSPORT_TRACE_DIR_ENV = "SLOCK_CLI_TRANSPORT_TRACE_DIR";
 var safePathPart = (value) => value.replace(/[^a-zA-Z0-9_.-]/g, "_");
 var RAW_CREDENTIAL_ENV_DENYLIST = [
-  "SLOCK_AGENT_CREDENTIAL_KEY"
+  "SLOCK_AGENT_TOKEN",
+  "SLOCK_AGENT_CREDENTIAL_KEY",
+  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
 ];
 var WORKSPACE_CLI_TRANSPORT_FILENAMES = [
   "agent-token",
@@ -6638,7 +6860,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  delete spawnEnv.SLOCK_AGENT_TOKEN;
+  scrubDaemonChildEnv(spawnEnv);
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -7206,7 +7428,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -7232,7 +7454,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
+  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -7658,7 +7880,7 @@ function codexNotificationDiagnosticEvent(message) {
       return null;
   }
   const sessionId = codexMessageThreadId(message);
-  const path20 = boundedString(params.path);
+  const path21 = boundedString(params.path);
   return {
     kind: "runtime_diagnostic",
     severity: "warning",
@@ -7666,7 +7888,7 @@ function codexNotificationDiagnosticEvent(message) {
     itemType: message.method,
     message: diagnosticMessage,
     ...details ? { details } : {},
-    ...path20 ? { path: path20 } : {},
+    ...path21 ? { path: path21 } : {},
     ...params.range !== void 0 ? { range: params.range } : {},
     payloadBytes: payloadBytes(params),
     ...sessionId ? { sessionId } : {}
@@ -9316,11 +9538,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return withWindowsUserEnvironment({
+  return scrubDaemonChildEnv(withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps);
+  }, deps));
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -9376,7 +9598,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = deps.env ?? process.env;
+  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -9513,12 +9735,15 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
 import os4 from "os";
 import path9 from "path";
 var KIMI_WIRE_PROTOCOL_VERSION = "1.3";
 var KIMI_SYSTEM_PROMPT_FILE = ".slock-kimi-system.md";
 var KIMI_AGENT_FILE = ".slock-kimi-agent.yaml";
+var KIMI_GENERATED_CONFIG_FILE = ".slock-kimi-config.toml";
+var SLOCK_KIMI_CONFIG_CONTENT_ENV = "SLOCK_KIMI_CONFIG_CONTENT";
+var SLOCK_KIMI_CONFIG_FILE_ENV = "SLOCK_KIMI_CONFIG_FILE";
 function parseToolArguments(raw) {
   if (typeof raw !== "string") return raw;
   try {
@@ -9527,6 +9752,73 @@ function parseToolArguments(raw) {
     return raw;
   }
 }
+function readKimiConfigSource(home = os4.homedir(), env = process.env) {
+  const inlineConfig = env[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  if (inlineConfig && inlineConfig.trim()) {
+    return {
+      raw: inlineConfig,
+      explicitPath: null,
+      sourcePath: SLOCK_KIMI_CONFIG_CONTENT_ENV
+    };
+  }
+  const explicitPath = env[SLOCK_KIMI_CONFIG_FILE_ENV];
+  const configPath = explicitPath && explicitPath.trim() ? explicitPath : path9.join(home, ".kimi", "config.toml");
+  try {
+    return {
+      raw: readFileSync3(configPath, "utf8"),
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  } catch {
+    return {
+      raw: null,
+      explicitPath: explicitPath && explicitPath.trim() ? explicitPath : null,
+      sourcePath: configPath
+    };
+  }
+}
+function buildKimiSpawnEnv(env = process.env) {
+  const spawnEnv = { ...env, FORCE_COLOR: "0", NO_COLOR: "1" };
+  delete spawnEnv[SLOCK_KIMI_CONFIG_CONTENT_ENV];
+  delete spawnEnv[SLOCK_KIMI_CONFIG_FILE_ENV];
+  return scrubDaemonChildEnv(spawnEnv);
+}
+function buildKimiEffectiveEnv(ctx, overrideEnv) {
+  return {
+    ...process.env,
+    ...ctx.config.envVars || {},
+    ...overrideEnv || {}
+  };
+}
+function buildKimiLaunchOptions(ctx, opts = {}) {
+  const env = buildKimiEffectiveEnv(ctx, opts.env);
+  const source = readKimiConfigSource(opts.home ?? os4.homedir(), env);
+  const args = [];
+  let configFilePath = null;
+  let configContent = null;
+  if (source.explicitPath) {
+    configFilePath = source.explicitPath;
+  } else if (source.raw !== null && source.sourcePath === SLOCK_KIMI_CONFIG_CONTENT_ENV) {
+    configFilePath = path9.join(ctx.workingDirectory, KIMI_GENERATED_CONFIG_FILE);
+    configContent = source.raw;
+    if (opts.writeGeneratedConfig !== false) {
+      writeFileSync3(configFilePath, source.raw, { encoding: "utf8", mode: 384 });
+      chmodSync(configFilePath, 384);
+    }
+  }
+  if (configFilePath) {
+    args.push("--config-file", configFilePath);
+  }
+  if (ctx.config.model && ctx.config.model !== "default") {
+    args.push("--model", ctx.config.model);
+  }
+  return {
+    args,
+    env: buildKimiSpawnEnv(env),
+    configFilePath,
+    configContent
+  };
+}
 function resolveKimiSpawn(commandArgs, deps = {}) {
   return {
     command: resolveCommandOnPath("kimi", deps) ?? "kimi",
@@ -9550,7 +9842,25 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
+    toLaunchSpec: (modelId, ctx, opts) => {
+      if (!ctx) return { args: ["--model", modelId] };
+      const launchCtx = {
+        ...ctx,
+        config: {
+          ...ctx.config,
+          model: modelId
+        }
+      };
+      const launch = buildKimiLaunchOptions(launchCtx, {
+        home: opts?.home,
+        writeGeneratedConfig: false
+      });
+      return {
+        args: launch.args,
+        env: launch.env,
+        configFiles: launch.configFilePath ? [launch.configFilePath] : void 0
+      };
+    }
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -9574,21 +9884,23 @@ var KimiDriver = class {
       `  system_prompt_path: ./${KIMI_SYSTEM_PROMPT_FILE}`,
       ""
     ].join("\n"), "utf8");
+    const launch = buildKimiLaunchOptions(ctx);
     const args = [
       "--wire",
       "--yolo",
       "--agent-file",
       agentFilePath,
       "--session",
-      this.sessionId
+      this.sessionId,
+      ...launch.args
     ];
     const launchRuntimeFields = runtimeConfigToLaunchFields(hydrateRuntimeConfig(ctx.config));
     if (launchRuntimeFields.model && launchRuntimeFields.model !== "default") {
       args.push("--model", launchRuntimeFields.model);
     }
     const spawnEnv = (await prepareCliTransport(ctx, { NO_COLOR: "1" })).spawnEnv;
-    const launch = resolveKimiSpawn(args);
-    const proc = spawn7(launch.command, launch.args, {
+    const spawnTarget = resolveKimiSpawn(args);
+    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -9596,7 +9908,7 @@ var KimiDriver = class {
       // and has an 8191-character command-line limit. Kimi's official
       // installer/uv entrypoint is an executable, so launch it directly and
       // keep prompts on stdin / files instead of routing through cmd.exe.
-      shell: launch.shell
+      shell: spawnTarget.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -9709,14 +10021,9 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir()) {
-  const configPath = path9.join(home, ".kimi", "config.toml");
-  let raw;
-  try {
-    raw = readFileSync3(configPath, "utf8");
-  } catch {
-    return null;
-  }
+function detectKimiModels(home = os4.homedir(), opts = {}) {
+  const raw = readKimiConfigSource(home, opts.env).raw;
+  if (raw === null) return null;
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -10382,7 +10689,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
+    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -12524,6 +12831,9 @@ function computeTarget(channelType, channelName, parentChannelName, parentChanne
   return `#${channelName}`;
 }
 function formatAgentMessageVisibleTarget(message) {
+  if (message.third_party_event) {
+    return `agent-event:${getMessageShortId(message.third_party_event.id)}`;
+  }
   return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
 }
 function formatProxyVisibleMessageTarget(message) {
@@ -13371,24 +13681,38 @@ function safeSessionFilename(value) {
   const normalized = value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
   return normalized || "unknown-session";
 }
-function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir) {
+function writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir, join, resolve) {
   try {
     const dir = path14.join(fallbackDir, ".slock", "runtime-sessions");
     mkdirSync4(dir, { recursive: true });
     const filePath = path14.join(dir, `${runtime}-${safeSessionFilename(sessionId)}.jsonl`);
+    const searchedPaths = resolve?.searchedPaths ?? [];
     writeFileSync4(filePath, JSON.stringify({
       type: "runtime_session_handoff",
       runtime,
       sessionId,
+      // Persisted L1<->L2 join keys (#460 V3): without these the
+      // session->launch mapping lives only in daemon memory and old L1
+      // transcripts can never re-join their launch after restart/adopt.
+      // ids-only, closed fields (no content payload).
+      launchId: join?.launchId ?? null,
+      processInstanceId: join?.processInstanceId ?? null,
+      // Negative-space (fruit#0 pt2): a resolve-miss is explicit evidence, not a
+      // silent "not found". Recording the lookup method + the directories checked
+      // makes "looked in the wrong place" distinguishable from "looked in the right
+      // place and it is genuinely absent". ids/paths only — no transcript content.
+      resolveStatus: "transcript_resolve_missing",
+      lookupMethod: resolve?.lookupMethod ?? "none",
+      searchedPaths,
       createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-      note: "The native runtime transcript file was not found on this machine; this daemon-created handoff records the runtime session identity for diagnostics."
+      note: "The native runtime transcript file was not found on this machine; this daemon-created handoff records the runtime session identity + the directories checked for diagnostics."
     }) + "\n", { mode: 384 });
     return {
       label: sessionId,
       path: filePath,
       runtime,
       reachable: true,
-      reason: "native session file path not found; using daemon handoff file"
+      reason: `native session file path not found; using daemon handoff file; searched=[${searchedPaths.join(", ")}]`
     };
   } catch {
     return null;
@@ -13413,12 +13737,16 @@ function ensureRuntimeHomeDir(config, defaultHomeDir, workspacePath, opts = {})
 function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), fallbackDir, opts) {
   let resolvedPath = null;
   let lookupMethod = "none";
+  const searchedPaths = [];
   if (runtime === "claude") {
     lookupMethod = "claude_jsonl";
-    resolvedPath = findSessionJsonl(path14.join(homeDir, ".claude", "projects"), (filename) => filename === `${sessionId}.jsonl`);
+    const claudeRoot = path14.join(homeDir, ".claude", "projects");
+    searchedPaths.push(claudeRoot);
+    resolvedPath = findSessionJsonl(claudeRoot, (filename) => filename === `${sessionId}.jsonl`);
   } else if (runtime === "codex") {
     lookupMethod = "codex_jsonl";
     for (const root of codexSessionRootCandidates(homeDir)) {
+      searchedPaths.push(root);
       resolvedPath = findSessionJsonl(root, (filename) => filename.endsWith(".jsonl") && filename.includes(sessionId));
       if (resolvedPath) break;
     }
@@ -13430,7 +13758,13 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), f
     resolvedPath = findPiSessionFile2(sessionId, opts?.workingDirectory, homeDir);
   }
   if (!resolvedPath && fallbackDir) {
-    const fallback = writeRuntimeSessionHandoff(runtime, sessionId, fallbackDir);
+    const fallback = writeRuntimeSessionHandoff(
+      runtime,
+      sessionId,
+      fallbackDir,
+      { launchId: opts?.launchId, processInstanceId: opts?.processInstanceId },
+      { lookupMethod, searchedPaths }
+    );
     if (fallback) {
       return {
         ...fallback,
@@ -13445,7 +13779,7 @@ function resolveRuntimeSessionRef(runtime, sessionId, homeDir = os6.homedir(), f
     reachable: Boolean(resolvedPath)
   };
   if (!resolvedPath) {
-    ref.reason = `session file path not found; attempted_lookup=${lookupMethod}`;
+    ref.reason = `session file path not found; attempted_lookup=${lookupMethod}; searched=[${searchedPaths.join(", ")}]`;
   }
   return ref;
 }
@@ -13499,7 +13833,7 @@ function formatIncomingMessage(message, options = {}) {
     `[Slock thread context: you were added to a new thread via @mention.]`,
     `parent: ${message.thread_join_context.parent_target}`,
     `thread: ${message.thread_join_context.thread_target}`,
-    `suggested next step: raft message read --channel "${message.thread_join_context.suggested_read_history_target}"`,
+    `suggested next step: raft message read --target "${message.thread_join_context.suggested_read_history_target}"`,
     "",
     "Parent message:",
     formatThreadContextMessage(message.thread_join_context.parent_message),
@@ -15329,7 +15663,8 @@ var AgentProcessManager = class _AgentProcessManager {
       detailKind: activity.statusEntry.detailKind ?? "daemon_activity",
       entries: activity.entries,
       launchId: ap?.launchId || void 0,
-      clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
+      clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0,
+      isHeartbeat: false
     });
   }
   recordRuntimeDiagnosticActivity(agentId, ap, event) {
@@ -15342,7 +15677,8 @@ var AgentProcessManager = class _AgentProcessManager {
       detailKind: ap.lastActivityDetailKind || "none",
       entries: [runtimeDiagnosticTrajectoryEntry(event)],
       launchId: ap.launchId || void 0,
-      clientSeq: this.nextActivityClientSeq(agentId)
+      clientSeq: this.nextActivityClientSeq(agentId),
+      isHeartbeat: false
     });
     this.recordDaemonTrace("daemon.runtime.diagnostic", {
       agentId,
@@ -15393,7 +15729,8 @@ var AgentProcessManager = class _AgentProcessManager {
       detailKind: ap.lastActivityDetailKind || "none",
       entries: [runtimeRecoveryTrajectoryEntry(event)],
       launchId: ap.launchId || void 0,
-      clientSeq: this.nextActivityClientSeq(agentId)
+      clientSeq: this.nextActivityClientSeq(agentId),
+      isHeartbeat: false
     });
     this.recordDaemonTrace("daemon.runtime.recovery.visible", {
       agentId,
@@ -15641,7 +15978,8 @@ var AgentProcessManager = class _AgentProcessManager {
     this.lifecycleRecords.setRestartSnapshot(agentId, {
       config: this.buildRestartSafeConfig(ap.config, nextConfigSessionId),
       sessionId: nextConfigSessionId,
-      launchId: nextLaunchId
+      launchId: nextLaunchId,
+      processInstanceId: ap.processInstanceId
     });
     this.recordStartRebind(agentId, start, reason, previousLaunchId, nextLaunchId, nextSessionId);
     this.sendAgentStatus(agentId, "active", nextLaunchId);
@@ -16072,6 +16410,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           config: this.buildRestartSafeConfig(runtimeConfig, runtimeConfig.sessionId || null),
           sessionId: runtimeConfig.sessionId || null,
           launchId: effectiveLaunchId
+          // No live AgentProcess in this adoption branch — omit rather than
+          // fabricate; the marker's processInstanceId is nullable by contract.
         });
         this.sendAgentStatus(agentId, "active", effectiveLaunchId);
         this.broadcastActivity(agentId, "online", "Process idle", [], void 0, "idle");
@@ -16161,7 +16501,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       this.lifecycleRecords.setRestartSnapshot(agentId, {
         config: this.buildRestartSafeConfig(runtimeConfig, restartSessionId),
         sessionId: restartSessionId,
-        launchId: effectiveLaunchId
+        launchId: effectiveLaunchId,
+        processInstanceId: agentProcess.processInstanceId
       });
       if (pendingStartRebind) {
         this.recordStartRebind(agentId, pendingStartRebind, "startup_registered", originalLaunchId, effectiveLaunchId, agentProcess.sessionId);
@@ -16363,7 +16704,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               this.lifecycleRecords.setRestartSnapshot(agentId, {
                 config: nextConfig,
                 sessionId: ap.sessionId,
-                launchId: ap.launchId
+                launchId: ap.launchId,
+                processInstanceId: ap.processInstanceId
               });
               this.broadcastMessageReceivedActivity(agentId);
               this.lifecycleRecords.deleteRestartSnapshot(agentId);
@@ -16381,7 +16723,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
                   this.lifecycleRecords.setRestartSnapshot(agentId, {
                     config: nextConfig,
                     sessionId: ap.sessionId,
-                    launchId: ap.launchId
+                    launchId: ap.launchId,
+                    processInstanceId: ap.processInstanceId
                   });
                   const report = this.recordSpawnFailure(agentId, "runner_credential_mint");
                   this.assertStartPendingDeliveryInvariants("queued-continuation-runner-credential-mint-failure");
@@ -16401,7 +16744,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
                 this.lifecycleRecords.setRestartSnapshot(agentId, {
                   config: nextConfig,
                   sessionId: ap.sessionId,
-                  launchId: ap.launchId
+                  launchId: ap.launchId,
+                  processInstanceId: ap.processInstanceId
                 });
                 this.broadcastActivity(agentId, "online", "Process idle", [], void 0, "idle");
               });
@@ -16410,7 +16754,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
             this.lifecycleRecords.setRestartSnapshot(agentId, {
               config: this.buildRestartSafeConfig(ap.config, ap.sessionId),
               sessionId: ap.sessionId,
-              launchId: ap.launchId
+              launchId: ap.launchId,
+              processInstanceId: ap.processInstanceId
             });
             if (!ap.driver.supportsStdinNotification) {
               logger.info(`[Agent ${agentId}] Turn completed; cached idle state for future restart`);
@@ -16422,7 +16767,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               this.lifecycleRecords.setRestartSnapshot(agentId, {
                 config: this.buildRestartSafeConfig(ap.config, ap.sessionId),
                 sessionId: ap.sessionId,
-                launchId: ap.launchId
+                launchId: ap.launchId,
+                processInstanceId: ap.processInstanceId
               });
               logger.warn(`[Agent ${agentId}] Recoverable provider stream failure (${reason}) \u2014 keeping agent wakeable`);
               this.sendAgentStatus(agentId, "active", ap.launchId);
@@ -16638,7 +16984,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     this.lifecycleRecords.setRestartSnapshot(agentId, {
       config: retryConfig,
       sessionId: retrySessionId,
-      launchId: ap.launchId
+      launchId: ap.launchId,
+      processInstanceId: ap.processInstanceId
     });
     this.recordDaemonTrace("daemon.agent.startup_timeout.retry_config_cached", {
       agentId,
@@ -17552,7 +17899,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     }
     return result;
   }
-  buildRuntimeProfileReport(agentId, config, sessionId, launchId, observedRuntimeHomeDir) {
+  buildRuntimeProfileReport(agentId, config, sessionId, launchId, observedRuntimeHomeDir, processInstanceId) {
     const workspacePath = path14.join(this.dataDir, agentId);
     const runtimeHomeDir = observedRuntimeHomeDir || resolveRuntimeHomeDir(config, this.runtimeSessionHomeDir, workspacePath, { agentId, slockHome: this.slockHome });
     return {
@@ -17568,7 +17915,16 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           path: workspacePath,
           reachable: true
         },
-        sessionRef: sessionId ? resolveRuntimeSessionRef(config.runtime, sessionId, runtimeHomeDir, workspacePath, { agentId, workingDirectory: workspacePath }) : null
+        sessionRef: sessionId ? resolveRuntimeSessionRef(config.runtime, sessionId, runtimeHomeDir, workspacePath, {
+          agentId,
+          workingDirectory: workspacePath,
+          // Join keys come from the CALLER's context (running agent OR idle
+          // restart snapshot) — reading only live state here left the
+          // restart/adopt path writing launchId:null markers, exactly the
+          // V3 class this exists to close (Leiysky review on #3863).
+          launchId: launchId || void 0,
+          processInstanceId: processInstanceId ?? this.agents.get(agentId)?.processInstanceId
+        }) : null
       }
     };
   }
@@ -17580,12 +17936,13 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         running.config,
         running.sessionId,
         running.launchId,
-        running.runtime.currentRuntimeHomeDir
+        running.runtime.currentRuntimeHomeDir,
+        running.processInstanceId
       );
     }
     const idle = this.lifecycleRecords.getRestartSnapshot(agentId);
     if (idle) {
-      return this.buildRuntimeProfileReport(agentId, idle.config, idle.sessionId, idle.launchId);
+      return this.buildRuntimeProfileReport(agentId, idle.config, idle.sessionId, idle.launchId, null, idle.processInstanceId);
     }
     return null;
   }
@@ -17983,7 +18340,9 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     }
     const ref = resolveRuntimeSessionRef(runtime, actualSessionId, homeDir, workspaceDir, {
       agentId,
-      workingDirectory: workspaceDir
+      workingDirectory: workspaceDir,
+      launchId: this.agents.get(agentId)?.launchId || void 0,
+      processInstanceId: this.agents.get(agentId)?.processInstanceId
     });
     const tier = runtimeTier(runtime);
     const span = this.tracer.startSpan("daemon.session_transcript.read", {
@@ -18241,6 +18600,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     const launchId = launchIdOverride || ap?.launchId || void 0;
     const clientSeq = this.nextActivityClientSeq(agentId);
     const producerFactId = this.buildActivityProducerFactId(agentId, launchId, clientSeq);
+    const observedAtMs = Date.now();
     this.sendToServer({
       type: "agent:activity",
       agentId,
@@ -18251,9 +18611,11 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       entries,
       launchId,
       clientSeq,
-      producerFactId
+      producerFactId,
+      observedAtMs,
+      isHeartbeat: false
     });
-    this.recordActivityProducedTrace(agentId, activityKind, detail, detailKind, entries, ap, launchId, clientSeq, producerFactId);
+    this.recordActivityProducedTrace(agentId, activityKind, detail, detailKind, entries, ap, launchId, clientSeq, producerFactId, false);
     if (ap) {
       ap.lastActivityKind = activityKind;
       ap.lastActivity = activityDisplay;
@@ -18270,6 +18632,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
             const heartbeatLaunchId = launchIdOverride || ap.launchId || void 0;
             const heartbeatClientSeq = this.nextActivityClientSeq(agentId);
             const heartbeatProducerFactId = this.buildActivityProducerFactId(agentId, heartbeatLaunchId, heartbeatClientSeq);
+            const heartbeatObservedAtMs = Date.now();
             this.sendToServer({
               type: "agent:activity",
               agentId,
@@ -18279,9 +18642,13 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               detailKind: ap.lastActivityDetailKind,
               launchId: heartbeatLaunchId,
               clientSeq: heartbeatClientSeq,
-              producerFactId: heartbeatProducerFactId
+              producerFactId: heartbeatProducerFactId,
+              observedAtMs: heartbeatObservedAtMs,
+              // The one knowing site: this timer re-broadcasts stale
+              // lastActivity, so it declares its replay provenance.
+              isHeartbeat: true
             });
-            this.recordActivityProducedTrace(agentId, ap.lastActivityKind, ap.lastActivityDetail, ap.lastActivityDetailKind, [], ap, heartbeatLaunchId, heartbeatClientSeq, heartbeatProducerFactId);
+            this.recordActivityProducedTrace(agentId, ap.lastActivityKind, ap.lastActivityDetail, ap.lastActivityDetailKind, [], ap, heartbeatLaunchId, heartbeatClientSeq, heartbeatProducerFactId, true);
           }, ACTIVITY_HEARTBEAT_MS);
           ap.activityHeartbeat = { kind: "active", timer };
         }
@@ -18290,7 +18657,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       }
     }
   }
-  recordActivityProducedTrace(agentId, activityKind, detail, detailKind, entries, ap, launchId, clientSeq, producerFactId) {
+  recordActivityProducedTrace(agentId, activityKind, detail, detailKind, entries, ap, launchId, clientSeq, producerFactId, isHeartbeat) {
     const runtimeContext = ap?.config.runtimeContext;
     this.recordDaemonTrace("daemon.agent.activity.produced", {
       agentId,
@@ -18312,6 +18679,11 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       client_seq_present: typeof clientSeq === "number",
       producerFactId,
       producer_fact_id: producerFactId,
+      // #460 V1: the wire's producer-declared replay-provenance bit must be
+      // independently verifiable from daemon-side evidence (L2<->L3 seam);
+      // closed boolean, mirrors the agent:activity isHeartbeat field exactly.
+      isHeartbeat,
+      is_heartbeat: isHeartbeat,
       correlation_id: `agent:${agentId}:daemonActivity:${launchId ?? "legacy"}:${clientSeq ?? "unsequenced"}`,
       session_id_present: Boolean(ap?.sessionId),
       runtime: ap?.config.runtime
@@ -18360,9 +18732,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       launchId,
       probeId,
       clientSeq,
-      producerFactId
+      producerFactId,
+      isHeartbeat: false
     });
-    this.recordActivityProducedTrace(agentId, activityKind, detail, detailKind, [], ap, launchId, clientSeq, producerFactId);
+    this.recordActivityProducedTrace(agentId, activityKind, detail, detailKind, [], ap, launchId, clientSeq, producerFactId, false);
   }
   flushPendingTrajectory(agentId) {
     const ap = this.agents.get(agentId);
@@ -18546,12 +18919,29 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     }
     this.commitApmIdleState(agentId, ap, false);
   }
-  interruptCompactionIfActive(agentId) {
+  interruptCompactionIfActive(agentId, options = {}) {
     const ap = this.agents.get(agentId);
-    if (!ap || ap.compaction.kind !== "active" && !ap.gatedSteering.compacting) return;
+    if (!ap || ap.compaction.kind !== "active" && !ap.gatedSteering.compacting) return false;
     this.clearCompactionWatchdog(ap);
     const reduction = reduceApmGatedCompaction(ap.gatedSteering, { kind: "compaction_interrupted" });
-    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
+    this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState, { event: "compaction_interrupted" });
+    if (options.traceAttrs) {
+      this.recordRuntimeTraceEvent(agentId, ap, "runtime.context_compaction.interrupted", options.traceAttrs);
+    }
+    if (options.detail) {
+      this.broadcastActivity(
+        agentId,
+        "error",
+        options.detail,
+        options.entries ?? [],
+        void 0,
+        options.detailKind ?? "runtime_error"
+      );
+    }
+    if (options.flushBoundaryMessages) {
+      this.flushCompactionBoundaryMessages(agentId, ap);
+    }
+    return true;
   }
   flushReviewBoundaryMessages(agentId, ap) {
     const reduction = reduceApmGatedReviewBoundaryFlush(ap.gatedSteering, {
@@ -19279,6 +19669,17 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     if (event.kind === "delivery_error") {
       if (ap) {
         this.restoreRuntimeDeliveryAfterAsyncRejection(agentId, ap, event);
+        this.interruptCompactionIfActive(agentId, {
+          detail: `Context compaction interrupted after runtime delivery failed: ${event.message}`,
+          entries: [{ kind: "text", text: `Error: ${event.message}` }],
+          flushBoundaryMessages: true,
+          traceAttrs: {
+            reason: "delivery_error",
+            request_method: event.requestMethod,
+            source: event.source,
+            payloadBytes: event.payloadBytes
+          }
+        });
       } else {
         this.recordDaemonTrace("daemon.agent.delivery_error.received_without_process", {
           agentId,
@@ -21302,6 +21703,563 @@ function assertLegacyDaemonKeyNotAdoptedByComputer(options) {
   if (match) throw new LegacyDaemonKeyAdoptedByComputerError(match);
 }
 
+// src/agentMigrationExport.ts
+import { createHash as createHash7 } from "crypto";
+import { createReadStream } from "fs";
+import { lstat as lstat2, readdir as readdir4, readFile as readFile3, readlink } from "fs/promises";
+import path19 from "path";
+var AGENT_MIGRATION_BUNDLE_SCHEMA_VERSION = "agent-bundle/v1";
+var REGENERABLE_DIRECTORY_NAMES = [
+  ".venv",
+  "__pycache__",
+  "dist",
+  "node_modules",
+  "target"
+];
+var SECRET_FILE_NAMES = /* @__PURE__ */ new Set([
+  ".env",
+  ".env.local",
+  ".env.development",
+  ".env.production",
+  ".env.test",
+  "credentials.json",
+  "credential.json"
+]);
+var ENV_KEY_PATTERN = /^\s*(?:export\s+)?([A-Za-z_][A-Za-z0-9_]*)\s*=/;
+async function buildAgentMigrationExportManifest(input) {
+  const slockHome = path19.resolve(input.slockHome);
+  const workspace = path19.resolve(input.workspacePath ?? path19.join(slockHome, "agents", input.agentId));
+  const proposedIncludes = normalizeProposalPaths(input.cooperativeManifest?.include, workspace, "include");
+  const proposedRegenerableExcludes = normalizeProposalPaths(input.cooperativeManifest?.exclude_regenerable, workspace, "exclude_regenerable");
+  const cleanedProposal = normalizeProposalPaths(input.cooperativeManifest?.cleaned, workspace, "cleaned");
+  const state = {
+    workspace,
+    files: [],
+    excludedRegenerable: [],
+    promotedIncludes: [],
+    proposalRefusals: [
+      ...proposedIncludes.refusals,
+      ...proposedRegenerableExcludes.refusals,
+      ...cleanedProposal.refusals
+    ],
+    unreachable: [],
+    secretsDisclosed: [],
+    seenWorkspacePaths: /* @__PURE__ */ new Set(),
+    explicitIncludePaths: new Set(proposedIncludes.paths)
+  };
+  await walkWorkspace(workspace, "", new Set(proposedRegenerableExcludes.paths), state, { forceIncludeRegenerable: false });
+  for (const requestedPath of proposedIncludes.paths) {
+    if (!state.seenWorkspacePaths.has(requestedPath)) {
+      await includeWorkspacePath(requestedPath, state, { forceIncludeRegenerable: true });
+    }
+  }
+  for (const requestedPath of proposedRegenerableExcludes.paths) {
+    if (isRegenerablePath(requestedPath)) continue;
+    state.promotedIncludes.push({ path: requestedPath, reason: "exclude_not_regenerable" });
+    await includeWorkspacePath(requestedPath, state, { forceIncludeRegenerable: true });
+  }
+  const crossTreeRefs = await buildCrossTreeRefs(input.runtimeSessionRefs ?? []);
+  const secretDisclosureProposal = normalizeProposalPaths(input.cooperativeManifest?.secrets_disclosed, workspace, "secrets_disclosed");
+  state.proposalRefusals.push(...secretDisclosureProposal.refusals);
+  return {
+    schemaVersion: AGENT_MIGRATION_BUNDLE_SCHEMA_VERSION,
+    agentId: input.agentId,
+    mode: input.mode,
+    createdAt: (input.now ?? /* @__PURE__ */ new Date()).toISOString(),
+    roots: {
+      slockHome,
+      workspace
+    },
+    defaults: {
+      unknownFiles: "include",
+      excludePolicy: "regenerable_only",
+      regenerableDirectoryNames: [...REGENERABLE_DIRECTORY_NAMES]
+    },
+    files: sortBundleEntries(state.files),
+    excludedRegenerable: sortByPath(state.excludedRegenerable),
+    promotedIncludes: sortByPath(state.promotedIncludes),
+    proposalRefusals: sortByPath(state.proposalRefusals),
+    unreachable: sortByPath(state.unreachable),
+    secretsDisclosed: sortByPath([
+      ...state.secretsDisclosed,
+      ...normalizeProvidedSecretDisclosures(secretDisclosureProposal.paths)
+    ]),
+    cleaned: cleanedProposal.paths,
+    crossTreeRefs: crossTreeRefs.sort((a, b) => a.bundlePath.localeCompare(b.bundlePath))
+  };
+}
+async function walkWorkspace(root, relativeDir, proposedRegenerableExcludes, state, opts) {
+  const absoluteDir = path19.join(root, relativeDir);
+  let entries;
+  try {
+    entries = await readdir4(absoluteDir, { withFileTypes: true });
+  } catch {
+    state.unreachable.push({
+      path: relativeDir || ".",
+      sourcePath: absoluteDir,
+      reason: "read_error"
+    });
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    const relativePath = toPosixPath(path19.join(relativeDir, entry.name));
+    if (entry.isDirectory()) {
+      if (!opts.forceIncludeRegenerable && isRegenerablePath(relativePath)) {
+        if (state.explicitIncludePaths.has(relativePath)) {
+          await walkWorkspace(root, relativePath, proposedRegenerableExcludes, state, { forceIncludeRegenerable: true });
+          continue;
+        }
+        if (hasExplicitIncludeDescendant(relativePath, state.explicitIncludePaths)) {
+          await walkWorkspace(root, relativePath, proposedRegenerableExcludes, state, opts);
+          continue;
+        }
+        state.excludedRegenerable.push({
+          path: relativePath,
+          reason: proposedRegenerableExcludes.has(relativePath) ? "cooperative_exclude_regenerable" : "regenerable_default",
+          regenerableHint: `${entry.name} is treated as rebuildable/installable state and is not bundled by default`
+        });
+        continue;
+      }
+      await walkWorkspace(root, relativePath, proposedRegenerableExcludes, state, opts);
+      continue;
+    }
+    await includeWorkspacePath(relativePath, state, { forceIncludeRegenerable: opts.forceIncludeRegenerable });
+  }
+}
+async function includeWorkspacePath(workspaceRelativePath, state, opts) {
+  const normalizedRelativePath = normalizeRelativePath(workspaceRelativePath);
+  if (state.seenWorkspacePaths.has(normalizedRelativePath)) return;
+  const sourcePath = path19.join(state.workspace, normalizedRelativePath);
+  let stat4;
+  try {
+    stat4 = await lstat2(sourcePath);
+  } catch {
+    state.unreachable.push({
+      path: normalizedRelativePath,
+      sourcePath,
+      reason: "missing"
+    });
+    return;
+  }
+  if (stat4.isDirectory()) {
+    if (!opts.forceIncludeRegenerable && isRegenerablePath(normalizedRelativePath)) {
+      state.excludedRegenerable.push({
+        path: normalizedRelativePath,
+        reason: "cooperative_exclude_regenerable",
+        regenerableHint: `${path19.basename(normalizedRelativePath)} is treated as rebuildable/installable state and is not bundled by default`
+      });
+      return;
+    }
+    await walkWorkspace(state.workspace, normalizedRelativePath, /* @__PURE__ */ new Set(), state, opts);
+    return;
+  }
+  state.seenWorkspacePaths.add(normalizedRelativePath);
+  const baseEntry = {
+    source: "workspace",
+    sourcePath,
+    workspaceRelativePath: normalizedRelativePath,
+    bundlePath: `workspace/${normalizedRelativePath}`,
+    mode: stat4.mode,
+    mtimeMs: stat4.mtimeMs
+  };
+  if (stat4.isSymbolicLink()) {
+    state.files.push({
+      ...baseEntry,
+      kind: "symlink",
+      linkTarget: await readlink(sourcePath)
+    });
+    return;
+  }
+  if (!stat4.isFile()) {
+    state.unreachable.push({
+      path: normalizedRelativePath,
+      sourcePath,
+      reason: "unsupported_file_type"
+    });
+    return;
+  }
+  const secretShapes = await detectSecretShapes(sourcePath, normalizedRelativePath);
+  if (secretShapes.length > 0) {
+    state.secretsDisclosed.push({ path: normalizedRelativePath, shapes: secretShapes });
+  }
+  state.files.push({
+    ...baseEntry,
+    kind: "file",
+    sizeBytes: stat4.size,
+    sha256: await sha256File(sourcePath),
+    secretShapes: secretShapes.length > 0 ? secretShapes : void 0
+  });
+}
+async function buildCrossTreeRefs(refs) {
+  const result = [];
+  for (const ref of refs) {
+    const sourcePath = path19.resolve(ref.path);
+    const bundlePath = `runtime/${safeBundleSegment(ref.runtime)}/${safeBundleSegment(ref.label)}/${safeBundleSegment(path19.basename(sourcePath) || "session")}`;
+    const entry = {
+      runtime: ref.runtime,
+      label: ref.label,
+      sourcePath,
+      bundlePath,
+      reachable: ref.reachable !== false,
+      reason: ref.reason
+    };
+    try {
+      const stat4 = await lstat2(sourcePath);
+      if (stat4.isFile()) {
+        entry.sizeBytes = stat4.size;
+        entry.sha256 = await sha256File(sourcePath);
+      }
+    } catch {
+      entry.reachable = false;
+    }
+    result.push(entry);
+  }
+  return result;
+}
+async function sha256File(filePath) {
+  const hash = createHash7("sha256");
+  await new Promise((resolve, reject) => {
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", resolve);
+  });
+  return hash.digest("hex");
+}
+async function detectSecretShapes(sourcePath, relativePath) {
+  const basename = path19.basename(relativePath);
+  const lowerBasename = basename.toLowerCase();
+  const shapes = /* @__PURE__ */ new Set();
+  if (SECRET_FILE_NAMES.has(lowerBasename) || lowerBasename.startsWith(".env.")) {
+    shapes.add(`file:${basename}`);
+    try {
+      const text = await readFile3(sourcePath, "utf8");
+      for (const line of text.split(/\r?\n/)) {
+        const match = ENV_KEY_PATTERN.exec(line);
+        if (match) shapes.add(`env:${match[1]}`);
+      }
+    } catch {
+      shapes.add("content:unreadable");
+    }
+  }
+  if (/(?:secret|token|credential|api[-_]?key)/i.test(relativePath)) {
+    shapes.add(`path:${basename}`);
+  }
+  return [...shapes].sort();
+}
+function normalizeProvidedSecretDisclosures(disclosures) {
+  return disclosures.map((entry) => ({
+    path: entry,
+    shapes: ["provided"]
+  }));
+}
+function normalizeProposalPaths(paths, workspace, source) {
+  if (!paths) return { paths: [], refusals: [] };
+  const result = [];
+  const refusals = [];
+  for (const value of paths) {
+    const trimmed = value.trim();
+    if (!trimmed) continue;
+    if (path19.isAbsolute(trimmed)) {
+      const relative = path19.relative(workspace, trimmed);
+      if (relative.startsWith("..") || path19.isAbsolute(relative)) {
+        refusals.push({
+          path: trimmed,
+          reason: "outside_workspace",
+          source
+        });
+        continue;
+      }
+      try {
+        result.push(normalizeRelativePath(relative));
+      } catch {
+        refusals.push({
+          path: trimmed,
+          reason: "unsafe_path",
+          source
+        });
+      }
+      continue;
+    }
+    try {
+      result.push(normalizeRelativePath(trimmed));
+    } catch {
+      refusals.push({
+        path: trimmed,
+        reason: "unsafe_path",
+        source
+      });
+    }
+  }
+  return { paths: [...new Set(result)], refusals };
+}
+function normalizeRelativePath(value) {
+  const normalized = path19.normalize(value).replace(/^[\\/]+/, "");
+  if (!normalized || normalized === "." || normalized.startsWith("..") || path19.isAbsolute(normalized)) {
+    throw new Error(`unsafe migration export path: ${value}`);
+  }
+  return toPosixPath(normalized);
+}
+function isRegenerablePath(relativePath) {
+  return normalizeRelativePath(relativePath).split("/").some((segment) => REGENERABLE_DIRECTORY_NAMES.includes(segment));
+}
+function hasExplicitIncludeDescendant(relativePath, explicitIncludePaths) {
+  const prefix = `${relativePath}/`;
+  for (const includePath of explicitIncludePaths) {
+    if (includePath.startsWith(prefix)) return true;
+  }
+  return false;
+}
+function safeBundleSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "") || "unknown";
+}
+function toPosixPath(value) {
+  return value.split(path19.sep).join("/");
+}
+function sortBundleEntries(entries) {
+  return [...entries].sort((a, b) => a.bundlePath.localeCompare(b.bundlePath));
+}
+function sortByPath(entries) {
+  return [...entries].sort((a, b) => a.path.localeCompare(b.path));
+}
+
+// src/agentMigrationHttpTransport.ts
+import { createHash as createHash8, randomBytes as randomBytes2, timingSafeEqual } from "crypto";
+import http2 from "http";
+var MigrationBundleStreamError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+  }
+};
+var AgentMigrationGrantRegistry = class {
+  grants = /* @__PURE__ */ new Map();
+  now;
+  constructor(now = () => /* @__PURE__ */ new Date()) {
+    this.now = now;
+  }
+  createGrant(input) {
+    const token = input.token ?? randomBytes2(32).toString("base64url");
+    const manifestSha256 = sha256Buffer(canonicalJsonBuffer(input.manifest));
+    const grant = {
+      grantId: input.grantId ?? randomBytes2(16).toString("hex"),
+      tokenHash: hashToken(token),
+      expiresAt: input.expiresAt,
+      oneTimeUse: input.oneTimeUse ?? true,
+      state: "issued",
+      manifest: input.manifest,
+      manifestSha256,
+      bundleEtag: `"agent-migration-${manifestSha256}"`
+    };
+    this.grants.set(grant.grantId, grant);
+    return { grant, token };
+  }
+  get(grantId) {
+    return this.grants.get(grantId);
+  }
+  authenticate(grantId, token) {
+    const grant = this.grants.get(grantId);
+    if (!grant || !token || !verifyTokenHash(token, grant.tokenHash)) {
+      return { ok: false, status: 401, code: "migration_grant_auth_failed" };
+    }
+    if (grant.state === "revoked" || grant.state === "consumed") {
+      return { ok: false, status: 410, code: "migration_grant_unavailable" };
+    }
+    if (this.now().getTime() >= grant.expiresAt.getTime()) {
+      grant.state = "expired";
+      return { ok: false, status: 410, code: "migration_grant_unavailable" };
+    }
+    return { ok: true, grant };
+  }
+  revokeAll() {
+    for (const grant of this.grants.values()) {
+      if (grant.state !== "consumed" && grant.state !== "expired") {
+        grant.state = "revoked";
+      }
+    }
+  }
+};
+function createAgentMigrationHttpTransport(options = {}) {
+  const registry = new AgentMigrationGrantRegistry(options.now);
+  const bundleStreamFactory = options.bundleStreamFactory ?? defaultBundleStream;
+  const server = http2.createServer((req, res) => {
+    void handleMigrationRequest(req, res, registry, bundleStreamFactory);
+  });
+  return {
+    grants: registry,
+    server,
+    listen: (port = 0, host = "127.0.0.1") => new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(port, host, () => {
+        server.off("error", reject);
+        const address = server.address();
+        if (!address || typeof address === "string") {
+          reject(new Error("migration transport listen did not produce a TCP address"));
+          return;
+        }
+        resolve({ url: `http://${address.address}:${address.port}` });
+      });
+    }),
+    close: () => new Promise((resolve, reject) => {
+      registry.revokeAll();
+      server.close((err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    })
+  };
+}
+async function handleMigrationRequest(req, res, registry, bundleStreamFactory) {
+  const parsed = new URL(req.url ?? "/", "http://127.0.0.1");
+  const match = /^\/migration\/([^/]+)\/([^/]+)(?:\/([^/]+))?$/.exec(parsed.pathname);
+  if (!match) {
+    sendJson(res, 404, { code: "migration_route_not_found" });
+    return;
+  }
+  const [, grantId, resource, resourceId] = match;
+  const auth = registry.authenticate(decodeURIComponent(grantId), extractBearerToken(req));
+  if (!auth.ok) {
+    sendJson(res, auth.status, { code: auth.code });
+    return;
+  }
+  if (resource === "manifest" && req.method === "GET" && !resourceId) {
+    sendJson(res, 200, {
+      manifestSha256: auth.grant.manifestSha256,
+      manifest: auth.grant.manifest
+    }, {
+      "X-Raft-Manifest-Sha": auth.grant.manifestSha256,
+      ETag: `"manifest-${auth.grant.manifestSha256}"`
+    });
+    return;
+  }
+  if (resource === "bundle.tar" && !resourceId) {
+    if (req.method === "HEAD") {
+      sendHead(res, auth.grant);
+      return;
+    }
+    if (req.method === "GET") {
+      await streamBundle(res, auth.grant, bundleStreamFactory);
+      return;
+    }
+  }
+  if (resource === "chunk" && req.method === "GET" && resourceId) {
+    sendJson(res, 501, { code: "migration_chunk_not_implemented" });
+    return;
+  }
+  sendJson(res, 405, { code: "migration_method_not_allowed" });
+}
+function sendHead(res, grant) {
+  res.statusCode = 200;
+  res.setHeader("X-Raft-Manifest-Sha", grant.manifestSha256);
+  res.setHeader("ETag", grant.bundleEtag);
+  res.setHeader("Accept-Ranges", "none");
+  res.setHeader("X-Raft-Bundle-Size", "unknown");
+  res.end();
+}
+async function streamBundle(res, grant, bundleStreamFactory) {
+  if (grant.state === "streaming") {
+    sendJson(res, 409, { code: "migration_bundle_stream_in_progress" });
+    return;
+  }
+  if (grant.oneTimeUse && grant.state !== "issued" && grant.state !== "interrupted") {
+    sendJson(res, 410, { code: "migration_grant_unavailable" });
+    return;
+  }
+  let stream;
+  try {
+    stream = bundleStreamFactory(grant);
+  } catch (err) {
+    const code = err instanceof MigrationBundleStreamError ? err.code : "migration_bundle_stream_failed";
+    sendJson(res, 500, { code });
+    return;
+  }
+  grant.state = "streaming";
+  let completed = false;
+  res.on("close", () => {
+    if (!completed && grant.state === "streaming") {
+      grant.state = "interrupted";
+    }
+  });
+  try {
+    res.statusCode = 200;
+    res.setHeader("Content-Type", "application/x-tar");
+    res.setHeader("X-Raft-Manifest-Sha", grant.manifestSha256);
+    res.setHeader("ETag", grant.bundleEtag);
+    for await (const chunk of stream) {
+      if (!res.write(chunk)) {
+        await onceDrain(res);
+      }
+    }
+    completed = true;
+    grant.state = "consumed";
+    res.end();
+  } catch {
+    if (!completed && grant.state === "streaming") {
+      grant.state = "interrupted";
+    }
+    if (!res.headersSent) {
+      sendJson(res, 500, { code: "migration_bundle_stream_failed" });
+    } else {
+      res.destroy();
+    }
+  }
+}
+function defaultBundleStream(grant) {
+  void grant;
+  throw new MigrationBundleStreamError("migration_bundle_stream_not_wired");
+}
+function extractBearerToken(req) {
+  const directHeader = singleHeader(req.headers["x-raft-migration-token"]);
+  if (directHeader) return directHeader;
+  const authorization = singleHeader(req.headers.authorization);
+  if (!authorization) return null;
+  const match = /^Bearer\s+(.+)$/i.exec(authorization);
+  return match?.[1] ?? null;
+}
+function singleHeader(value) {
+  if (!value) return null;
+  return Array.isArray(value) ? value[0] ?? null : value;
+}
+function sendJson(res, status, body, headers = {}) {
+  const payload = JSON.stringify(body);
+  res.writeHead(status, {
+    "Content-Type": "application/json",
+    "Content-Length": Buffer.byteLength(payload).toString(),
+    ...headers
+  });
+  res.end(payload);
+}
+function hashToken(token) {
+  return sha256Buffer(Buffer.from(token, "utf8"));
+}
+function verifyTokenHash(token, expectedHashHex) {
+  const actual = Buffer.from(hashToken(token), "hex");
+  const expected = Buffer.from(expectedHashHex, "hex");
+  if (actual.byteLength !== expected.byteLength) return false;
+  return timingSafeEqual(actual, expected);
+}
+function sha256Buffer(buffer) {
+  return createHash8("sha256").update(buffer).digest("hex");
+}
+function canonicalJsonBuffer(value) {
+  return Buffer.from(canonicalJson(value), "utf8");
+}
+function canonicalJson(value) {
+  return JSON.stringify(sortJsonValue(value));
+}
+function sortJsonValue(value) {
+  if (Array.isArray(value)) return value.map(sortJsonValue);
+  if (!value || typeof value !== "object") return value;
+  return Object.keys(value).sort().reduce((result, key) => {
+    result[key] = sortJsonValue(value[key]);
+    return result;
+  }, {});
+}
+function onceDrain(res) {
+  return new Promise((resolve) => res.once("drain", resolve));
+}
+
 // src/core.ts
 var DEFAULT_TRACE_UPLOAD_URL = "https://slock-trace-upload.botiverse.dev";
 var RUNNER_CREDENTIAL_SCOPES = ["send", "read", "mentions", "tasks", "reactions", "server", "channels", "knowledge"];
@@ -21409,7 +22367,17 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["running_agents_count", "idle_agents_count"]
   },
   "daemon.agent.activity.produced": {
-    spanAttrs: ["agentId", "agent_id", "server_id", "machine_id", "activity", "detail_present", "entry_kinds", "ap_present", "launchId", "launch_id", "launch_id_present", "clientSeq", "client_seq", "client_seq_present", "correlation_id", "session_id_present", "runtime"]
+    // isHeartbeat/is_heartbeat (#460 V1) and process_instance_id (#460 V3)
+    // were emitted by agentProcessManager but scrubbed here (pilot violation
+    // V4): this list is a RUNTIME allowlist (SpanAttrContractTracer), so an
+    // emission-site key that is not added here silently dies before disk.
+    // Witness for the pair lives in agentProcessManager.builtin.e2e.test.ts
+    // behind a contract-wrapped tracer (production-isomorphic oracle).
+    // producerFactId/producer_fact_id and activity_kind/detail_kind are ALSO
+    // emitted-and-scrubbed today; deliberately NOT added here — banned-join-
+    // key discipline for the fact id (#460 classification ruling) means
+    // widening needs its own ruling, not a drive-by.
+    spanAttrs: ["agentId", "agent_id", "server_id", "machine_id", "activity", "detail_present", "entry_kinds", "ap_present", "launchId", "launch_id", "launch_id_present", "clientSeq", "client_seq", "client_seq_present", "correlation_id", "session_id_present", "runtime", "isHeartbeat", "is_heartbeat", "process_instance_id"]
   },
   "daemon.agent.activity.skipped": {
     spanAttrs: ["agentId", "event_kind", "reason", "text_length"]
@@ -21418,7 +22386,7 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
     spanAttrs: ["agentId", "event_kind", "runtime"]
   }
 };
-var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
+var DAEMON_CLI_USAGE = `Usage: slock-daemon --server-url <url> (--api-key <key> or ${DAEMON_API_KEY_ENV}=<key>)`;
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -21454,9 +22422,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args) {
+function parseDaemonCliArgs(args, env = {}) {
   let serverUrl = "";
-  let apiKey = "";
+  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
   for (let i = 0; i < args.length; i++) {
     if (args[i] === "--server-url" && args[i + 1]) serverUrl = args[++i];
     if (args[i] === "--api-key" && args[i + 1]) apiKey = args[++i];
@@ -21473,13 +22441,13 @@ function readDaemonVersion(moduleUrl = import.meta.url) {
   }
 }
 function resolveSlockCliPath(moduleUrl = import.meta.url) {
-  const thisDir = path19.dirname(fileURLToPath(moduleUrl));
-  const bundledDistPath = path19.resolve(thisDir, "cli", "index.js");
+  const thisDir = path20.dirname(fileURLToPath(moduleUrl));
+  const bundledDistPath = path20.resolve(thisDir, "cli", "index.js");
   try {
     accessSync(bundledDistPath);
     return bundledDistPath;
   } catch {
-    const workspaceDistPath = path19.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
+    const workspaceDistPath = path20.resolve(thisDir, "..", "..", "cli", "dist", "index.js");
     accessSync(workspaceDistPath);
     return workspaceDistPath;
   }
@@ -21493,7 +22461,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-P3SAWND7.js");
+  await import("./dist-PAW4LJQD.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -21701,7 +22669,7 @@ var DaemonCore = class {
   }
   resolveMachineStateRoot() {
     if (this.options.machineStateDir) return this.options.machineStateDir;
-    if (this.options.dataDir) return path19.join(path19.dirname(this.options.dataDir), "machines");
+    if (this.options.dataDir) return path20.join(path20.dirname(this.options.dataDir), "machines");
     return resolveDefaultMachineStateRoot();
   }
   shouldEnableLocalTrace() {
@@ -21729,7 +22697,7 @@ var DaemonCore = class {
       sinks: [this.localTraceSink]
     }));
     this.agentManager.setTracer(this.tracer);
-    this.agentManager.setCliTransportTraceDir(path19.join(machineDir, "traces"));
+    this.agentManager.setCliTransportTraceDir(path20.join(machineDir, "traces"));
   }
   installTraceBundleUploader(machineDir) {
     if (!this.shouldEnableLocalTrace()) return;
@@ -22018,7 +22986,7 @@ var DaemonCore = class {
             session_id_present: Boolean(msg.config.sessionId)
           }, "error");
           this.connection.send({ type: "agent:status", agentId: msg.agentId, status: "inactive", launchId: msg.launchId });
-          this.connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: classification.userMessage, launchId: msg.launchId });
+          this.connection.send({ type: "agent:activity", agentId: msg.agentId, activity: "offline", detail: classification.userMessage, launchId: msg.launchId, observedAtMs: Date.now() });
         });
         break;
       case "agent:stop":
@@ -22435,9 +23403,15 @@ var DaemonCore = class {
 
 export {
   subscribeDaemonLogs,
+  DAEMON_API_KEY_ENV,
+  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,
+  AGENT_MIGRATION_BUNDLE_SCHEMA_VERSION,
+  buildAgentMigrationExportManifest,
+  AgentMigrationGrantRegistry,
+  createAgentMigrationHttpTransport,
   DAEMON_CORE_TRACE_ATTR_CONTRACTS,
   DAEMON_CLI_USAGE,
   parseDaemonCliArgs,