@botiverse/raft-daemon 0.63.7-play.20260628145435 → 0.64.0

package/dist/{chunk-GY4WDH5I.js → chunk-ILFE5NTJ.js}

@@ -1698,6 +1698,10 @@ function summarizeToolInput(toolName, input) {
 // ../shared/src/attachmentPreview.ts
 var CSV_PREVIEW_MAX_FILE_SIZE_BYTES = 5 * 1024 * 1024;
 
+// ../shared/src/brandedIds.ts
+var asMessageId = (id) => id;
+var asChannelId = (id) => id;
+
 // ../shared/src/actionCards.ts
 import { z } from "zod";
 var uuidSchema = z.uuid();
@@ -1808,6 +1812,11 @@ var optionalNumberSchema = z2.number().finite().optional();
 var nullableStringSchema = z2.string().nullable();
 var nullableNumberSchema = z2.number().finite().nullable();
 var optionalIsoTimestampSchema = z2.string().datetime().optional();
+var agentStatusSchema = z2.enum(["active", "inactive", "stopped"]);
+var reminderStatusSchema = z2.enum(["scheduled", "fired", "canceled"]);
+var reminderEventTypeSchema = z2.enum(["scheduled", "fired", "snoozed", "updated", "canceled"]);
+var reasoningEffortSchema = z2.enum(["low", "medium", "high", "xhigh"]);
+var profileVisibilityMembershipStatusSchema = z2.enum(["active", "removed"]);
 var passthroughObject = (shape) => z2.object(shape).passthrough();
 var taskStatusSchema = z2.enum(["todo", "in_progress", "in_review", "done", "closed"]);
 var agentApiEventsQuerySchema = passthroughObject({
@@ -1821,6 +1830,17 @@ var agentApiHistoryQuerySchema = passthroughObject({
   around: optionalStringSchema,
   limit: optionalStringSchema
 });
+var agentApiMessageSearchQuerySchema = passthroughObject({
+  q: optionalStringSchema,
+  channel: optionalStringSchema,
+  sender: optionalStringSchema,
+  senderId: optionalStringSchema,
+  sort: z2.enum(["relevance", "recent"]).optional(),
+  before: optionalStringSchema,
+  after: optionalStringSchema,
+  limit: optionalStringSchema,
+  offset: optionalStringSchema
+});
 var agentApiSendBodySchema = passthroughObject({
   target: z2.string().optional(),
   content: z2.string().optional(),
@@ -1834,10 +1854,10 @@ var agentApiSendBodySchema = passthroughObject({
   seenUpToSeq: optionalNumberSchema
 });
 var agentApiMessageResolveParamsSchema = passthroughObject({
-  msgId: z2.string().trim().min(1)
+  msgId: z2.string().trim().min(1).transform(asMessageId)
 });
 var agentApiMessageReactionParamsSchema = passthroughObject({
-  msgId: z2.string().trim().min(1)
+  msgId: z2.string().trim().min(1).transform(asMessageId)
 });
 var agentApiMessageReactionBodySchema = passthroughObject({
   emoji: z2.string().trim().min(1).max(16).refine((value) => !/\s/.test(value), {
@@ -1845,8 +1865,20 @@ var agentApiMessageReactionBodySchema = passthroughObject({
   })
 });
 var agentApiChannelMembershipParamsSchema = passthroughObject({
+  channelId: z2.string().trim().min(1).transform(asChannelId)
+});
+var agentApiChannelMembersQuerySchema = passthroughObject({
+  channel: z2.string().trim().min(1)
+});
+var agentApiResolveChannelBodySchema = passthroughObject({
+  target: z2.string().trim().min(1)
+});
+var agentApiResolveChannelResponseSchema = passthroughObject({
   channelId: z2.string().trim().min(1)
 });
+var agentApiThreadUnfollowBodySchema = passthroughObject({
+  thread: z2.string().trim().min(1)
+});
 var agentApiTaskClaimBodySchema = passthroughObject({
   channel: z2.string().trim().min(1),
   task_numbers: z2.array(z2.number().int().positive()).optional(),
@@ -1871,6 +1903,128 @@ var agentApiTaskUpdateStatusBodySchema = passthroughObject({
   task_number: z2.number().int().positive(),
   status: taskStatusSchema
 });
+var agentApiReminderListQuerySchema = passthroughObject({
+  status: optionalStringSchema,
+  all: optionalStringSchema
+});
+var agentApiReminderParamsSchema = passthroughObject({
+  reminderId: z2.string().trim().min(1)
+});
+var agentApiReminderScheduleBodySchema = passthroughObject({
+  title: z2.string(),
+  fireAt: optionalStringSchema,
+  delaySeconds: optionalNumberSchema,
+  msgId: z2.string().nullable().optional(),
+  payload: z2.unknown().optional(),
+  repeat: optionalStringSchema,
+  tz: optionalStringSchema,
+  channel: optionalStringSchema
+});
+var agentApiReminderSnoozeBodySchema = passthroughObject({
+  delaySeconds: z2.number().finite()
+});
+var agentApiReminderUpdateBodySchema = passthroughObject({
+  fireAt: optionalStringSchema,
+  delaySeconds: optionalNumberSchema,
+  repeat: optionalStringSchema,
+  title: optionalStringSchema,
+  tz: optionalStringSchema
+});
+var agentApiProfileShowQuerySchema = passthroughObject({
+  target: optionalStringSchema
+});
+var agentApiProfileUpdateBodySchema = passthroughObject({
+  avatarUrl: optionalStringSchema,
+  displayName: optionalStringSchema,
+  description: optionalStringSchema
+});
+var agentApiProfileCreatedAgentSchema = passthroughObject({
+  id: z2.string(),
+  name: z2.string(),
+  displayName: nullableStringSchema,
+  avatarUrl: nullableStringSchema,
+  runtime: z2.string(),
+  status: agentStatusSchema
+});
+var agentApiProfileCreatorSchema = z2.union([
+  passthroughObject({
+    type: z2.literal("human"),
+    id: z2.string(),
+    name: z2.string(),
+    displayName: nullableStringSchema,
+    avatarUrl: nullableStringSchema,
+    gravatarHash: z2.string()
+  }),
+  passthroughObject({
+    type: z2.literal("agent"),
+    id: z2.string(),
+    name: z2.string(),
+    displayName: nullableStringSchema,
+    avatarUrl: nullableStringSchema,
+    deletedAt: nullableStringSchema
+  })
+]);
+var agentApiProfileViewSchema = z2.discriminatedUnion("kind", [
+  passthroughObject({
+    kind: z2.literal("human"),
+    id: z2.string(),
+    isSelf: z2.boolean(),
+    name: z2.string(),
+    displayName: nullableStringSchema,
+    description: nullableStringSchema,
+    avatarUrl: nullableStringSchema,
+    email: nullableStringSchema,
+    role: z2.enum(["owner", "admin", "member"]).nullable(),
+    joinedAt: nullableStringSchema,
+    membershipStatus: profileVisibilityMembershipStatusSchema,
+    createdAgents: z2.array(agentApiProfileCreatedAgentSchema)
+  }),
+  passthroughObject({
+    kind: z2.literal("agent"),
+    id: z2.string(),
+    isSelf: z2.boolean(),
+    name: z2.string(),
+    displayName: nullableStringSchema,
+    description: nullableStringSchema,
+    avatarUrl: nullableStringSchema,
+    status: agentStatusSchema,
+    serverRole: z2.enum(["owner", "admin", "member"]).nullable(),
+    runtime: z2.string(),
+    model: z2.string(),
+    reasoningEffort: reasoningEffortSchema.nullable(),
+    executionMode: nullableStringSchema,
+    computerId: nullableStringSchema,
+    computerName: nullableStringSchema,
+    computerHostname: nullableStringSchema,
+    daemonVersion: nullableStringSchema,
+    creator: agentApiProfileCreatorSchema.nullable(),
+    createdAgents: z2.array(agentApiProfileCreatedAgentSchema),
+    createdAt: z2.string(),
+    deletedAt: nullableStringSchema
+  })
+]);
+var agentApiIntegrationLoginBodySchema = passthroughObject({
+  service: z2.string().trim().min(1),
+  scopes: optionalStringArraySchema,
+  target: optionalStringSchema
+});
+var agentApiIntegrationAppPrepareBodySchema = passthroughObject({
+  mode: z2.enum(["register", "update"]),
+  target: z2.string().trim().min(1),
+  clientKey: z2.string().trim().min(1),
+  name: optionalStringSchema,
+  description: optionalStringSchema,
+  homepageUrl: optionalStringSchema,
+  returnUrl: optionalStringSchema,
+  agentManifestUrl: optionalStringSchema,
+  scopes: optionalStringArraySchema,
+  unsafeDemoUrlOverride: optionalBooleanSchema,
+  draftHint: optionalStringSchema
+});
+var agentApiActionPrepareBodySchema = passthroughObject({
+  target: z2.string().trim().min(1),
+  action: actionCardActionSchema
+});
 var agentApiServerInfoResponseSchema = passthroughObject({
   runtimeContext: passthroughObject({
     agentId: z2.string(),
@@ -1885,7 +2039,7 @@ var agentApiServerInfoResponseSchema = passthroughObject({
   serverRole: z2.string().nullable().optional(),
   serverCapabilities: passthroughObject({}).optional(),
   channels: z2.array(passthroughObject({
-    id: z2.string(),
+    id: z2.string().transform(asChannelId),
     name: z2.string(),
     joined: z2.boolean()
   })),
@@ -1916,10 +2070,69 @@ var agentApiMentionActionsExecuteResponseSchema = passthroughObject({
   action: z2.enum(["notify", "add"]),
   results: z2.array(agentApiMentionActionEnvelopeSchema)
 });
+var agentApiIntegrationServiceSchema = passthroughObject({
+  id: z2.string(),
+  clientId: z2.string(),
+  appType: z2.enum(["server_local", "slock_builtin", "third_party_global"]).optional(),
+  name: z2.string(),
+  description: nullableStringSchema,
+  homepageUrl: nullableStringSchema,
+  returnUrl: nullableStringSchema,
+  agentManifestUrl: nullableStringSchema,
+  agentManifestUrlSource: z2.enum(["explicit", "well_known"]).nullable().optional(),
+  createdAt: z2.string(),
+  updatedAt: z2.string()
+});
+var agentApiActiveIntegrationLoginSchema = passthroughObject({
+  id: z2.string(),
+  serviceId: z2.string(),
+  clientId: z2.string(),
+  appType: z2.enum(["server_local", "slock_builtin", "third_party_global"]).optional(),
+  name: z2.string(),
+  description: nullableStringSchema,
+  homepageUrl: nullableStringSchema,
+  returnUrl: nullableStringSchema,
+  agentManifestUrl: nullableStringSchema,
+  agentManifestUrlSource: z2.enum(["explicit", "well_known"]).nullable().optional(),
+  scopes: z2.array(z2.string()),
+  createdAt: z2.string()
+});
+var agentApiIntegrationListResponseSchema = passthroughObject({
+  services: z2.array(agentApiIntegrationServiceSchema),
+  activeLogins: z2.array(agentApiActiveIntegrationLoginSchema)
+});
+var agentApiIntegrationLoginResponseSchema = passthroughObject({
+  status: z2.enum(["logged_in", "already_logged_in", "approval_required"]),
+  service: agentApiIntegrationServiceSchema,
+  scopes: z2.array(z2.string()),
+  requestId: z2.string(),
+  approval: passthroughObject({
+    requestId: z2.string(),
+    target: nullableStringSchema,
+    actionCardMessageId: nullableStringSchema
+  }).optional()
+});
+var agentApiIntegrationAppPrepareResponseSchema = passthroughObject({
+  status: z2.literal("prepared"),
+  mode: z2.enum(["register", "update"]),
+  target: z2.string(),
+  actionCardMessageId: z2.string(),
+  action: z2.discriminatedUnion("type", [
+    integrationRegisterAppOperationSchema,
+    integrationUpdateAppRegistrationOperationSchema
+  ])
+});
 var agentApiAttachmentEnvelopeSchema = passthroughObject({
   id: z2.string(),
   filename: z2.string()
 });
+var agentApiAttachmentUploadResponseSchema = passthroughObject({
+  id: z2.string().trim().min(1),
+  filename: z2.string(),
+  mimeType: nullableStringSchema,
+  sizeBytes: z2.number().int().nonnegative(),
+  thumbnailUrl: nullableStringSchema
+});
 var agentApiMessageEnvelopeSchema = passthroughObject({
   seq: optionalNumberSchema,
   id: optionalStringSchema,
@@ -2004,6 +2217,46 @@ var agentApiMessageResolveResponseSchema = passthroughObject({
 var agentApiOkResponseSchema = passthroughObject({
   ok: z2.literal(true)
 });
+var agentApiSearchResultSchema = passthroughObject({
+  id: z2.string(),
+  seq: z2.number().int().nonnegative(),
+  channelId: z2.string(),
+  threadId: z2.string().nullable(),
+  parentMessageId: z2.string().nullable(),
+  parentMessageContent: z2.string().nullable(),
+  parentChannelId: z2.string(),
+  parentChannelName: z2.string(),
+  parentChannelType: z2.string(),
+  parentChannelArchivedAt: nullableStringSchema,
+  senderId: z2.string(),
+  senderType: z2.string(),
+  senderName: z2.string(),
+  channelName: z2.string(),
+  channelType: z2.string(),
+  channelArchivedAt: nullableStringSchema,
+  content: z2.string(),
+  snippet: z2.string(),
+  createdAt: z2.string().datetime()
+});
+var agentApiMessageSearchResponseSchema = passthroughObject({
+  results: z2.array(agentApiSearchResultSchema),
+  hasMore: z2.boolean()
+});
+var agentApiChannelMembersResponseSchema = passthroughObject({
+  channel: passthroughObject({
+    ref: z2.string(),
+    type: z2.string()
+  }),
+  agents: z2.array(passthroughObject({
+    name: z2.string(),
+    status: optionalStringSchema
+  })),
+  humans: z2.array(passthroughObject({
+    name: z2.string(),
+    description: z2.string().nullable().optional(),
+    role: optionalStringSchema
+  }))
+});
 var agentApiTaskClaimResultSchema = passthroughObject({
   taskNumber: z2.number().int().positive().optional(),
   messageId: optionalStringSchema,
@@ -2047,6 +2300,48 @@ var agentApiTaskUpdateStatusResponseSchema = z2.union([
   agentApiTaskUpdateStatusSuccessResponseSchema,
   agentApiHeldFreshnessResponseSchema
 ]);
+var agentApiActionPrepareResponseSchema = passthroughObject({
+  messageId: z2.string(),
+  metadata: passthroughObject({
+    kind: z2.literal("action-card")
+  })
+});
+var agentApiReminderRecurrenceSchema = z2.object({
+  kind: z2.enum(["interval", "daily", "weekly", "unsupported"]),
+  description: z2.string()
+});
+var agentApiReminderSummarySchema = z2.object({
+  reminderId: z2.string(),
+  ownerAgentId: z2.string(),
+  title: z2.string(),
+  fireAt: z2.string(),
+  firedAt: nullableStringSchema.optional(),
+  createdAt: z2.string(),
+  status: reminderStatusSchema,
+  msgRef: nullableStringSchema,
+  msgPermalink: nullableStringSchema,
+  recurrence: agentApiReminderRecurrenceSchema.nullable()
+});
+var agentApiReminderEventSummarySchema = z2.object({
+  eventId: z2.string(),
+  reminderId: z2.string(),
+  eventType: reminderEventTypeSchema,
+  actorType: z2.enum(["agent", "human", "system"]),
+  actorId: nullableStringSchema,
+  occurredAt: z2.string(),
+  nextFireAt: nullableStringSchema,
+  metadata: z2.record(z2.string(), z2.unknown()).nullable()
+});
+var agentApiReminderListResponseSchema = passthroughObject({
+  reminders: z2.array(agentApiReminderSummarySchema)
+});
+var agentApiReminderResponseSchema = passthroughObject({
+  reminder: agentApiReminderSummarySchema,
+  warning: optionalStringSchema
+});
+var agentApiReminderLogResponseSchema = passthroughObject({
+  events: z2.array(agentApiReminderEventSummarySchema)
+});
 function route(input) {
   return {
     ...input,
@@ -2094,6 +2389,16 @@ var agentApiContract = {
     request: { params: agentApiMessageResolveParamsSchema },
     response: { body: agentApiMessageResolveResponseSchema }
   }),
+  messageSearch: route({
+    key: "messageSearch",
+    method: "GET",
+    path: "/search",
+    client: { resource: "messages", method: "search" },
+    capability: "read",
+    description: "Search messages visible to the bound agent credential.",
+    request: { query: agentApiMessageSearchQuerySchema },
+    response: { body: agentApiMessageSearchResponseSchema }
+  }),
   messageReactionAdd: route({
     key: "messageReactionAdd",
     method: "POST",
@@ -2134,6 +2439,36 @@ var agentApiContract = {
     request: { params: agentApiChannelMembershipParamsSchema },
     response: { body: agentApiOkResponseSchema }
   }),
+  channelMembers: route({
+    key: "channelMembers",
+    method: "GET",
+    path: "/channel-members",
+    client: { resource: "channels", method: "members" },
+    capability: "channels",
+    description: "List agents and humans in a visible channel, DM, or thread.",
+    request: { query: agentApiChannelMembersQuerySchema },
+    response: { body: agentApiChannelMembersResponseSchema }
+  }),
+  resolveChannel: route({
+    key: "resolveChannel",
+    method: "POST",
+    path: "/resolve-channel",
+    client: { resource: "channels", method: "resolve" },
+    capability: "send",
+    description: "Resolve a writable channel, DM, or thread target for the bound agent credential.",
+    request: { body: agentApiResolveChannelBodySchema },
+    response: { body: agentApiResolveChannelResponseSchema }
+  }),
+  threadUnfollow: route({
+    key: "threadUnfollow",
+    method: "POST",
+    path: "/threads/unfollow",
+    client: { resource: "threads", method: "unfollow" },
+    capability: "channels",
+    description: "Stop ordinary delivery for a followed thread as the bound agent credential.",
+    request: { body: agentApiThreadUnfollowBodySchema },
+    response: { body: agentApiOkResponseSchema }
+  }),
   serverInfo: route({
     key: "serverInfo",
     method: "GET",
@@ -2213,6 +2548,136 @@ var agentApiContract = {
     description: "Update a task status.",
     request: { body: agentApiTaskUpdateStatusBodySchema },
     response: { body: agentApiTaskUpdateStatusResponseSchema }
+  }),
+  reminderList: route({
+    key: "reminderList",
+    method: "GET",
+    path: "/reminders",
+    client: { resource: "reminders", method: "list" },
+    capability: "read",
+    description: "List reminders owned by the bound agent credential.",
+    request: { query: agentApiReminderListQuerySchema },
+    response: { body: agentApiReminderListResponseSchema }
+  }),
+  reminderCreate: route({
+    key: "reminderCreate",
+    method: "POST",
+    path: "/reminders",
+    client: { resource: "reminders", method: "create" },
+    capability: "tasks",
+    description: "Create a reminder owned by the bound agent credential.",
+    request: { body: agentApiReminderScheduleBodySchema },
+    response: { body: agentApiReminderResponseSchema }
+  }),
+  reminderCancel: route({
+    key: "reminderCancel",
+    method: "DELETE",
+    path: "/reminders/:reminderId",
+    client: { resource: "reminders", method: "cancel" },
+    capability: "tasks",
+    description: "Cancel a scheduled or fired reminder owned by the bound agent credential.",
+    request: { params: agentApiReminderParamsSchema },
+    response: { body: agentApiReminderResponseSchema }
+  }),
+  reminderSnooze: route({
+    key: "reminderSnooze",
+    method: "POST",
+    path: "/reminders/:reminderId/snooze",
+    client: { resource: "reminders", method: "snooze" },
+    capability: "tasks",
+    description: "Snooze a scheduled or fired reminder owned by the bound agent credential.",
+    request: { params: agentApiReminderParamsSchema, body: agentApiReminderSnoozeBodySchema },
+    response: { body: agentApiReminderResponseSchema }
+  }),
+  reminderUpdate: route({
+    key: "reminderUpdate",
+    method: "PATCH",
+    path: "/reminders/:reminderId",
+    client: { resource: "reminders", method: "update" },
+    capability: "tasks",
+    description: "Update a scheduled reminder owned by the bound agent credential.",
+    request: { params: agentApiReminderParamsSchema, body: agentApiReminderUpdateBodySchema },
+    response: { body: agentApiReminderResponseSchema }
+  }),
+  reminderLog: route({
+    key: "reminderLog",
+    method: "GET",
+    path: "/reminders/:reminderId/log",
+    client: { resource: "reminders", method: "log" },
+    capability: "read",
+    description: "Read lifecycle events for a reminder owned by the bound agent credential.",
+    request: { params: agentApiReminderParamsSchema },
+    response: { body: agentApiReminderLogResponseSchema }
+  }),
+  profileShow: route({
+    key: "profileShow",
+    method: "GET",
+    path: "/profile",
+    client: { resource: "profile", method: "show" },
+    capability: "read",
+    description: "Show the bound agent profile, or another visible profile when target is provided.",
+    request: { query: agentApiProfileShowQuerySchema },
+    response: { body: agentApiProfileViewSchema }
+  }),
+  profileUpdate: route({
+    key: "profileUpdate",
+    method: "POST",
+    path: "/profile",
+    client: { resource: "profile", method: "update" },
+    capability: "server",
+    description: "Update the bound agent profile metadata.",
+    request: { body: agentApiProfileUpdateBodySchema },
+    response: { body: agentApiProfileViewSchema }
+  }),
+  integrationList: route({
+    key: "integrationList",
+    method: "GET",
+    path: "/integrations",
+    client: { resource: "integrations", method: "list" },
+    capability: "read",
+    description: "List available integration services and active agent logins.",
+    request: {},
+    response: { body: agentApiIntegrationListResponseSchema }
+  }),
+  integrationLogin: route({
+    key: "integrationLogin",
+    method: "POST",
+    path: "/integrations/login",
+    client: { resource: "integrations", method: "login" },
+    capability: "read",
+    description: "Provision or reuse this agent's login for a registered integration service.",
+    request: { body: agentApiIntegrationLoginBodySchema },
+    response: { body: agentApiIntegrationLoginResponseSchema }
+  }),
+  integrationAppPrepare: route({
+    key: "integrationAppPrepare",
+    method: "POST",
+    path: "/integrations/app/prepare",
+    client: { resource: "integrations", method: "prepareApp" },
+    capability: "read",
+    description: "Prepare a third-party integration registration/update action card.",
+    request: { body: agentApiIntegrationAppPrepareBodySchema },
+    response: { body: agentApiIntegrationAppPrepareResponseSchema }
+  }),
+  actionPrepare: route({
+    key: "actionPrepare",
+    method: "POST",
+    path: "/prepare-action",
+    client: { resource: "actions", method: "prepare" },
+    capability: "tasks",
+    description: "Prepare an action card for a human to commit.",
+    request: { body: agentApiActionPrepareBodySchema },
+    response: { body: agentApiActionPrepareResponseSchema }
+  }),
+  attachmentUpload: route({
+    key: "attachmentUpload",
+    method: "POST",
+    path: "/upload",
+    client: { resource: "attachments", method: "upload" },
+    capability: "send",
+    description: "Upload a multipart attachment as the bound agent credential.",
+    request: {},
+    response: { body: agentApiAttachmentUploadResponseSchema }
   })
 };
 
@@ -3710,7 +4175,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 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. 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 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 the command returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes an app URL, open that URL as the service-provided app surface; it should look like the service's normal Login with Slock callback and not require you to understand Slock's internal grant/request protocol. 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, 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. 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. 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 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 the command 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 the registered OAuth callback carrying an Agent Login request code, not as a normal browser app URL; open it only when the service documents a stateless Agent Login callback that accepts that URL directly. Otherwise use the service docs, API, or manifest entry point. 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, 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;
@@ -3898,19 +4363,6 @@ 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";
@@ -5479,9 +5931,7 @@ 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_TOKEN",
-  "SLOCK_AGENT_CREDENTIAL_KEY",
-  "SLOCK_AGENT_CREDENTIAL_KEY_FILE"
+  "SLOCK_AGENT_CREDENTIAL_KEY"
 ];
 var WORKSPACE_CLI_TRANSPORT_FILENAMES = [
   "agent-token",
@@ -5836,7 +6286,7 @@ set "SLOCK_AGENT_ACTIVE_CAPABILITIES=${DEFAULT_ACTIVE_CAPABILITIES}"\r
     SLOCK_SERVER_URL: ctx.config.serverUrl,
     PATH: `${slockDir}${path2.delimiter}${process.env.PATH ?? ""}`
   };
-  scrubDaemonChildEnv(spawnEnv);
+  delete spawnEnv.SLOCK_AGENT_TOKEN;
   for (const key of RAW_CREDENTIAL_ENV_DENYLIST) {
     delete spawnEnv[key];
   }
@@ -6358,7 +6808,7 @@ function requiresWindowsShell(command, platform = process.platform) {
 }
 function resolveCommandOnPath(command, deps = {}) {
   const platform = deps.platform ?? process.platform;
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   const existsSyncFn = deps.existsSyncFn ?? existsSync3;
   if (platform === "win32") {
@@ -6384,7 +6834,7 @@ function firstExistingPath(candidates, deps = {}) {
   return null;
 }
 function readCommandVersion(command, args = [], deps = {}) {
-  const env = scrubDaemonChildEnv({ ...withWindowsUserEnvironment(deps.env ?? process.env, deps) });
+  const env = withWindowsUserEnvironment(deps.env ?? process.env, deps);
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync;
   try {
     const output = normalizeExecOutput(execFileSyncFn(command, [...args, "--version"], {
@@ -8468,11 +8918,11 @@ function detectCursorModels(runCommand = runCursorModelsCommand) {
   return parseCursorModelsOutput(String(result.stdout || ""));
 }
 function buildCursorModelProbeEnv(deps = {}) {
-  return scrubDaemonChildEnv(withWindowsUserEnvironment({
+  return withWindowsUserEnvironment({
     ...deps.env ?? process.env,
     FORCE_COLOR: "0",
     NO_COLOR: "1"
-  }, deps));
+  }, deps);
 }
 function runCursorModelsCommand() {
   return spawnSync("cursor-agent", ["models"], {
@@ -8528,7 +8978,7 @@ function resolveGeminiSpawn(commandArgs, deps = {}) {
   }
   const execFileSyncFn = deps.execFileSyncFn ?? execFileSync3;
   const existsSyncFn = deps.existsSyncFn ?? existsSync5;
-  const env = scrubDaemonChildEnv({ ...deps.env ?? process.env });
+  const env = deps.env ?? process.env;
   const winPath = path8.win32;
   let geminiEntry = null;
   try {
@@ -8665,15 +9115,12 @@ var GeminiDriver = class {
 // src/drivers/kimi.ts
 import { randomUUID as randomUUID2 } from "crypto";
 import { spawn as spawn7 } from "child_process";
-import { chmodSync, existsSync as existsSync6, readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { 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 {
@@ -8682,73 +9129,6 @@ 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",
@@ -8772,25 +9152,7 @@ var KimiDriver = class {
   };
   model = {
     detectedModelsVerifiedAs: "launchable",
-    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
-      };
-    }
+    toLaunchSpec: (modelId) => ({ args: ["--model", modelId] })
   };
   supportsStdinNotification = true;
   busyDeliveryMode = "direct";
@@ -8814,23 +9176,21 @@ 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,
-      ...launch.args
+      this.sessionId
     ];
     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 spawnTarget = resolveKimiSpawn(args);
-    const proc = spawn7(spawnTarget.command, spawnTarget.args, {
+    const launch = resolveKimiSpawn(args);
+    const proc = spawn7(launch.command, launch.args, {
       cwd: ctx.workingDirectory,
       stdio: ["pipe", "pipe", "pipe"],
       env: spawnEnv,
@@ -8838,7 +9198,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: spawnTarget.shell
+      shell: launch.shell
     });
     proc.stdin?.write(JSON.stringify({
       jsonrpc: "2.0",
@@ -8951,9 +9311,14 @@ var KimiDriver = class {
     return detectKimiModels();
   }
 };
-function detectKimiModels(home = os4.homedir(), opts = {}) {
-  const raw = readKimiConfigSource(home, opts.env).raw;
-  if (raw === null) return null;
+function detectKimiModels(home = os4.homedir()) {
+  const configPath = path9.join(home, ".kimi", "config.toml");
+  let raw;
+  try {
+    raw = readFileSync3(configPath, "utf8");
+  } catch {
+    return null;
+  }
   const models = [];
   const sectionRe = /^\s*\[models(?:\.([^\]]+)|"\.[^"]+"|\."[^"]+")\s*\]\s*$/gm;
   const lineRe = /^\s*\[models\.(.+?)\s*\]\s*$/gm;
@@ -9619,7 +9984,7 @@ function runOpenCodeModelsCommand(home, deps = {}) {
   const platform = deps.platform ?? process.platform;
   const spawnSyncFn = deps.spawnSyncFn ?? spawnSync2;
   const result = spawnSyncFn("opencode", ["models"], {
-    env: scrubDaemonChildEnv({ ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" }),
+    env: { ...process.env, HOME: home, FORCE_COLOR: "0", NO_COLOR: "1" },
     encoding: "utf8",
     timeout: 5e3,
     shell: platform === "win32"
@@ -10958,6 +11323,459 @@ async function deleteWorkspaceDirectory(dataDir, directoryName) {
   }
 }
 
+// src/agentStartCoordinator.ts
+var AgentStartCoordinator = class {
+  starting = /* @__PURE__ */ new Set();
+  queuedByAgent = /* @__PURE__ */ new Map();
+  queue = [];
+  activeStarts = 0;
+  pumpTimer = null;
+  lastStartAt = 0;
+  lastStartAgentId = null;
+  maxConcurrentStarts;
+  minStartIntervalMs;
+  constructor(opts) {
+    this.maxConcurrentStarts = Math.max(1, Math.floor(opts.maxConcurrentStarts));
+    this.minStartIntervalMs = Math.max(0, Math.floor(opts.minStartIntervalMs));
+    this.assertInvariants("constructor");
+  }
+  snapshot() {
+    return {
+      activeStarts: this.activeStarts,
+      queueDepth: this.queue.length,
+      maxConcurrentStarts: this.maxConcurrentStarts,
+      minStartIntervalMs: this.minStartIntervalMs,
+      startingAgentIds: [...this.starting],
+      queuedAgentIds: [...this.queuedByAgent.keys()],
+      pumpTimerActive: this.pumpTimer !== null
+    };
+  }
+  hasStarting(agentId) {
+    return this.starting.has(agentId);
+  }
+  hasQueued(agentId) {
+    return this.queuedByAgent.has(agentId);
+  }
+  getQueued(agentId) {
+    return this.queuedByAgent.get(agentId);
+  }
+  enqueue(item) {
+    if (this.starting.has(item.agentId)) {
+      throw new Error(`Agent start invariant violation after enqueue: ${item.agentId} is already starting`);
+    }
+    if (this.queuedByAgent.has(item.agentId)) {
+      throw new Error(`Agent start invariant violation after enqueue: ${item.agentId} is already queued`);
+    }
+    this.queue.push(item);
+    this.queuedByAgent.set(item.agentId, item);
+    this.assertInvariants("enqueue");
+  }
+  markStarting(agentId) {
+    if (this.queuedByAgent.has(agentId)) {
+      throw new Error(`Agent start invariant violation after markStarting: ${agentId} is still queued`);
+    }
+    this.starting.add(agentId);
+    this.assertInvariants("markStarting");
+  }
+  clearStarting(agentId) {
+    this.starting.delete(agentId);
+    this.assertInvariants("clearStarting");
+  }
+  getPumpState(now = Date.now()) {
+    if (this.pumpTimer) return { kind: "blocked", reason: "timer_active" };
+    if (this.queue.length === 0) return { kind: "blocked", reason: "queue_empty" };
+    if (this.activeStarts >= this.maxConcurrentStarts) return { kind: "blocked", reason: "capacity_full" };
+    const item = this.queue[0];
+    if (!item) return { kind: "blocked", reason: "queue_empty" };
+    const shouldRateLimit = item.agentId !== this.lastStartAgentId;
+    const elapsed = now - this.lastStartAt;
+    const waitMs = shouldRateLimit ? Math.max(0, this.minStartIntervalMs - elapsed) : 0;
+    if (waitMs > 0) return { kind: "rate_limited", item, waitMs };
+    return { kind: "ready", item };
+  }
+  schedulePump(waitMs, callback) {
+    if (this.pumpTimer) return;
+    this.pumpTimer = setTimeout(() => {
+      this.pumpTimer = null;
+      callback();
+    }, waitMs);
+    this.assertInvariants("schedulePump");
+  }
+  dequeue() {
+    const item = this.queue.shift();
+    if (!item) {
+      this.assertInvariants("dequeue empty");
+      return { kind: "empty" };
+    }
+    if (this.queuedByAgent.get(item.agentId) !== item) {
+      this.assertInvariants("dequeue stale");
+      return { kind: "stale", item };
+    }
+    this.queuedByAgent.delete(item.agentId);
+    this.assertInvariants("dequeue");
+    return { kind: "item", item };
+  }
+  claimStartSlot(agentId, now = Date.now()) {
+    this.activeStarts++;
+    this.lastStartAt = now;
+    this.lastStartAgentId = agentId;
+    this.assertInvariants("claimStartSlot");
+  }
+  releaseStartSlot() {
+    if (this.activeStarts <= 0) return false;
+    this.activeStarts = Math.max(0, this.activeStarts - 1);
+    this.assertInvariants("releaseStartSlot");
+    return true;
+  }
+  cancelQueued(agentId) {
+    const item = this.queuedByAgent.get(agentId);
+    if (!item) return void 0;
+    this.queuedByAgent.delete(agentId);
+    this.queue = this.queue.filter((candidate) => candidate !== item);
+    this.clearPumpTimerIfIdle();
+    this.assertInvariants("cancelQueued");
+    return item;
+  }
+  cancelAllQueued(onCancel) {
+    const items = [];
+    for (const item of this.queue) {
+      if (this.queuedByAgent.get(item.agentId) === item) {
+        items.push(item);
+        onCancel?.(item);
+      }
+    }
+    this.queue = [];
+    this.queuedByAgent.clear();
+    this.clearPumpTimer();
+    this.assertInvariants("cancelAllQueued");
+    return items;
+  }
+  assertInvariants(context) {
+    if (this.activeStarts < 0) {
+      throw new Error(`Agent start invariant violation after ${context}: activeStarts is negative`);
+    }
+    if (this.activeStarts > this.maxConcurrentStarts) {
+      throw new Error(`Agent start invariant violation after ${context}: activeStarts exceeds maxConcurrentStarts`);
+    }
+    const queuedIds = /* @__PURE__ */ new Set();
+    for (const item of this.queue) {
+      if (queuedIds.has(item.agentId)) {
+        throw new Error(`Agent start invariant violation after ${context}: duplicate queued agent ${item.agentId}`);
+      }
+      queuedIds.add(item.agentId);
+      if (this.queuedByAgent.get(item.agentId) !== item) {
+        throw new Error(`Agent start invariant violation after ${context}: queue/map mismatch for ${item.agentId}`);
+      }
+      if (this.starting.has(item.agentId)) {
+        throw new Error(`Agent start invariant violation after ${context}: ${item.agentId} is queued and starting`);
+      }
+    }
+    if (queuedIds.size !== this.queuedByAgent.size) {
+      throw new Error(`Agent start invariant violation after ${context}: queue/map size mismatch`);
+    }
+    for (const [agentId, item] of this.queuedByAgent) {
+      if (!queuedIds.has(agentId)) {
+        throw new Error(`Agent start invariant violation after ${context}: map-only queued agent ${agentId}`);
+      }
+      if (item.agentId !== agentId) {
+        throw new Error(`Agent start invariant violation after ${context}: map key/item agent mismatch for ${agentId}`);
+      }
+    }
+  }
+  setMaxConcurrentStartsForTesting(value) {
+    this.maxConcurrentStarts = Math.max(1, Math.floor(value));
+    if (this.activeStarts > this.maxConcurrentStarts) {
+      this.activeStarts = this.maxConcurrentStarts;
+    }
+    this.assertInvariants("setMaxConcurrentStartsForTesting");
+  }
+  setActiveStartsForTesting(value) {
+    this.activeStarts = Math.max(0, Math.floor(value));
+    this.assertInvariants("setActiveStartsForTesting");
+  }
+  clearPumpTimerIfIdle() {
+    if (this.queue.length === 0) {
+      this.clearPumpTimer();
+    }
+  }
+  clearPumpTimer() {
+    if (this.pumpTimer) {
+      clearTimeout(this.pumpTimer);
+      this.pumpTimer = null;
+    }
+  }
+};
+
+// src/agentStartPendingDeliveryBuffer.ts
+var AgentStartPendingDeliveryBuffer = class {
+  pending = /* @__PURE__ */ new Map();
+  count(agentId) {
+    return this.pending.get(agentId)?.length ?? 0;
+  }
+  has(agentId) {
+    return this.pending.has(agentId);
+  }
+  get size() {
+    return this.pending.size;
+  }
+  values(agentId) {
+    return [...this.pending.get(agentId) ?? []];
+  }
+  bufferDuringStart(agentId, message) {
+    return this.append(agentId, [message], "bufferDuringStart");
+  }
+  bufferMessagesDuringStart(agentId, messages) {
+    return this.append(agentId, messages, "bufferMessagesDuringStart");
+  }
+  rebindWake(agentId, previousWakeMessage, nextWakeMessage, sameWakeMessage) {
+    if (!previousWakeMessage || !nextWakeMessage || sameWakeMessage(previousWakeMessage, nextWakeMessage)) {
+      return this.count(agentId);
+    }
+    return this.append(agentId, [previousWakeMessage], "rebindWake");
+  }
+  drainOnSpawn(agentId) {
+    const messages = this.pending.get(agentId) ?? [];
+    this.pending.delete(agentId);
+    this.assertInternalInvariants("drainOnSpawn");
+    return messages;
+  }
+  cancelStart(agentId) {
+    this.pending.delete(agentId);
+    this.assertInternalInvariants("cancelStart");
+  }
+  cancelAllStarts() {
+    this.pending.clear();
+    this.assertInternalInvariants("cancelAllStarts");
+  }
+  suppressConsumed(agentId, predicate) {
+    const messages = this.pending.get(agentId);
+    if (!messages || messages.length === 0) return 0;
+    let removed = 0;
+    const retained = messages.filter((message) => {
+      const matched = predicate(message);
+      if (matched) removed += 1;
+      return !matched;
+    });
+    if (retained.length === 0) {
+      this.pending.delete(agentId);
+    } else {
+      this.pending.set(agentId, retained);
+    }
+    this.assertInternalInvariants("suppressConsumed");
+    return removed;
+  }
+  purge(agentId, predicate) {
+    return this.suppressConsumed(agentId, predicate);
+  }
+  assertInvariants(context, snapshot) {
+    this.assertInternalInvariants(context);
+    const allowed = /* @__PURE__ */ new Set([
+      ...snapshot.queuedAgentIds,
+      ...snapshot.startingAgentIds,
+      ...snapshot.terminalRecoveryAgentIds ?? [],
+      ...snapshot.cooldownAgentIds ?? []
+    ]);
+    for (const agentId of this.pending.keys()) {
+      if (!allowed.has(agentId)) {
+        throw new Error(`Agent start pending delivery invariant violation after ${context}: pending messages for non-starting agent ${agentId}`);
+      }
+    }
+  }
+  append(agentId, messages, context) {
+    if (messages.length === 0) return this.count(agentId);
+    const existing = this.pending.get(agentId);
+    if (existing) {
+      existing.push(...messages);
+    } else {
+      this.pending.set(agentId, [...messages]);
+    }
+    this.assertInternalInvariants(context);
+    return this.count(agentId);
+  }
+  assertInternalInvariants(context) {
+    for (const [agentId, messages] of this.pending) {
+      if (!agentId) {
+        throw new Error(`Agent start pending delivery invariant violation after ${context}: empty agent id`);
+      }
+      if (messages.length === 0) {
+        throw new Error(`Agent start pending delivery invariant violation after ${context}: empty pending buffer for ${agentId}`);
+      }
+    }
+  }
+};
+
+// src/agentVisibleDeliveryLedger.ts
+function getMessageShortId(messageId2) {
+  return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
+}
+function computeTarget(channelType, channelName, parentChannelName, parentChannelType) {
+  if (channelType === "thread" && parentChannelName) {
+    const shortId = getMessageShortId(String(channelName ?? ""));
+    if (parentChannelType === "dm") {
+      return `dm:@${parentChannelName}:${shortId}`;
+    }
+    return `#${parentChannelName}:${shortId}`;
+  }
+  if (channelType === "dm") {
+    return `dm:@${channelName}`;
+  }
+  return `#${channelName}`;
+}
+function formatAgentMessageVisibleTarget(message) {
+  return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
+}
+function formatProxyVisibleMessageTarget(message) {
+  return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
+}
+function hasTargetMetadata(message) {
+  if (message.channel_type === "thread") return Boolean(message.parent_channel_name && message.channel_name);
+  return Boolean(message.channel_type && message.channel_name);
+}
+function visibleMessageId(message) {
+  if (typeof message.message_id === "string") return String(message.message_id);
+  if (typeof message.id === "string") return String(message.id);
+  return "";
+}
+function isTrueDeliveryConsumeSource(source) {
+  return source === "spawn_wake_message" || source === "agent_api_events_local" || source.startsWith("stdin_");
+}
+var AgentVisibleDeliveryLedger = class {
+  boundaryByAgent = /* @__PURE__ */ new Map();
+  messageIdsByAgent = /* @__PURE__ */ new Map();
+  clearAgent(agentId) {
+    this.boundaryByAgent.delete(agentId);
+    this.messageIdsByAgent.delete(agentId);
+  }
+  hasAgentState(agentId) {
+    return this.boundaryByAgent.has(agentId) || this.messageIdsByAgent.has(agentId);
+  }
+  getBoundary(agentId, target) {
+    return this.boundaryByAgent.get(agentId)?.get(target);
+  }
+  getMessageIdSet(agentId, target) {
+    return this.messageIdsByAgent.get(agentId)?.get(target);
+  }
+  isModelSeen(agentId, target, message) {
+    const seq = Number(message.seq ?? 0);
+    const boundary = this.getBoundary(agentId, target);
+    if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= Math.floor(seq)) return true;
+    const id = visibleMessageId(message);
+    return id.length > 0 && this.getMessageIdSet(agentId, target)?.has(id) === true;
+  }
+  recordConsumed(agentId, input) {
+    if (input.messages.length === 0 && (!input.target || typeof input.boundarySeq !== "number")) return null;
+    const byTarget = /* @__PURE__ */ new Map();
+    const ensureBucket = (target) => {
+      let bucket = byTarget.get(target);
+      if (!bucket) {
+        bucket = { maxSeq: 0, boundarySeq: 0, seqs: /* @__PURE__ */ new Set(), ids: /* @__PURE__ */ new Set() };
+        byTarget.set(target, bucket);
+      }
+      return bucket;
+    };
+    for (const message of input.messages) {
+      const messageTarget = formatProxyVisibleMessageTarget(message);
+      if (input.target && hasTargetMetadata(message) && messageTarget !== input.target) {
+        throw new Error(`AgentVisibleDeliveryLedger target mismatch: explicit target ${input.target} does not match visible message target ${messageTarget}`);
+      }
+      const target = input.target ?? messageTarget;
+      if (!target) continue;
+      const bucket = ensureBucket(target);
+      const seq = Number(message.seq ?? 0);
+      if (Number.isFinite(seq) && seq > 0) {
+        const normalizedSeq = Math.floor(seq);
+        bucket.maxSeq = Math.max(bucket.maxSeq, normalizedSeq);
+        bucket.seqs.add(normalizedSeq);
+      }
+      const id = visibleMessageId(message);
+      if (id.length > 0) bucket.ids.add(id);
+    }
+    if (input.target && typeof input.boundarySeq === "number" && Number.isFinite(input.boundarySeq) && input.boundarySeq > 0) {
+      const bucket = ensureBucket(input.target);
+      bucket.boundarySeq = Math.max(bucket.boundarySeq, Math.floor(input.boundarySeq));
+    }
+    if (byTarget.size === 0) return null;
+    const advancesBoundary = isTrueDeliveryConsumeSource(input.source);
+    for (const [target, bucket] of byTarget) {
+      const previousBoundary = this.getBoundary(agentId, target);
+      if (advancesBoundary) {
+        const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
+        const boundaryMap = this.boundaryMap(agentId);
+        boundaryMap.set(target, Math.max(previousBoundary ?? 0, highWaterSeq));
+      }
+      if (bucket.ids.size > 0) {
+        const targetIds = this.messageIdSet(agentId, target);
+        for (const id of bucket.ids) targetIds.add(id);
+      }
+      this.assertConsumedInvariants("recordConsumed", agentId, target, bucket, {
+        advancesBoundary,
+        previousBoundary
+      });
+    }
+    return {
+      targets: [...byTarget.keys()],
+      messagesCount: input.messages.length,
+      shouldSuppress(message) {
+        const target = formatAgentMessageVisibleTarget(message);
+        const bucket = byTarget.get(target);
+        if (!bucket) return false;
+        const seq = typeof message.seq === "number" ? Math.floor(message.seq) : 0;
+        const id = visibleMessageId(message);
+        return seq > 0 && bucket.boundarySeq > 0 && seq <= bucket.boundarySeq || seq > 0 && bucket.seqs.has(seq) || id.length > 0 && bucket.ids.has(id);
+      }
+    };
+  }
+  boundaryMap(agentId) {
+    let map = this.boundaryByAgent.get(agentId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.boundaryByAgent.set(agentId, map);
+    }
+    return map;
+  }
+  messageIdMap(agentId) {
+    let map = this.messageIdsByAgent.get(agentId);
+    if (!map) {
+      map = /* @__PURE__ */ new Map();
+      this.messageIdsByAgent.set(agentId, map);
+    }
+    return map;
+  }
+  messageIdSet(agentId, target) {
+    const map = this.messageIdMap(agentId);
+    let ids = map.get(target);
+    if (!ids) {
+      ids = /* @__PURE__ */ new Set();
+      map.set(target, ids);
+    }
+    return ids;
+  }
+  assertConsumedInvariants(context, agentId, target, bucket, options) {
+    const boundary = this.getBoundary(agentId, target);
+    if (!options.advancesBoundary && boundary !== options.previousBoundary) {
+      throw new Error(`Agent visible delivery ledger invariant violation after ${context}: set-only source advanced boundary for ${agentId} ${target}`);
+    }
+    if (options.advancesBoundary) {
+      const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
+      const normalizedBoundary = boundary ?? 0;
+      if (normalizedBoundary < (options.previousBoundary ?? 0)) {
+        throw new Error(`Agent visible delivery ledger invariant violation after ${context}: boundary regressed for ${agentId} ${target}`);
+      }
+      if (highWaterSeq > 0 && normalizedBoundary < highWaterSeq) {
+        throw new Error(`Agent visible delivery ledger invariant violation after ${context}: boundary below consumed high-water for ${agentId} ${target}`);
+      }
+    }
+    if (bucket.ids.size > 0) {
+      const targetIds = this.getMessageIdSet(agentId, target);
+      for (const id of bucket.ids) {
+        if (targetIds?.has(id) !== true) {
+          throw new Error(`Agent visible delivery ledger invariant violation after ${context}: missing consumed message id for ${agentId} ${target}`);
+        }
+      }
+    }
+  }
+};
+
 // src/runtimeErrorDiagnostics.ts
 import { createHash as createHash2 } from "crypto";
 var MAX_RUNTIME_ERROR_MESSAGE_EXCERPT_CHARS = 4096;
@@ -11467,26 +12285,10 @@ function toLocalTime(iso) {
 function formatChannelLabel(message) {
   return message.channel_type === "dm" ? `DM:@${message.channel_name}` : `#${message.channel_name}`;
 }
-function computeTarget(channelType, channelName, parentChannelName, parentChannelType) {
-  if (channelType === "thread" && parentChannelName) {
-    const shortId = getMessageShortId(String(channelName ?? ""));
-    if (parentChannelType === "dm") {
-      return `dm:@${parentChannelName}:${shortId}`;
-    }
-    return `#${parentChannelName}:${shortId}`;
-  }
-  if (channelType === "dm") {
-    return `dm:@${channelName}`;
-  }
-  return `#${channelName}`;
-}
 function formatMessageTarget(message) {
-  return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
+  return formatAgentMessageVisibleTarget(message);
 }
-function formatVisibleMessageTarget(message) {
-  return computeTarget(message.channel_type, message.channel_name, message.parent_channel_name, message.parent_channel_type);
-}
-function getMessageShortId(messageId2) {
+function getMessageShortId2(messageId2) {
   return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
 }
 var RESPONSE_TARGET_HINT = "Reply in the channel or create/reply in a thread as appropriate; use each message's `target` and `msg` fields to choose the exact target.";
@@ -11753,31 +12555,11 @@ function formatTaskAssigneeType(type) {
   return type ?? null;
 }
 function formatThreadContextMessage(message) {
-  const msgId = message.message_id ? getMessageShortId(message.message_id) : "-";
+  const msgId = message.message_id ? getMessageShortId2(message.message_id) : "-";
   const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
   const senderType = formatVisibleActorType(message.sender_type);
   return `- [msg=${msgId} time=${time}${senderType}] ${formatSenderHandle(message)}: ${message.content}`;
 }
-function communicationCommand(name) {
-  switch (name) {
-    case "send_message":
-      return "raft message send";
-    case "read_history":
-      return "raft message read";
-    case "check_messages":
-      return "raft message check";
-    case "claim_tasks":
-      return "raft task claim";
-    default:
-      return `raft ${name.replace(/_/g, " ")}`;
-  }
-}
-function dynamicReplyInstruction() {
-  return "reply using `raft message send --target <exact target>`";
-}
-function dynamicClaimInstruction() {
-  return "claim the relevant task with `raft task claim`";
-}
 function formatIncomingMessage(message, options = {}) {
   const threadJoinPrefix = message.thread_join_context ? [
     `[Slock thread context: you were added to a new thread via @mention.]`,
@@ -11793,7 +12575,7 @@ function formatIncomingMessage(message, options = {}) {
     ""
   ].join("\n") : "";
   const target = formatMessageTarget(message);
-  const msgId = message.message_id ? getMessageShortId(message.message_id) : "-";
+  const msgId = message.message_id ? getMessageShortId2(message.message_id) : "-";
   const time = message.timestamp ? toLocalTime(message.timestamp) : "-";
   const senderType = formatVisibleActorType(message.sender_type);
   const attachSuffix = formatAttachmentSuffix(message.attachments, options.attachmentHint);
@@ -12752,17 +13534,8 @@ var AgentProcessManager = class _AgentProcessManager {
     this.activityClientSeqByAgent.set(agentId, next);
     return next;
   }
-  agentsStarting = /* @__PURE__ */ new Set();
-  // Prevent concurrent starts of same agent
-  queuedAgentStarts = /* @__PURE__ */ new Map();
-  agentStartQueue = [];
-  activeAgentStartCount = 0;
-  agentStartPumpTimer = null;
-  lastAgentStartAt = 0;
-  lastAgentStartAgentId = null;
-  maxConcurrentAgentStarts;
-  agentStartIntervalMs;
-  startingInboxes = /* @__PURE__ */ new Map();
+  agentStarts;
+  startingInboxes = new AgentStartPendingDeliveryBuffer();
   terminalRuntimeFailures = /* @__PURE__ */ new Map();
   runtimeErrorFingerprintFences = /* @__PURE__ */ new Map();
   pendingStartRebinds = /* @__PURE__ */ new Map();
@@ -12786,8 +13559,7 @@ var AgentProcessManager = class _AgentProcessManager {
   cliTransportTraceDir = null;
   deliveryTraceContexts = /* @__PURE__ */ new WeakMap();
   runtimeExitTraceAttrs = /* @__PURE__ */ new WeakMap();
-  agentVisibleBoundaries = /* @__PURE__ */ new Map();
-  agentVisibleMessageIds = /* @__PURE__ */ new Map();
+  agentVisibleDelivery = new AgentVisibleDeliveryLedger();
   // Spawn-fail backoff state per-agent (lifted outside AgentProcess because spawn fails
   // BEFORE ap exists; rate-state must persist across stop/respawn so churn can't bypass).
   // Explicit stop clears (fresh launch resets dedup clock — CC1 lifecycle pattern); silent
@@ -12832,18 +13604,10 @@ var AgentProcessManager = class _AgentProcessManager {
       Math.min(1, opts.runtimeErrorDeliveryBackoff?.jitterRatio ?? 0.1)
     );
     this.runtimeErrorDeliveryBackoffFailPointForTesting = opts.runtimeErrorDeliveryBackoff?.failPointForTesting ?? null;
-    this.maxConcurrentAgentStarts = Math.max(
-      1,
-      Math.floor(
-        opts.runtimeStartScheduler?.maxConcurrentStarts ?? readPositiveIntegerEnv("SLOCK_DAEMON_MAX_CONCURRENT_AGENT_STARTS", DEFAULT_MAX_CONCURRENT_AGENT_STARTS)
-      )
-    );
-    this.agentStartIntervalMs = Math.max(
-      0,
-      Math.floor(
-        opts.runtimeStartScheduler?.minStartIntervalMs ?? readNonNegativeIntegerEnv("SLOCK_DAEMON_AGENT_START_INTERVAL_MS", DEFAULT_AGENT_START_INTERVAL_MS)
-      )
-    );
+    this.agentStarts = new AgentStartCoordinator({
+      maxConcurrentStarts: opts.runtimeStartScheduler?.maxConcurrentStarts ?? readPositiveIntegerEnv("SLOCK_DAEMON_MAX_CONCURRENT_AGENT_STARTS", DEFAULT_MAX_CONCURRENT_AGENT_STARTS),
+      minStartIntervalMs: opts.runtimeStartScheduler?.minStartIntervalMs ?? readNonNegativeIntegerEnv("SLOCK_DAEMON_AGENT_START_INTERVAL_MS", DEFAULT_AGENT_START_INTERVAL_MS)
+    });
   }
   setTracer(tracer) {
     this.tracer = tracer;
@@ -12851,34 +13615,23 @@ var AgentProcessManager = class _AgentProcessManager {
   setCliTransportTraceDir(traceDir) {
     this.cliTransportTraceDir = traceDir;
   }
-  visibleBoundaryMap(agentId) {
-    let map = this.agentVisibleBoundaries.get(agentId);
-    if (!map) {
-      map = /* @__PURE__ */ new Map();
-      this.agentVisibleBoundaries.set(agentId, map);
-    }
-    return map;
+  assertStartPendingDeliveryInvariants(context) {
+    const startSnapshot = this.agentStarts.snapshot();
+    this.startingInboxes.assertInvariants(context, {
+      queuedAgentIds: startSnapshot.queuedAgentIds,
+      startingAgentIds: startSnapshot.startingAgentIds,
+      terminalRecoveryAgentIds: [...this.terminalRuntimeFailures.keys()],
+      cooldownAgentIds: [...this.agentSpawnFailBackoff.keys()]
+    });
   }
   getVisibleBoundary(agentId, target) {
-    return this.agentVisibleBoundaries.get(agentId)?.get(target);
-  }
-  visibleMessageIdMap(agentId) {
-    let map = this.agentVisibleMessageIds.get(agentId);
-    if (!map) {
-      map = /* @__PURE__ */ new Map();
-      this.agentVisibleMessageIds.set(agentId, map);
-    }
-    return map;
+    return this.agentVisibleDelivery.getBoundary(agentId, target);
   }
   getVisibleMessageIdSet(agentId, target) {
-    return this.agentVisibleMessageIds.get(agentId)?.get(target);
+    return this.agentVisibleDelivery.getMessageIdSet(agentId, target);
   }
   isVisibleMessageModelSeen(agentId, target, message) {
-    const seq = Number(message.seq ?? 0);
-    const boundary = this.getVisibleBoundary(agentId, target);
-    if (Number.isFinite(seq) && seq > 0 && typeof boundary === "number" && boundary >= Math.floor(seq)) return true;
-    const id = typeof message.message_id === "string" ? message.message_id : typeof message.id === "string" ? message.id : "";
-    return id.length > 0 && this.getVisibleMessageIdSet(agentId, target)?.has(id) === true;
+    return this.agentVisibleDelivery.isModelSeen(agentId, target, message);
   }
   // ----- SPAWN-FAIL BACKOFF (per-agent) ----------------------------------
   // Anchored at auto_restart_from_idle (apm:3596) + runtime_profile_auto_restart (apm:4137).
@@ -13320,7 +14073,7 @@ var AgentProcessManager = class _AgentProcessManager {
     const collect = (messages) => (messages ?? []).filter((message) => typeof message.seq === "number" && message.seq > 0);
     return [
       ...collect(this.agents.get(agentId)?.inbox),
-      ...collect(this.startingInboxes.get(agentId))
+      ...collect(this.startingInboxes.values(agentId))
     ];
   }
   pendingVisibleMessages(agentId, target) {
@@ -13333,61 +14086,13 @@ var AgentProcessManager = class _AgentProcessManager {
    * same seq must not be injected later through the local pending queue.
    */
   consumeVisibleMessages(agentId, input) {
-    if (input.messages.length === 0 && (!input.target || typeof input.boundarySeq !== "number")) return;
-    const byTarget = /* @__PURE__ */ new Map();
-    const ensureBucket = (target) => {
-      let bucket = byTarget.get(target);
-      if (!bucket) {
-        bucket = { maxSeq: 0, boundarySeq: 0, seqs: /* @__PURE__ */ new Set(), ids: /* @__PURE__ */ new Set() };
-        byTarget.set(target, bucket);
-      }
-      return bucket;
-    };
-    for (const message of input.messages) {
-      const seq = Number(message.seq ?? 0);
-      const target = input.target ?? formatVisibleMessageTarget(message);
-      if (!target) continue;
-      const bucket = ensureBucket(target);
-      if (Number.isFinite(seq) && seq > 0) {
-        bucket.maxSeq = Math.max(bucket.maxSeq, Math.floor(seq));
-        bucket.seqs.add(Math.floor(seq));
-      }
-      const id = typeof message.message_id === "string" ? message.message_id : typeof message.id === "string" ? message.id : null;
-      if (id) bucket.ids.add(id);
-    }
-    if (input.target && typeof input.boundarySeq === "number" && Number.isFinite(input.boundarySeq) && input.boundarySeq > 0) {
-      const bucket = ensureBucket(input.target);
-      bucket.boundarySeq = Math.max(bucket.boundarySeq, Math.floor(input.boundarySeq));
-    }
-    if (byTarget.size === 0) return;
-    const boundaryMap = this.visibleBoundaryMap(agentId);
-    const visibleIds = this.visibleMessageIdMap(agentId);
-    const advancesBoundary = input.source === "spawn_wake_message" || input.source === "agent_api_events_local" || input.source.startsWith("stdin_");
-    for (const [target, bucket] of byTarget) {
-      if (advancesBoundary) {
-        const highWaterSeq = Math.max(bucket.maxSeq, bucket.boundarySeq);
-        const previous = boundaryMap.get(target) ?? 0;
-        boundaryMap.set(target, Math.max(previous, highWaterSeq));
-      }
-      if (bucket.ids.size > 0) {
-        let targetIds = visibleIds.get(target);
-        if (!targetIds) {
-          targetIds = /* @__PURE__ */ new Set();
-          visibleIds.set(target, targetIds);
-        }
-        for (const id of bucket.ids) targetIds.add(id);
-      }
-    }
+    const consumed = this.agentVisibleDelivery.recordConsumed(agentId, input);
+    if (!consumed) return;
     const suppress = (messages) => {
       if (!messages || messages.length === 0) return 0;
       let removed = 0;
       const retained = messages.filter((message) => {
-        const target = formatMessageTarget(message);
-        const bucket = byTarget.get(target);
-        if (!bucket) return true;
-        const seq = typeof message.seq === "number" ? Math.floor(message.seq) : 0;
-        const id = message.message_id ?? "";
-        const matched = seq > 0 && bucket.boundarySeq > 0 && seq <= bucket.boundarySeq || seq > 0 && bucket.seqs.has(seq) || id.length > 0 && bucket.ids.has(id);
+        const matched = consumed.shouldSuppress(message);
         if (matched) removed += 1;
         return !matched;
       });
@@ -13396,12 +14101,13 @@ var AgentProcessManager = class _AgentProcessManager {
     };
     const active = this.agents.get(agentId);
     const removedActive = suppress(active?.inbox);
-    const removedStarting = suppress(this.startingInboxes.get(agentId));
+    const removedStarting = this.startingInboxes.suppressConsumed(agentId, consumed.shouldSuppress);
+    this.assertStartPendingDeliveryInvariants("visible-consume");
     this.recordDaemonTrace("daemon.agent.inbox.visible_consumed", {
       agentId,
       source: input.source,
-      targets: [...byTarget.keys()],
-      messages_count: input.messages.length,
+      targets: consumed.targets,
+      messages_count: consumed.messagesCount,
       suppressed_pending_count: removedActive + removedStarting
     });
   }
@@ -13423,11 +14129,8 @@ var AgentProcessManager = class _AgentProcessManager {
     };
     const active = this.agents.get(agentId);
     const removedActive = purge(active?.inbox);
-    const startingInbox = this.startingInboxes.get(agentId);
-    const removedStarting = purge(startingInbox);
-    if (startingInbox && startingInbox.length === 0) {
-      this.startingInboxes.delete(agentId);
-    }
+    const removedStarting = this.startingInboxes.purge(agentId, (message) => channelIdSet.has(message.channel_id));
+    this.assertStartPendingDeliveryInvariants("purge-starting-inbox");
     if (active && removedActive > 0) {
       active.notifications.remove(removedActive);
       if (active.inbox.length === 0) {
@@ -13444,7 +14147,7 @@ var AgentProcessManager = class _AgentProcessManager {
       removed_starting_count: removedStarting,
       removed_count: removedCount,
       active_inbox_count: active?.inbox.length ?? 0,
-      starting_inbox_count: this.startingInboxes.get(agentId)?.length ?? 0
+      starting_inbox_count: this.startingInboxes.count(agentId)
     });
     return { removedCount };
   }
@@ -13591,6 +14294,7 @@ var AgentProcessManager = class _AgentProcessManager {
     };
   }
   startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
+    const startSnapshot = this.agentStarts.snapshot();
     return {
       agentId,
       launchId,
@@ -13602,10 +14306,10 @@ var AgentProcessManager = class _AgentProcessManager {
       wake_message_transient: Boolean(wakeMessage && wakeMessageTransient),
       unread_channels_count: unreadSummary ? Object.keys(unreadSummary).length : 0,
       resume_prompt_present: Boolean(resumePrompt),
-      queue_depth: this.agentStartQueue.length,
-      active_starts: this.activeAgentStartCount,
-      max_concurrent_starts: this.maxConcurrentAgentStarts,
-      min_start_interval_ms: this.agentStartIntervalMs,
+      queue_depth: startSnapshot.queueDepth,
+      active_starts: startSnapshot.activeStarts,
+      max_concurrent_starts: startSnapshot.maxConcurrentStarts,
+      min_start_interval_ms: startSnapshot.minStartIntervalMs,
       ...this.runtimeLaunchPolicyTraceAttrs(config)
     };
   }
@@ -13691,18 +14395,20 @@ var AgentProcessManager = class _AgentProcessManager {
     return left === right;
   }
   rebindQueuedStart(agentId, start, reason) {
-    const item = this.queuedAgentStarts.get(agentId);
+    const item = this.agentStarts.getQueued(agentId);
     if (!item) {
       return false;
     }
     const previousLaunchId = item.launchId || null;
     const nextLaunchId = start.launchId || previousLaunchId;
     const previousWakeMessage = item.wakeMessage;
-    if (previousWakeMessage && start.wakeMessage && !this.sameWakeMessage(previousWakeMessage, start.wakeMessage)) {
-      const pending = this.startingInboxes.get(agentId) || [];
-      pending.push(previousWakeMessage);
-      this.startingInboxes.set(agentId, pending);
-    }
+    this.startingInboxes.rebindWake(
+      agentId,
+      previousWakeMessage,
+      start.wakeMessage,
+      (left, right) => this.sameWakeMessage(left, right)
+    );
+    this.assertStartPendingDeliveryInvariants("rebind-queued-start");
     item.config = start.config;
     item.unreadSummary = start.unreadSummary;
     item.resumePrompt = start.resumePrompt;
@@ -13769,7 +14475,7 @@ var AgentProcessManager = class _AgentProcessManager {
       logger.info(`[Agent ${agentId}] Start rebound (already running)`);
       return;
     }
-    if (this.agentsStarting.has(agentId)) {
+    if (this.agentStarts.hasStarting(agentId)) {
       this.recordDaemonTrace("daemon.agent.start.ignored", {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_starting"
@@ -13778,7 +14484,7 @@ var AgentProcessManager = class _AgentProcessManager {
       logger.info(`[Agent ${agentId}] Start rebind deferred (startup in progress)`);
       return;
     }
-    if (this.queuedAgentStarts.has(agentId)) {
+    if (this.agentStarts.hasQueued(agentId)) {
       this.recordDaemonTrace("daemon.agent.start.ignored", {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_queued"
@@ -13799,46 +14505,40 @@ var AgentProcessManager = class _AgentProcessManager {
         resolve,
         reject
       };
-      this.agentStartQueue.push(item);
-      this.queuedAgentStarts.set(agentId, item);
+      this.agentStarts.enqueue(item);
       this.recordDaemonTrace("daemon.agent.start.queued", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
+      const startSnapshot = this.agentStarts.snapshot();
       logger.info(
-        `[Agent ${agentId}] Start queued (queue=${this.agentStartQueue.length}, active=${this.activeAgentStartCount}, max=${this.maxConcurrentAgentStarts}, interval=${this.agentStartIntervalMs}ms)`
+        `[Agent ${agentId}] Start queued (queue=${startSnapshot.queueDepth}, active=${startSnapshot.activeStarts}, max=${startSnapshot.maxConcurrentStarts}, interval=${startSnapshot.minStartIntervalMs}ms)`
       );
       this.pumpAgentStartQueue();
     });
   }
   pumpAgentStartQueue() {
-    if (this.agentStartPumpTimer) return;
-    if (this.agentStartQueue.length === 0) return;
-    if (this.activeAgentStartCount >= this.maxConcurrentAgentStarts) return;
-    const next = this.agentStartQueue[0];
-    const shouldRateLimit = next ? next.agentId !== this.lastAgentStartAgentId : true;
-    const elapsed = Date.now() - this.lastAgentStartAt;
-    const waitMs = shouldRateLimit ? Math.max(0, this.agentStartIntervalMs - elapsed) : 0;
-    if (waitMs > 0) {
+    const pumpState = this.agentStarts.getPumpState();
+    if (pumpState.kind === "blocked") return;
+    if (pumpState.kind === "rate_limited") {
+      const { item: next, waitMs } = pumpState;
       this.recordDaemonTrace("daemon.agent.start.rate_limited", {
         ...this.startQueueTraceAttrs(next.agentId, next.config, next.wakeMessage, next.unreadSummary, next.resumePrompt, next.launchId, next.wakeMessageTransient),
         wait_ms: waitMs
       });
-      this.agentStartPumpTimer = setTimeout(() => {
-        this.agentStartPumpTimer = null;
-        this.pumpAgentStartQueue();
-      }, waitMs);
+      this.agentStarts.schedulePump(waitMs, () => this.pumpAgentStartQueue());
       return;
     }
-    const item = this.agentStartQueue.shift();
-    if (!item) return;
-    if (this.queuedAgentStarts.get(item.agentId) !== item) {
+    const dequeued = this.agentStarts.dequeue();
+    if (dequeued.kind === "empty") return;
+    if (dequeued.kind === "stale") {
+      const { item: item2 } = dequeued;
       this.recordDaemonTrace("daemon.agent.start.skipped", {
-        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
+        ...this.startQueueTraceAttrs(item2.agentId, item2.config, item2.wakeMessage, item2.unreadSummary, item2.resumePrompt, item2.launchId, item2.wakeMessageTransient),
         reason: "stale_queue_item"
       });
       this.pumpAgentStartQueue();
       return;
     }
-    this.queuedAgentStarts.delete(item.agentId);
-    if (this.agents.has(item.agentId) || this.agentsStarting.has(item.agentId)) {
+    const { item } = dequeued;
+    if (this.agents.has(item.agentId) || this.agentStarts.hasStarting(item.agentId)) {
       this.recordDaemonTrace("daemon.agent.start.skipped", {
         ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
         reason: "already_running_or_starting"
@@ -13853,11 +14553,10 @@ var AgentProcessManager = class _AgentProcessManager {
       this.pumpAgentStartQueue();
       return;
     }
-    this.activeAgentStartCount++;
-    this.lastAgentStartAt = Date.now();
-    this.lastAgentStartAgentId = item.agentId;
+    this.agentStarts.claimStartSlot(item.agentId);
+    const startSnapshot = this.agentStarts.snapshot();
     logger.info(
-      `[Agent ${item.agentId}] Dequeued start (remaining=${this.agentStartQueue.length}, active=${this.activeAgentStartCount})`
+      `[Agent ${item.agentId}] Dequeued start (remaining=${startSnapshot.queueDepth}, active=${startSnapshot.activeStarts})`
     );
     this.recordDaemonTrace("daemon.agent.start.dequeued", this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient));
     this.startAgentNow(
@@ -13877,30 +14576,25 @@ var AgentProcessManager = class _AgentProcessManager {
     });
   }
   releaseAgentStartSlot(agentId, reason) {
-    if (this.activeAgentStartCount <= 0) return;
-    this.activeAgentStartCount = Math.max(0, this.activeAgentStartCount - 1);
+    if (!this.agentStarts.releaseStartSlot()) return;
+    const startSnapshot = this.agentStarts.snapshot();
     this.recordDaemonTrace("daemon.agent.start.slot_released", {
       agentId,
       reason,
-      active_starts: this.activeAgentStartCount,
-      queue_depth: this.agentStartQueue.length,
-      max_concurrent_starts: this.maxConcurrentAgentStarts
+      active_starts: startSnapshot.activeStarts,
+      queue_depth: startSnapshot.queueDepth,
+      max_concurrent_starts: startSnapshot.maxConcurrentStarts
     });
     logger.info(
-      `[Agent ${agentId}] Start slot released (${reason}) (active=${this.activeAgentStartCount}, queue=${this.agentStartQueue.length})`
+      `[Agent ${agentId}] Start slot released (${reason}) (active=${startSnapshot.activeStarts}, queue=${startSnapshot.queueDepth})`
     );
     this.pumpAgentStartQueue();
   }
   cancelQueuedAgentStart(agentId, reason) {
-    const item = this.queuedAgentStarts.get(agentId);
+    const item = this.agentStarts.cancelQueued(agentId);
     if (!item) return false;
-    this.queuedAgentStarts.delete(agentId);
-    this.agentStartQueue = this.agentStartQueue.filter((candidate) => candidate !== item);
-    this.startingInboxes.delete(agentId);
-    if (this.agentStartQueue.length === 0 && this.agentStartPumpTimer) {
-      clearTimeout(this.agentStartPumpTimer);
-      this.agentStartPumpTimer = null;
-    }
+    this.startingInboxes.cancelStart(agentId);
+    this.assertStartPendingDeliveryInvariants("cancel-queued-start");
     this.recordDaemonTrace("daemon.agent.start.cancelled", {
       ...this.startQueueTraceAttrs(agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
       reason
@@ -13910,23 +14604,18 @@ var AgentProcessManager = class _AgentProcessManager {
     return true;
   }
   cancelAllQueuedAgentStarts(reason) {
-    for (const item of this.agentStartQueue) {
-      if (this.queuedAgentStarts.get(item.agentId) === item) {
-        this.recordDaemonTrace("daemon.agent.start.cancelled", {
-          ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
-          reason
-        }, "cancelled");
-        logger.info(`[Agent ${item.agentId}] Queued start cancelled (${reason})`);
-        item.resolve();
-      }
-    }
-    this.agentStartQueue = [];
-    this.queuedAgentStarts.clear();
-    this.startingInboxes.clear();
-    if (this.agentStartPumpTimer) {
-      clearTimeout(this.agentStartPumpTimer);
-      this.agentStartPumpTimer = null;
+    const cancelled = this.agentStarts.cancelAllQueued((item) => {
+      this.recordDaemonTrace("daemon.agent.start.cancelled", {
+        ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
+        reason
+      }, "cancelled");
+      logger.info(`[Agent ${item.agentId}] Queued start cancelled (${reason})`);
+    });
+    for (const item of cancelled) {
+      item.resolve();
     }
+    this.startingInboxes.cancelAllStarts();
+    this.assertStartPendingDeliveryInvariants("cancel-all-queued-starts");
   }
   async startAgentNow(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient = false) {
     if (this.agents.has(agentId)) {
@@ -13938,7 +14627,7 @@ var AgentProcessManager = class _AgentProcessManager {
       logger.info(`[Agent ${agentId}] Start rebound (already running)`);
       return;
     }
-    if (this.agentsStarting.has(agentId)) {
+    if (this.agentStarts.hasStarting(agentId)) {
       this.recordDaemonTrace("daemon.agent.spawn.skipped", {
         ...this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient),
         reason: "already_starting"
@@ -13947,7 +14636,7 @@ var AgentProcessManager = class _AgentProcessManager {
       logger.info(`[Agent ${agentId}] Start rebind deferred (startup in progress)`);
       return;
     }
-    this.agentsStarting.add(agentId);
+    this.agentStarts.markStarting(agentId);
     let agentProcess = null;
     let pendingStartRebind;
     const originalLaunchId = launchId || null;
@@ -13980,11 +14669,13 @@ var AgentProcessManager = class _AgentProcessManager {
       if (pendingStartRebind) {
         this.pendingStartRebinds.delete(agentId);
         const previousWakeMessage = wakeMessage;
-        if (previousWakeMessage && pendingStartRebind.wakeMessage && !this.sameWakeMessage(previousWakeMessage, pendingStartRebind.wakeMessage)) {
-          const pending = this.startingInboxes.get(agentId) || [];
-          pending.push(previousWakeMessage);
-          this.startingInboxes.set(agentId, pending);
-        }
+        this.startingInboxes.rebindWake(
+          agentId,
+          previousWakeMessage,
+          pendingStartRebind.wakeMessage,
+          (left, right) => this.sameWakeMessage(left, right)
+        );
+        this.assertStartPendingDeliveryInvariants("rebind-starting-start");
         config = pendingStartRebind.config;
         unreadSummary = pendingStartRebind.unreadSummary;
         resumePrompt = pendingStartRebind.resumePrompt;
@@ -14025,7 +14716,7 @@ var AgentProcessManager = class _AgentProcessManager {
       let promptSource;
       let wakeMessageDeliveredAsInboxUpdate = false;
       let startingInboxDeliveredAsInput = false;
-      const startingInboxMessages = this.startingInboxes.get(agentId) || [];
+      const startingInboxMessages = this.startingInboxes.values(agentId);
       if (runtimeConfig.runtimeProfileControl && !wakeMessage) {
         prompt = driver.supportsNativeStandingPrompt ? NATIVE_STANDING_PROMPT_STARTUP_INPUT : formatRuntimeProfileControlStartupInput(runtimeConfig.runtimeProfileControl, driver);
         promptSource = "runtime_profile_control";
@@ -14077,7 +14768,7 @@ Use the inbox/read commands at a natural breakpoint if you choose to inspect tho
         }
         prompt += `
 
-Use ${communicationCommand("read_history")} to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call ${communicationCommand("check_messages")} in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: ${dynamicReplyInstruction()} and ${dynamicClaimInstruction()} before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver)}`;
+Use \`raft message read\` to catch up on the channels listed above, then stop. Read each listed channel at most once unless a read fails. Do NOT call \`raft message check\` in this mode. If the history reveals a direct request, assignment, @mention, review request, or task clearly addressed to you, switch into active handling instead of stopping: reply using \`raft message send --target <exact target>\` and claim the relevant task with \`raft task claim\` before starting work. Otherwise, do NOT send any message in this mode. ${getMessageDeliveryText(driver)}`;
         promptSource = "resume_unread_summary";
       } else if (isResume) {
         prompt = `No new messages while you were away. Nothing to do \u2014 just stop. ${getMessageDeliveryText(driver)}`;
@@ -14100,9 +14791,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       const effectiveLaunchId = launchId || null;
       const canDeferEmptyStart = driver.deferSpawnUntilMessage === true && !wakeMessage && !runtimeConfig.runtimeProfileControl && (!unreadSummary || Object.keys(unreadSummary).length === 0);
       if (canDeferEmptyStart) {
-        const pendingMessages = this.startingInboxes.get(agentId) || [];
-        this.startingInboxes.delete(agentId);
-        this.agentsStarting.delete(agentId);
+        const pendingMessages = this.startingInboxes.drainOnSpawn(agentId);
+        this.agentStarts.clearStarting(agentId);
+        this.assertStartPendingDeliveryInvariants("defer-empty-start-drain");
         this.idleAgentConfigs.set(agentId, {
           config: this.buildRestartSafeConfig(runtimeConfig, runtimeConfig.sessionId || null),
           sessionId: runtimeConfig.sessionId || null,
@@ -14185,7 +14876,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         pendingTrajectory: null,
         gatedSteering: createGatedSteeringState()
       };
-      this.startingInboxes.delete(agentId);
+      this.startingInboxes.drainOnSpawn(agentId);
+      this.assertStartPendingDeliveryInvariants("spawn-drain");
       this.agents.set(agentId, agentProcess);
       this.idleAgentConfigs.set(agentId, {
         config: this.buildRestartSafeConfig(runtimeConfig, restartSessionId),
@@ -14196,7 +14888,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         this.recordStartRebind(agentId, pendingStartRebind, "startup_registered", originalLaunchId, effectiveLaunchId, agentProcess.sessionId);
       }
       this.startRuntimeTrace(agentId, agentProcess, "spawn", wakeMessage ? [wakeMessage] : void 0, runtimeInputTraceAttrs);
-      this.agentsStarting.delete(agentId);
+      this.agentStarts.clearStarting(agentId);
       if (runtimeConfig.runtimeProfileControl) {
         this.ackInjectedRuntimeProfileControl(agentId, runtimeConfig.runtimeProfileControl, agentProcess.launchId);
       }
@@ -14500,7 +15192,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       this.broadcastActivity(agentId, "working", "Starting\u2026");
       this.startRuntimeStartupTimeout(agentId, agentProcess);
     } catch (err) {
-      this.agentsStarting.delete(agentId);
+      this.agentStarts.clearStarting(agentId);
       this.pendingStartRebinds.delete(agentId);
       this.cleanupFailedRuntimeStart(agentId, agentProcess, err);
       throw err;
@@ -14554,11 +15246,11 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     cleanupAgentCredentialProxy(agentId, ap.launchId);
     this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
     this.idleAgentConfigs.delete(agentId);
-    const pending = this.startingInboxes.get(agentId) || [];
     if (ap.inbox.length > 0) {
-      this.startingInboxes.set(agentId, [...pending, ...ap.inbox]);
+      this.startingInboxes.bufferMessagesDuringStart(agentId, ap.inbox);
     }
     this.terminalRuntimeFailures.set(agentId, { detail, launchId: ap.launchId });
+    this.assertStartPendingDeliveryInvariants("terminal-runtime-failure-cleanup");
     this.agents.delete(agentId);
     const diagnostics = buildRuntimeErrorDiagnosticEnvelope(detail);
     this.recordDaemonTrace("daemon.agent.terminal_runtime_error.cleanup", {
@@ -14801,10 +15493,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     );
   }
   queueRuntimeProfileNotificationDuringStart(agentId, message, kind, key) {
-    const pending = this.startingInboxes.get(agentId) || [];
-    pending.push(message);
-    this.startingInboxes.set(agentId, pending);
-    const queuedStart = this.queuedAgentStarts.get(agentId);
+    const startingInboxCount = this.startingInboxes.bufferDuringStart(agentId, message);
+    this.assertStartPendingDeliveryInvariants("runtime-profile-during-start");
+    const queuedStart = this.agentStarts.getQueued(agentId);
     this.recordDaemonTrace("daemon.agent.runtime_profile.routed", {
       agentId,
       kind,
@@ -14812,7 +15503,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       key_hash: hashRuntimeProfileKey(key),
       outcome: "queued_during_start",
       startup_pending: true,
-      starting_inbox_count: pending.length,
+      starting_inbox_count: startingInboxCount,
       launchId: queuedStart?.launchId
     });
     logger.info(`[Agent ${agentId}] Queued runtime profile ${kind} ${key} during startup`);
@@ -14844,8 +15535,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     this.agents.delete(agentId);
     if (!silent) {
       this.activityClientSeqByAgent.delete(agentId);
-      this.agentVisibleBoundaries.delete(agentId);
-      this.agentVisibleMessageIds.delete(agentId);
+      this.agentVisibleDelivery.clearAgent(agentId);
       this.resetSpawnFailBackoff(agentId);
       this.resetRuntimeErrorFingerprintFence(agentId, "explicit_stop", ap);
     }
@@ -14911,9 +15601,9 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
     }
     const ap = this.agents.get(agentId);
     if (!ap) {
-      if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
+      if (this.agentStarts.hasStarting(agentId) || this.agentStarts.hasQueued(agentId)) {
         if (transientDelivery) {
-          const queuedStart2 = this.queuedAgentStarts.get(agentId);
+          const queuedStart2 = this.agentStarts.getQueued(agentId);
           this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
             outcome: "transient_dropped_during_start",
             accepted: true,
@@ -14923,16 +15613,15 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           }));
           return true;
         }
-        const queuedStart = this.queuedAgentStarts.get(agentId);
-        const pending = this.startingInboxes.get(agentId) || [];
-        pending.push(message);
-        this.startingInboxes.set(agentId, pending);
+        const queuedStart = this.agentStarts.getQueued(agentId);
+        const startingInboxCount = this.startingInboxes.bufferDuringStart(agentId, message);
+        this.assertStartPendingDeliveryInvariants("delivery-during-start");
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
           outcome: "queued_during_start",
           accepted: true,
           process_present: false,
           startup_pending: true,
-          starting_inbox_count: pending.length,
+          starting_inbox_count: startingInboxCount,
           launchId: queuedStart?.launchId
         }));
         return true;
@@ -14950,16 +15639,15 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           }));
           return true;
         }
-        const pending = this.startingInboxes.get(agentId) || [];
-        pending.push(message);
-        this.startingInboxes.set(agentId, pending);
+        const startingInboxCount = this.startingInboxes.bufferDuringStart(agentId, message);
+        this.assertStartPendingDeliveryInvariants("delivery-terminal-runtime-error");
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
           outcome: "queued_terminal_runtime_error_no_process",
           accepted: true,
           process_present: false,
           cached_idle_config_present: false,
           terminal_runtime_failure: true,
-          starting_inbox_count: pending.length,
+          starting_inbox_count: startingInboxCount,
           launchId: terminalRuntimeFailure.launchId || void 0
         }));
         this.sendAgentStatus(agentId, "inactive", terminalRuntimeFailure.launchId);
@@ -14984,9 +15672,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
         logger.info(`[Agent ${agentId}] Starting from idle state for new message`);
         if (this.isSpawnFailBackoffActive(agentId)) {
           const state = this.agentSpawnFailBackoff.get(agentId);
-          const pending = this.startingInboxes.get(agentId) || [];
-          pending.push(message);
-          this.startingInboxes.set(agentId, pending);
+          const startingInboxCount = this.startingInboxes.bufferDuringStart(agentId, message);
+          this.assertStartPendingDeliveryInvariants("delivery-spawn-fail-cooldown");
           this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
             outcome: "spawn_fail_cooldown_active",
             accepted: true,
@@ -14997,7 +15684,7 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
             launchId: cached.launchId || void 0,
             spawn_fail_attempts: state.attempts,
             spawn_fail_until_ms: state.untilMs,
-            starting_inbox_count: pending.length
+            starting_inbox_count: startingInboxCount
           }));
           return true;
         }
@@ -15041,16 +15728,15 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
           return false;
         });
       }
-      if (!transientDelivery && (this.queuedAgentStarts.has(agentId) || this.agentsStarting.has(agentId))) {
-        const pending = this.startingInboxes.get(agentId) || [];
-        pending.push(message);
-        this.startingInboxes.set(agentId, pending);
+      if (!transientDelivery && (this.agentStarts.hasQueued(agentId) || this.agentStarts.hasStarting(agentId))) {
+        const startingInboxCount = this.startingInboxes.bufferDuringStart(agentId, message);
+        this.assertStartPendingDeliveryInvariants("delivery-queued-or-starting");
         this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
-          outcome: this.agentsStarting.has(agentId) ? "queued_for_starting_process" : "queued_for_queued_start",
+          outcome: this.agentStarts.hasStarting(agentId) ? "queued_for_starting_process" : "queued_for_queued_start",
           accepted: true,
           process_present: false,
           cached_idle_config_present: false,
-          starting_inbox_count: pending.length
+          starting_inbox_count: startingInboxCount
         }));
         return true;
       }
@@ -15631,8 +16317,8 @@ Use ${communicationCommand("read_history")} to catch up on the channels listed a
       });
       return written;
     }
-    if (this.agentsStarting.has(agentId) || this.queuedAgentStarts.has(agentId)) {
-      const queuedStart = this.queuedAgentStarts.get(agentId);
+    if (this.agentStarts.hasStarting(agentId) || this.agentStarts.hasQueued(agentId)) {
+      const queuedStart = this.agentStarts.getQueued(agentId);
       this.queueRuntimeProfileNotificationDuringStart(agentId, message, kind, key);
       span.end("ok", {
         attrs: {
@@ -18952,7 +19638,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> or ${DAEMON_API_KEY_ENV}=<key>)`;
+var DAEMON_CLI_USAGE = "Usage: slock-daemon --server-url <url> --api-key <key>";
 var RunnerCredentialMintError2 = class extends Error {
   code;
   retryable;
@@ -18988,9 +19674,9 @@ function runnerCredentialErrorDetail2(error) {
 async function waitForRunnerCredentialRetry2() {
   await new Promise((resolve) => setTimeout(resolve, RUNNER_CREDENTIAL_MINT_RETRY_DELAY_MS2));
 }
-function parseDaemonCliArgs(args, env = {}) {
+function parseDaemonCliArgs(args) {
   let serverUrl = "";
-  let apiKey = env[DAEMON_API_KEY_ENV] ?? "";
+  let apiKey = "";
   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];
@@ -19027,7 +19713,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-CBVXAPI6.js");
+  await import("./dist-TPCGG5OS.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];
@@ -19964,8 +20650,6 @@ var DaemonCore = class {
 
 export {
   subscribeDaemonLogs,
-  DAEMON_API_KEY_ENV,
-  scrubDaemonAuthEnv,
   resolveWorkspaceDirectoryPath,
   scanWorkspaceDirectories,
   deleteWorkspaceDirectory,