@botiverse/raft-daemon 0.65.0 → 0.66.0

package/dist/{chunk-53ZFBLI4.js → chunk-EX73HXGE.js}

@@ -820,17 +820,26 @@ function projectApmHeldFreshnessActivity(input) {
     countLine,
     ...decisionLines
   ].filter((line) => Boolean(line)).join("\n");
+  const statusEntry = {
+    kind: "status",
+    activity: "working",
+    detail: title,
+    producerFactId: input.producerFactId
+  };
+  const entry = {
+    kind: "slock_action",
+    producerFactId: input.producerFactId,
+    title,
+    text
+  };
   return {
     clauseId: "SMR-006",
     projector: "held-envelope",
     surface: "agent:activity",
     producerFactId: input.producerFactId,
-    entry: {
-      kind: "slock_action",
-      producerFactId: input.producerFactId,
-      title,
-      text
-    }
+    statusEntry,
+    entry,
+    entries: [statusEntry, entry]
   };
 }
 function projectApmFreshnessDecisionTrace(input) {
@@ -1347,6 +1356,7 @@ var TOOL_DISPLAY_METADATA = {
   claim_tasks: { logLabel: "Claiming tasks", activityLabel: "Claiming tasks\u2026", summaryKind: "claim_tasks" },
   unclaim_task: { logLabel: "Unclaiming task", activityLabel: "Unclaiming task\u2026", summaryKind: "task_ref" },
   update_task_status: { logLabel: "Updating task status", activityLabel: "Updating task status\u2026", summaryKind: "task_ref" },
+  add_channel_member: { logLabel: "Adding channel member", activityLabel: "Adding channel member\u2026", summaryKind: "target" },
   join_channel: { logLabel: "Joining channel", activityLabel: "Joining channel\u2026", summaryKind: "target" },
   leave_channel: { logLabel: "Leaving channel", activityLabel: "Leaving channel\u2026", summaryKind: "target" },
   upload_file: { logLabel: "Uploading file", activityLabel: "Uploading file\u2026", summaryKind: "file_path" },
@@ -1378,6 +1388,7 @@ var KNOWN_TOOL_ALIASES = {
   claim_tasks: "claim_tasks",
   unclaim_task: "unclaim_task",
   update_task_status: "update_task_status",
+  add_channel_member: "add_channel_member",
   join_channel: "join_channel",
   leave_channel: "leave_channel",
   upload_file: "upload_file",
@@ -1595,8 +1606,44 @@ function resolveSlockCliInvocation(toolName, input) {
       return { toolName: "search_messages", input: { query: readOptionValue(rest, "--query") } };
     case "server info":
       return { toolName: "list_server", input: {} };
+    case "server update":
+      return {
+        toolName: "update_server",
+        input: {
+          name: readOptionValue(rest, "--name"),
+          avatar_file: readOptionValue(rest, "--avatar-file")
+        }
+      };
     case "channel members":
       return { toolName: "list_channel_members", input: { channel: rest[0] } };
+    case "channel update":
+      return {
+        toolName: "update_channel",
+        input: {
+          target: readOptionValue(rest, "--target"),
+          name: readOptionValue(rest, "--name"),
+          description: readOptionValue(rest, "--description"),
+          visibility: rest.includes("--private") ? "private" : rest.includes("--public") ? "public" : void 0
+        }
+      };
+    case "channel add-member":
+      return {
+        toolName: "add_channel_member",
+        input: {
+          target: readOptionValue(rest, "--target"),
+          user: readOptionValue(rest, "--user"),
+          agent: readOptionValue(rest, "--agent")
+        }
+      };
+    case "channel remove-member":
+      return {
+        toolName: "remove_channel_member",
+        input: {
+          target: readOptionValue(rest, "--target"),
+          user: readOptionValue(rest, "--user"),
+          agent: readOptionValue(rest, "--agent")
+        }
+      };
     case "channel join":
       return { toolName: "join_channel", input: { target: readOptionValue(rest, "--target") } };
     case "channel leave":
@@ -1830,6 +1877,21 @@ var agentApiHistoryQuerySchema = passthroughObject({
   around: optionalStringSchema,
   limit: optionalStringSchema
 });
+var agentApiKnowledgeGetQuerySchema = passthroughObject({
+  topic: z2.string().trim().min(1),
+  reason: optionalStringSchema,
+  turn_id: optionalStringSchema,
+  trace_id: optionalStringSchema
+});
+var agentApiKnowledgeGetResponseSchema = passthroughObject({
+  ok: z2.literal(true),
+  docId: z2.string(),
+  topicOrPath: z2.string(),
+  docVersion: z2.string(),
+  docState: z2.string(),
+  contentType: z2.string(),
+  content: z2.string()
+});
 var agentApiMessageSearchQuerySchema = passthroughObject({
   q: optionalStringSchema,
   channel: optionalStringSchema,
@@ -1867,6 +1929,58 @@ var agentApiMessageReactionBodySchema = passthroughObject({
 var agentApiChannelMembershipParamsSchema = passthroughObject({
   channelId: z2.string().trim().min(1).transform(asChannelId)
 });
+var agentApiAttachmentDownloadParamsSchema = passthroughObject({
+  attachmentId: z2.string().trim().min(1)
+});
+var agentApiAttachmentCommentsParamsSchema = passthroughObject({
+  attachmentId: z2.string().trim().min(1)
+});
+var agentApiAttachmentCommentsQuerySchema = passthroughObject({
+  limit: optionalStringSchema
+});
+var agentApiAttachmentCommentAnchorSchema = passthroughObject({
+  type: z2.string().trim().min(1),
+  data: z2.record(z2.string(), z2.unknown())
+});
+var agentApiAttachmentCommentReactionSchema = passthroughObject({
+  emoji: z2.string().trim().min(1),
+  reactorType: z2.string().trim().min(1),
+  reactorId: z2.string().trim().min(1),
+  createdAt: z2.string().datetime()
+});
+var agentApiAttachmentCommentResolvedBySchema = passthroughObject({
+  reactorId: z2.string().trim().min(1),
+  reactorType: z2.string().trim().min(1)
+});
+var agentApiAttachmentCommentSchema = passthroughObject({
+  id: z2.string().trim().min(1),
+  channelId: z2.string().trim().min(1).optional(),
+  senderId: z2.string().trim().min(1),
+  senderType: z2.enum(["user", "agent"]),
+  senderName: z2.string().trim().min(1),
+  senderAvatarUrl: nullableStringSchema.optional(),
+  senderGravatarHash: nullableStringSchema.optional(),
+  content: z2.string(),
+  createdAt: z2.string().datetime(),
+  reactions: z2.array(agentApiAttachmentCommentReactionSchema),
+  anchor: agentApiAttachmentCommentAnchorSchema.nullable(),
+  resolved: z2.boolean().optional(),
+  resolvedBy: agentApiAttachmentCommentResolvedBySchema.nullable().optional(),
+  resolvedAt: z2.string().datetime().nullable().optional()
+});
+var agentApiAttachmentCommentsResponseSchema = passthroughObject({
+  comments: z2.array(agentApiAttachmentCommentSchema),
+  threadChannelId: nullableStringSchema.optional(),
+  viewer: passthroughObject({
+    canComment: z2.boolean(),
+    reason: z2.string().optional(),
+    canResolve: z2.boolean(),
+    resolveAction: passthroughObject({
+      type: z2.string().trim().min(1),
+      emoji: z2.string().trim().min(1)
+    }).optional()
+  }).optional()
+});
 var agentApiChannelMembersQuerySchema = passthroughObject({
   channel: z2.string().trim().min(1)
 });
@@ -2021,6 +2135,9 @@ var agentApiIntegrationAppPrepareBodySchema = passthroughObject({
   unsafeDemoUrlOverride: optionalBooleanSchema,
   draftHint: optionalStringSchema
 });
+var agentApiIntegrationAppRotateSecretBodySchema = passthroughObject({
+  clientKey: z2.string().trim().min(1)
+});
 var agentApiActionPrepareBodySchema = passthroughObject({
   target: z2.string().trim().min(1),
   action: actionCardActionSchema
@@ -2028,6 +2145,9 @@ var agentApiActionPrepareBodySchema = passthroughObject({
 var agentApiServerInfoResponseSchema = passthroughObject({
   runtimeContext: passthroughObject({
     agentId: z2.string(),
+    runtime: z2.string().optional(),
+    model: z2.string().optional(),
+    reasoningEffort: reasoningEffortSchema.nullable().optional(),
     serverId: z2.string(),
     machineId: z2.string().nullable().optional(),
     machineName: z2.string().nullable().optional(),
@@ -2044,10 +2164,12 @@ var agentApiServerInfoResponseSchema = passthroughObject({
     joined: z2.boolean()
   })),
   agents: z2.array(passthroughObject({
-    name: z2.string()
+    name: z2.string(),
+    role: z2.enum(["owner", "admin", "member"]).nullable().optional()
   })),
   humans: z2.array(passthroughObject({
-    name: z2.string()
+    name: z2.string(),
+    role: z2.enum(["owner", "admin", "member"]).nullable().optional()
   }))
 });
 var agentApiMentionActionsPendingQuerySchema = passthroughObject({
@@ -2122,6 +2244,12 @@ var agentApiIntegrationAppPrepareResponseSchema = passthroughObject({
     integrationUpdateAppRegistrationOperationSchema
   ])
 });
+var agentApiIntegrationAppRotateSecretResponseSchema = passthroughObject({
+  clientId: z2.string(),
+  clientKey: z2.string(),
+  clientName: z2.string(),
+  clientSecret: z2.string()
+});
 var agentApiAttachmentEnvelopeSchema = passthroughObject({
   id: z2.string(),
   filename: z2.string()
@@ -2257,6 +2385,21 @@ var agentApiChannelMembersResponseSchema = passthroughObject({
     role: optionalStringSchema
   }))
 });
+var agentApiChannelMuteResponseSchema = passthroughObject({
+  activityMuted: optionalBooleanSchema,
+  muteFromSeq: nullableNumberSchema.optional(),
+  attention: passthroughObject({
+    state: optionalStringSchema,
+    ordinaryActivity: optionalStringSchema,
+    unmuteCommand: optionalStringSchema,
+    unmuteApi: optionalStringSchema,
+    muteCommand: optionalStringSchema,
+    muteApi: optionalStringSchema,
+    stillArrives: optionalStringArraySchema,
+    threadBoundary: optionalStringSchema,
+    catchUp: optionalStringSchema
+  }).optional()
+});
 var agentApiTaskClaimResultSchema = passthroughObject({
   taskNumber: z2.number().int().positive().optional(),
   messageId: optionalStringSchema,
@@ -2369,6 +2512,16 @@ var agentApiContract = {
     request: { query: agentApiHistoryQuerySchema },
     response: { body: agentApiHistoryResponseSchema }
   }),
+  knowledgeGet: route({
+    key: "knowledgeGet",
+    method: "GET",
+    path: "/knowledge",
+    client: { resource: "knowledge", method: "get" },
+    capability: "knowledge",
+    description: "Fetch a Slock Manual for Agents topic from the current server.",
+    request: { query: agentApiKnowledgeGetQuerySchema },
+    response: { body: agentApiKnowledgeGetResponseSchema }
+  }),
   messageSend: route({
     key: "messageSend",
     method: "POST",
@@ -2439,6 +2592,26 @@ var agentApiContract = {
     request: { params: agentApiChannelMembershipParamsSchema },
     response: { body: agentApiOkResponseSchema }
   }),
+  channelMute: route({
+    key: "channelMute",
+    method: "POST",
+    path: "/channels/:channelId/mute",
+    client: { resource: "channels", method: "mute" },
+    capability: "channels",
+    description: "Mute ordinary activity delivery for a visible regular channel as the bound agent credential.",
+    request: { params: agentApiChannelMembershipParamsSchema },
+    response: { body: agentApiChannelMuteResponseSchema }
+  }),
+  channelUnmute: route({
+    key: "channelUnmute",
+    method: "POST",
+    path: "/channels/:channelId/unmute",
+    client: { resource: "channels", method: "unmute" },
+    capability: "channels",
+    description: "Unmute ordinary activity delivery for a visible regular channel as the bound agent credential.",
+    request: { params: agentApiChannelMembershipParamsSchema },
+    response: { body: agentApiChannelMuteResponseSchema }
+  }),
   channelMembers: route({
     key: "channelMembers",
     method: "GET",
@@ -2629,6 +2802,16 @@ var agentApiContract = {
     request: { body: agentApiProfileUpdateBodySchema },
     response: { body: agentApiProfileViewSchema }
   }),
+  profileAvatarUpdate: route({
+    key: "profileAvatarUpdate",
+    method: "POST",
+    path: "/profile/avatar",
+    client: { resource: "profile", method: "updateAvatar" },
+    capability: "server",
+    description: "Update the bound agent profile avatar using multipart form data.",
+    request: {},
+    response: { body: agentApiProfileViewSchema }
+  }),
   integrationList: route({
     key: "integrationList",
     method: "GET",
@@ -2659,6 +2842,22 @@ var agentApiContract = {
     request: { body: agentApiIntegrationAppPrepareBodySchema },
     response: { body: agentApiIntegrationAppPrepareResponseSchema }
   }),
+  integrationAppRotateSecret: route({
+    key: "integrationAppRotateSecret",
+    method: "POST",
+    path: "/integrations/app/rotate-secret",
+    client: { resource: "integrations", method: "rotateAppSecret" },
+    // Mirrors integrationAppPrepare's "read" capability: the AgentApiCapability
+    // enum has no generic "mutation"/"integrations" scope, and the sibling
+    // integration app routes (prepare/login) all gate on "read". Owner-scope is
+    // enforced server-side in rotateClientSecretForAgent's WHERE clause (and the
+    // bound agent credential), so the capability tier is not the security
+    // boundary here. Keep parity with integrationAppPrepare.
+    capability: "read",
+    description: "Regenerate the one-time client secret for a server-local integration app the calling agent owns; invalidates the previous secret.",
+    request: { body: agentApiIntegrationAppRotateSecretBodySchema },
+    response: { body: agentApiIntegrationAppRotateSecretResponseSchema }
+  }),
   actionPrepare: route({
     key: "actionPrepare",
     method: "POST",
@@ -2678,6 +2877,131 @@ var agentApiContract = {
     description: "Upload a multipart attachment as the bound agent credential.",
     request: {},
     response: { body: agentApiAttachmentUploadResponseSchema }
+  }),
+  attachmentDownload: route({
+    key: "attachmentDownload",
+    method: "GET",
+    path: "/attachments/:attachmentId",
+    client: { resource: "attachments", method: "download" },
+    capability: "read",
+    description: "Download attachment bytes visible to the bound agent credential.",
+    request: { params: agentApiAttachmentDownloadParamsSchema },
+    response: { kind: "binary" }
+  }),
+  attachmentCommentsList: route({
+    key: "attachmentCommentsList",
+    method: "GET",
+    path: "/attachments/:attachmentId/comments",
+    client: { resource: "attachments", method: "comments" },
+    capability: "read",
+    description: "List comments scoped to an attachment visible to the bound agent credential.",
+    request: { params: agentApiAttachmentCommentsParamsSchema, query: agentApiAttachmentCommentsQuerySchema },
+    response: { body: agentApiAttachmentCommentsResponseSchema }
+  })
+};
+
+// ../shared/src/daemonApiContract.ts
+import { z as z3 } from "zod";
+var DAEMON_API_BASE_PATH = "/internal/agent-api";
+var optionalStringSchema2 = z3.string().trim().optional();
+var optionalNonNegativeIntSchema = z3.number().int().nonnegative().optional();
+var optionalQueryIntSchema = z3.union([z3.number().int().nonnegative(), z3.string().trim().min(1)]).optional();
+var nullableNumberSchema2 = z3.number().finite().nullable();
+var passthroughObject2 = (shape) => z3.object(shape).passthrough();
+var daemonApiInboxFlagSchema = z3.enum(["mention", "thread", "dm", "task"]);
+var daemonApiInboxTargetRowSchema = passthroughObject2({
+  target: z3.string().trim().min(1),
+  channelId: optionalStringSchema2,
+  channelType: optionalStringSchema2,
+  pendingCount: z3.number().int().nonnegative(),
+  firstPendingMsgId: optionalStringSchema2,
+  firstPendingSeq: optionalNonNegativeIntSchema,
+  latestMsgId: optionalStringSchema2,
+  latestSeq: optionalNonNegativeIntSchema,
+  latestSenderName: optionalStringSchema2,
+  latestSenderType: z3.enum(["human", "agent", "system"]).optional(),
+  flags: z3.array(daemonApiInboxFlagSchema)
+});
+var daemonApiInboxCheckResponseSchema = passthroughObject2({
+  rows: z3.array(daemonApiInboxTargetRowSchema).optional()
+});
+var daemonApiWakeHintsQuerySchema = passthroughObject2({
+  since: z3.union([z3.literal("latest"), z3.number().int().nonnegative(), z3.string().trim().min(1)]).optional(),
+  limit: optionalQueryIntSchema
+});
+var daemonApiWakeHintSchema = passthroughObject2({
+  hintId: optionalStringSchema2,
+  hint_id: optionalStringSchema2,
+  eventId: optionalStringSchema2,
+  event_id: optionalStringSchema2,
+  messageId: z3.string().nullable().optional(),
+  message_id: z3.string().nullable().optional(),
+  seq: optionalNonNegativeIntSchema,
+  id: optionalStringSchema2,
+  target: optionalStringSchema2,
+  targetType: optionalStringSchema2,
+  target_type: optionalStringSchema2,
+  reason: optionalStringSchema2,
+  wake_reason: optionalStringSchema2,
+  createdAt: optionalStringSchema2,
+  created_at: optionalStringSchema2
+});
+var daemonApiWakeHintsFetchResponseSchema = passthroughObject2({
+  hints: z3.array(daemonApiWakeHintSchema).optional(),
+  wake_hints: z3.array(daemonApiWakeHintSchema).optional(),
+  last_seen_hint_seq: nullableNumberSchema2.optional(),
+  last_hint_seq: nullableNumberSchema2.optional(),
+  has_more: z3.boolean().optional()
+});
+var daemonApiActivityEventSchema = passthroughObject2({
+  schema: optionalStringSchema2
+});
+var daemonApiActivityForwardBodySchema = passthroughObject2({
+  schema: z3.literal("raft-agent-activity-ingest.v1"),
+  coreSessionId: optionalStringSchema2,
+  adapterInstance: optionalStringSchema2,
+  events: z3.array(daemonApiActivityEventSchema),
+  dropped: optionalNonNegativeIntSchema
+});
+var daemonApiActivityForwardResponseSchema = passthroughObject2({
+  ok: z3.literal(true).optional(),
+  acceptedCount: z3.number().int().nonnegative().optional(),
+  rejectedCount: z3.number().int().nonnegative().optional(),
+  droppedCount: z3.number().int().nonnegative().optional()
+});
+function route2(input) {
+  return {
+    ...input,
+    fullPath: `${DAEMON_API_BASE_PATH}${input.path}`
+  };
+}
+var daemonApiContract = {
+  inboxCheck: route2({
+    key: "inboxCheck",
+    method: "GET",
+    path: "/inbox",
+    client: { resource: "inbox", method: "check" },
+    description: "Read the managed-runner daemon inbox snapshot without draining message content.",
+    request: {},
+    response: { body: daemonApiInboxCheckResponseSchema }
+  }),
+  wakeHintsFetch: route2({
+    key: "wakeHintsFetch",
+    method: "GET",
+    path: "/wake-hints",
+    client: { resource: "wakeHints", method: "fetch" },
+    description: "Peek content-free wake hints without advancing delivery cursors.",
+    request: { query: daemonApiWakeHintsQuerySchema },
+    response: { body: daemonApiWakeHintsFetchResponseSchema }
+  }),
+  activityForward: route2({
+    key: "activityForward",
+    method: "POST",
+    path: "/activity",
+    client: { resource: "activity", method: "forward" },
+    description: "Forward plugin-observed activity from a local bridge to the daemon/server activity ingest path.",
+    request: { body: daemonApiActivityForwardBodySchema },
+    response: { body: daemonApiActivityForwardResponseSchema }
   })
 };
 
@@ -2708,7 +3032,7 @@ function shortMessageId(value) {
 }
 
 // ../shared/src/externalAgentIntegration.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 var EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION = "agent-comms-core.v1";
 var EXTERNAL_AGENT_PROOF_SCHEMA_VERSION = "agent-proof.v1";
 var EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA = "slock-external-runtime-integration.v1";
@@ -2752,35 +3076,35 @@ var externalAgentAdapterFailureValues = [
   "auth_revoked"
 ];
 var externalAgentServerApiModeValues = ["interim-agent-api-events", "agent-inbox-protocol"];
-var nonEmptyStringSchema = z3.string().min(1);
-var isoTimestampSchema = z3.string().refine((value) => !Number.isNaN(Date.parse(value)), {
+var nonEmptyStringSchema = z4.string().min(1);
+var isoTimestampSchema = z4.string().refine((value) => !Number.isNaN(Date.parse(value)), {
   message: "must be a parseable timestamp"
 });
-var externalRuntimeIntegrationManifestSchema = z3.object({
-  schema: z3.literal(EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA),
+var externalRuntimeIntegrationManifestSchema = z4.object({
+  schema: z4.literal(EXTERNAL_RUNTIME_INTEGRATION_MANIFEST_SCHEMA),
   runtimeId: nonEmptyStringSchema,
-  integrationPattern: z3.enum(externalAgentIntegrationPatternValues),
-  commsMode: z3.enum(externalAgentCommsModeValues),
-  commsProtocolVersion: z3.literal(EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION),
-  proofSchemaVersion: z3.literal(EXTERNAL_AGENT_PROOF_SCHEMA_VERSION),
+  integrationPattern: z4.enum(externalAgentIntegrationPatternValues),
+  commsMode: z4.enum(externalAgentCommsModeValues),
+  commsProtocolVersion: z4.literal(EXTERNAL_AGENT_COMMS_PROTOCOL_VERSION),
+  proofSchemaVersion: z4.literal(EXTERNAL_AGENT_PROOF_SCHEMA_VERSION),
   minSlockCliVersion: nonEmptyStringSchema,
-  multiplex: z3.boolean(),
-  agentIsolation: z3.enum(externalAgentIsolationValues),
-  bridgeLifecycle: z3.object({
-    explicitStartOnly: z3.literal(true),
-    oneShotCommandsBridgeIndependent: z3.literal(true),
-    requiresBridgeFailureCodes: z3.array(z3.enum(["BRIDGE_NOT_RUNNING", "NO_CORE_SESSION"])).min(1),
-    autoStartDefault: z3.literal(false)
+  multiplex: z4.boolean(),
+  agentIsolation: z4.enum(externalAgentIsolationValues),
+  bridgeLifecycle: z4.object({
+    explicitStartOnly: z4.literal(true),
+    oneShotCommandsBridgeIndependent: z4.literal(true),
+    requiresBridgeFailureCodes: z4.array(z4.enum(["BRIDGE_NOT_RUNNING", "NO_CORE_SESSION"])).min(1),
+    autoStartDefault: z4.literal(false)
   }).strict(),
-  serverApi: z3.object({
-    mode: z3.enum(externalAgentServerApiModeValues),
-    deliveryOnly: z3.boolean(),
-    cursorAuthority: z3.literal("model_seen_only")
+  serverApi: z4.object({
+    mode: z4.enum(externalAgentServerApiModeValues),
+    deliveryOnly: z4.boolean(),
+    cursorAuthority: z4.literal("model_seen_only")
   }).strict(),
-  wakeAdapter: z3.object({
-    kind: z3.enum(externalAgentWakeAdapterKindValues),
+  wakeAdapter: z4.object({
+    kind: z4.enum(externalAgentWakeAdapterKindValues),
     protocol: nonEmptyStringSchema,
-    requiresInteractiveSession: z3.boolean().optional()
+    requiresInteractiveSession: z4.boolean().optional()
   }).strict()
 }).strict().superRefine((value, ctx) => {
   if (!value.bridgeLifecycle.requiresBridgeFailureCodes.includes("BRIDGE_NOT_RUNNING")) {
@@ -2805,8 +3129,8 @@ var externalRuntimeIntegrationManifestSchema = z3.object({
     });
   }
 });
-var externalAgentWakeEventBaseSchema = z3.object({
-  schema: z3.literal(EXTERNAL_AGENT_WAKE_EVENT_SCHEMA),
+var externalAgentWakeEventBaseSchema = z4.object({
+  schema: z4.literal(EXTERNAL_AGENT_WAKE_EVENT_SCHEMA),
   eventId: nonEmptyStringSchema,
   attemptId: nonEmptyStringSchema,
   messageId: nonEmptyStringSchema,
@@ -2816,30 +3140,30 @@ var externalAgentWakeEventBaseSchema = z3.object({
   adapterInstance: nonEmptyStringSchema,
   runtimeSession: nonEmptyStringSchema.nullable(),
   occurredAt: isoTimestampSchema,
-  lifecycleState: z3.enum(externalAgentCommsLifecycleStateValues),
-  authority: z3.object({
-    source: z3.enum(externalAgentLifecycleSourceValues),
-    provenance: z3.enum(externalAgentLifecycleProvenanceValues)
+  lifecycleState: z4.enum(externalAgentCommsLifecycleStateValues),
+  authority: z4.object({
+    source: z4.enum(externalAgentLifecycleSourceValues),
+    provenance: z4.enum(externalAgentLifecycleProvenanceValues)
   }).strict()
 }).strict();
 var externalAgentProofEventEnvelopeSchema = externalAgentWakeEventBaseSchema.extend({
-  kind: z3.literal("proof"),
-  proofLevel: z3.enum(externalAgentWakeProofLevelValues),
-  outcome: z3.literal("ok"),
-  failureMeta: z3.undefined().optional(),
-  reason: z3.string().optional()
+  kind: z4.literal("proof"),
+  proofLevel: z4.enum(externalAgentWakeProofLevelValues),
+  outcome: z4.literal("ok"),
+  failureMeta: z4.undefined().optional(),
+  reason: z4.string().optional()
 });
 var externalAgentFailedWakeEventEnvelopeSchema = externalAgentWakeEventBaseSchema.extend({
-  kind: z3.literal("wake_attempt"),
-  proofLevel: z3.undefined().optional(),
-  outcome: z3.literal("failed"),
-  failureMeta: z3.object({
-    failureClass: z3.enum(externalAgentAdapterFailureValues),
-    retryAfterMs: z3.number().int().positive().optional()
+  kind: z4.literal("wake_attempt"),
+  proofLevel: z4.undefined().optional(),
+  outcome: z4.literal("failed"),
+  failureMeta: z4.object({
+    failureClass: z4.enum(externalAgentAdapterFailureValues),
+    retryAfterMs: z4.number().int().positive().optional()
   }).strict(),
   reason: nonEmptyStringSchema
 });
-var externalAgentWakeEventEnvelopeSchema = z3.discriminatedUnion("kind", [
+var externalAgentWakeEventEnvelopeSchema = z4.discriminatedUnion("kind", [
   externalAgentProofEventEnvelopeSchema,
   externalAgentFailedWakeEventEnvelopeSchema
 ]);
@@ -3382,7 +3706,7 @@ var TRIAL_DURATION_DAYS = (TRIAL_END_DATE.getTime() - TRIAL_START_DATE.getTime()
 // src/agentProcessManager.ts
 import { existsSync as existsSync8, mkdirSync as mkdirSync4, readFileSync as readFileSync6, readdirSync as readdirSync4, statSync, writeFileSync as writeFileSync4 } from "fs";
 import { mkdir, writeFile, access, readdir as readdir2, stat as stat2, readFile, rm as rm2, lstat, realpath, open } from "fs/promises";
-import { createHash as createHash3, randomUUID as randomUUID5 } from "crypto";
+import { createHash as createHash3, randomUUID as randomUUID6 } from "crypto";
 import path14 from "path";
 import { gzipSync } from "zlib";
 import os6 from "os";
@@ -3797,40 +4121,20 @@ function buildCommunicationSection(audience) {
   const installation = describeSlockInstallation(audience);
   return `## Communication \u2014 raft CLI ONLY
 
-Use the \`raft\` CLI for chat / task / attachment operations (\`slock\` remains a legacy alias). ${installation} Use ONLY these commands for communication:
-
-1. **\`raft message check\`** \u2014 Non-blocking check for new messages. Use freely during work \u2014 at natural breakpoints or after notifications.
-2. **\`raft message send\`** \u2014 Send a message to a channel or DM.
-3. **\`raft server info\`** \u2014 List channels in this server, which ones you have joined, plus all agents and humans.
-4. **\`raft channel members\`** \u2014 List the members (agents and humans) of a specific channel, DM, or thread target.
-5. **\`raft channel join\`** \u2014 Join a visible public channel. This only affects your own agent membership.
-6. **\`raft channel leave\`** \u2014 Leave a regular channel you have joined. This only affects your own agent membership.
-7. **\`raft channel mute\`** \u2014 Mute ordinary Activity delivery for a regular channel for your agent. Personal @mentions and DMs still pierce; a task pierces only when it personally @mentions you (being a task does not pierce).
-8. **\`raft channel unmute\`** \u2014 Unmute ordinary Activity delivery for a regular channel for your agent. Muted-window messages are not retroactively promoted.
-9. **\`raft thread unfollow\`** \u2014 Stop receiving ordinary delivery for a thread you no longer need to follow. This only affects your own agent attention state.
-10. **\`raft message read\`** \u2014 Read past messages from a channel, DM, or thread. Supports \`before\` / \`after\` anchors and \`around\` for centered context.
-11. **\`raft message search\`** \u2014 Search messages visible to you, then inspect a hit with \`raft message read\`.
-12. **\`raft message resolve\`** \u2014 Verify that a cited message id exists exactly and print its canonical message row. Use this when checking whether a referenced id is real; \`read --around\` is for context, not proof.
-13. **\`raft message react\`** \u2014 Add or remove your reaction on a message. Use sparingly: prefer acknowledgement/follow-up signals like \u{1F440}, and do not auto-react to every merge, deploy, or task completion with celebratory emoji.
-14. **\`raft task list\`** \u2014 View a channel's task board.
-15. **\`raft task create\`** \u2014 Create new task-messages in a channel (supports batch titles; equivalent to sending a new message and publishing it as a task-message, not claiming it for yourself).
-16. **\`raft task claim\`** \u2014 Claim tasks by number or message ID using repeatable flags; examples: \`raft task claim --channel "#channel" --number 1 --number 2\`, or \`raft task claim --channel "#channel" --message-id abc12345\`.
-17. **\`raft task unclaim\`** \u2014 Release your claim on a task.
-18. **\`raft task update\`** \u2014 Change a task's status (e.g. to in_review or done).
-19. **\`raft attachment upload\`** \u2014 Upload a file to attach to a message. Uses content sniffing for image previews; pass \`--mime-type\` only when you know the exact type. Returns an attachment ID to pass to \`raft message send\`.
-20. **\`raft attachment view\`** \u2014 Download an attached file by its attachment ID so you can inspect it locally.
-21. **\`raft profile show\`** \u2014 Show your own profile, or another visible profile via \`@handle\`. Mirrors the canonical Slock profile view.
-22. **\`raft profile update\`** \u2014 Update your own profile. Supports \`--avatar-file <path>\`, \`--avatar-url pixel:random:<seed>\`, \`--display-name <name>\`, and \`--description <text>\`. Use \`--avatar-url pixel:random:<seed>\` when you want a new pixel avatar but do not have a local image file. Values must be non-empty. Provide at least one flag per call; multiple flags can be combined.
-23. **\`raft integration list\`** \u2014 List built-in Slock apps, registered third-party services, and this agent's active Slock Agent Logins.
-24. **\`raft integration login\`** \u2014 Provision or reuse this agent's login for a built-in Slock app or registered third-party service.
-25. **\`raft integration env\`** \u2014 Print per-agent local CLI environment for a manifest-backed service that requires isolated HOME/XDG state.
-26. **\`raft reminder schedule\`** \u2014 Schedule a reminder for yourself later, at a specific time, or on a recurring cadence.
-27. **\`raft reminder list\`** \u2014 List your reminders, including lifecycle history for each reminder.
-28. **\`raft reminder snooze\`** \u2014 Push a reminder later without replacing it.
-29. **\`raft reminder update\`** \u2014 Change a reminder's title, schedule, or recurrence without creating a new reminder.
-30. **\`raft reminder cancel\`** \u2014 Cancel one of your reminders by ID.
-31. **\`raft reminder log\`** \u2014 Show the event log for a reminder, including fires, dismissals, and reschedules.
-32. **\`raft action prepare\`** \u2014 Prepare an action card for a human to commit (B-mode quick-commit shortcut). Posts a card the human can click to execute the action under their own identity. Pass \`--target <ch>\` and pipe the action JSON on stdin (variants: \`channel:create\`, \`agent:create\`).
+Use the \`raft\` CLI for chat / task / attachment operations (\`slock\` remains a legacy alias). ${installation} Use ONLY these command families for communication and management:
+
+1. **Messages** \u2014 \`raft message check\`, \`raft message send\`, \`raft message read\`, \`raft message search\`, \`raft message resolve\`, \`raft message react\`.
+2. **Server and channel awareness** \u2014 \`raft server info\`, \`raft channel members\`.
+3. **Your channel/thread attention** \u2014 \`raft channel join\`, \`raft channel leave\`, \`raft channel mute\`, \`raft channel unmute\`, \`raft thread unfollow\`.
+4. **Admin channel/server management** \u2014 \`raft channel create\`, \`raft channel update\`, \`raft channel add-member\`, \`raft channel remove-member\`, \`raft server update\`.
+5. **Tasks** \u2014 \`raft task list\`, \`raft task create\`, \`raft task claim\`, \`raft task unclaim\`, \`raft task update\`.
+6. **Attachments** \u2014 \`raft attachment upload\`, \`raft attachment view\`.
+7. **Profiles** \u2014 \`raft profile show\`, \`raft profile update\`.
+8. **Integrations** \u2014 \`raft integration list\`, \`raft integration login\`, \`raft integration env\`, \`raft integration invoke\`.
+9. **Reminders** \u2014 \`raft reminder schedule\`, \`raft reminder list\`, \`raft reminder snooze\`, \`raft reminder update\`, \`raft reminder cancel\`, \`raft reminder log\`.
+10. **Action cards** \u2014 \`raft action prepare\`.
+
+Run any subcommand with \`--help\` for syntax.
 
 The CLI prints human-readable canonical text on success (matching the format you see in received messages and history). On failure it prints canonical labeled text to stderr:
 - \`Error:\` human-readable error summary
@@ -3947,7 +4251,7 @@ Only top-level channel / DM messages can become tasks. Messages inside threads a
 
 **Workflow:**
 1. Receive a message that requires action \u2192 claim it first (by task number if already a task, or by message ID if it's a regular message). Use repeat flags: \`raft task claim --channel "#channel" --number 1 --number 2\` or \`raft task claim --channel "#channel" --message-id abc12345\`.
-2. If the claim fails, someone else is working on it \u2014 move on to another task
+2. If the claim fails, someone else is working on it \u2014 do not work on that task unless an owner/admin explicitly redirects it to you
 3. Post updates in the task's thread: \`raft message send --target "#channel:msgShortId" <<'${D}'\` followed by the message body and \`${D}\`
 4. When done, set status to \`in_review\` so a human can validate via \`raft task update\`
 5. After approval (e.g. "looks good", "merge it"), set status to \`done\`
@@ -4001,7 +4305,7 @@ function buildConversationEtiquetteSection(taskClaimCmd = "`raft task claim`") {
 
 - **Respect ongoing conversations.** If a human is having a back-and-forth with another person (human or agent) on a topic, their follow-up messages are directed at that person \u2014 only join if you are explicitly @mentioned or clearly addressed.
 - **Only the person doing the work should report on it.** If someone else completed a task or submitted a PR, don't echo or summarize their work \u2014 let them respond to questions about it.
-- **Claim before you start.** Always call ${taskClaimCmd} before doing any work on a task. If the claim fails, stop immediately and pick a different task.
+- **Claim before you start.** Always call ${taskClaimCmd} before doing any work on a task. If the claim fails, do not work on that task unless an owner/admin explicitly redirects it to you.
 - **Before stopping, check for concrete blockers you own.** If you still owe a specific handoff, review, decision, or reply that is currently blocking a specific person, send one minimal actionable message to that person or channel before stopping.
 - **Skip idle narration.** Only send messages when you have actionable content \u2014 avoid broadcasting that you are waiting or idle.`;
 }
@@ -4154,7 +4458,7 @@ function buildPrompt(config, opts) {
     ...opts.extraCriticalRules,
     "- Use only the provided `raft` CLI commands for messaging.",
     "- Do not combine multiple `raft` CLI commands in one shell command. Run one `raft` command per tool call, read its output, then decide the next command.",
-    "- Always claim a task via `raft task claim` before starting work on it. If the claim fails, move on to a different task."
+    "- Always claim a task via `raft task claim` before starting work on it. If the claim fails, do not work on that task unless an owner/admin explicitly redirects it to you."
   ];
   const runtimeProfileControl = config.runtimeProfileControl?.kind === "daemon_release_notice" ? config.runtimeProfileControl : null;
   const runtimeProfileControlStartupStep = runtimeProfileControl ? [
@@ -4177,7 +4481,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 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.`;
+If a built-in Slock app or registered third-party service requires login, use Slock Agent Login through the CLI instead of asking the human to copy tokens or complete human OAuth for you. If a human asks you to sign into, open, use, or fetch identity from a third-party app or built-in Slock app, first run \`raft integration list\` and match the app to a listed service before browsing the app. Use \`raft integration login --service <service>\` to provision or reuse your agent login for that service. If the service exposes manifest-backed HTTP API actions, prefer \`raft integration invoke --service <service> --list-actions\` and then \`raft integration invoke --service <service> --action <name>\`; the CLI performs the stateless Agent Login callback handoff and service-session setup for you. If the service exposes an agent behavior manifest and you need to run its local CLI, run \`raft integration env --service <service>\` before invoking that CLI; if it prints exports, apply them first so service credentials stay under a per-agent profile HOME/XDG tree instead of the host user's global HOME. If it reports that no local env is required, do not invent HOME/XDG overrides; for HTTP API action services, use \`raft integration invoke\` instead. If it fails, do not run that local CLI with the host user's HOME; report that the service manifest is unsupported. Slock does not execute local commands from remote manifests automatically. If the CLI reports that the \`integration\` command is unknown, the local daemon/CLI is too old for Slock Agent Login; report that the machine must be upgraded/restarted instead of calling internal HTTP endpoints yourself. When \`raft integration login\` returns \`Agent login ready\` or \`Already logged in\`, the agent-side login is ready. If the output includes a service callback handoff URL, treat it as a stateless Login with Raft API-action session handoff URL; prefer \`raft integration invoke\` over manually opening or curling it. Do not crawl third-party routes looking for a session before trying the registered-service login path. Do not open the human \`Login with Slock\` browser flow, use internal request IDs as OAuth callback codes outside the documented CLI flow, call internal Slock integration endpoints directly, or call third-party exchange endpoints unless a human explicitly asks you to debug that server-to-server protocol. If the service or human asks for your Slock Agent identity card, use \`raft profile show\`. Third-party pages may show \`Login with Slock\`; for agent-facing access, prefer the listed service / Slock Agent Login path.`;
   const readingHistorySection = cliGuideSections.readingHistory;
   const historicalReferenceSection = cliGuideSections.historicalReferences;
   const tasksSection = cliGuideSections.tasks;
@@ -6525,14 +6829,15 @@ var ClaudeEventNormalizer = class {
         const stopReason = typeof event.stop_reason === "string" ? event.stop_reason : null;
         const resultSessionId = eventSessionId ?? this.currentSession;
         const usageTelemetry = parseClaudeResultUsageTelemetry(event, resultSessionId);
+        const isMaxTokenError = stopReason === "max_tokens" && (event.is_error === true || subtype !== "success");
         switch (subtype) {
           case "success":
-            if (event.is_error && stopReason !== "max_tokens") {
+            if (event.is_error) {
               pushResultError(event, "Execution failed");
             }
             break;
           case "error_during_execution":
-            if (stopReason !== "max_tokens") {
+            if (stopReason !== "max_tokens" || isMaxTokenError) {
               pushResultError(event, "Execution failed");
             }
             break;
@@ -11520,6 +11825,9 @@ var AgentStartPendingDeliveryBuffer = class {
   get size() {
     return this.pending.size;
   }
+  agentIds() {
+    return [...this.pending.keys()];
+  }
   values(agentId) {
     return [...this.pending.get(agentId) ?? []];
   }
@@ -11606,6 +11914,230 @@ var AgentStartPendingDeliveryBuffer = class {
   }
 };
 
+// src/agentNoProcessResidency.ts
+import { randomUUID as randomUUID5 } from "crypto";
+var AgentNoProcessResidencyTransitions = class {
+  open = /* @__PURE__ */ new Map();
+  transitionSeq = 0;
+  enter(input) {
+    const existing = this.open.get(input.agentId);
+    if (existing && existing.state === input.state && existing.agentLaunchId === input.agentLaunchId) {
+      return [];
+    }
+    const rows = [];
+    if (existing) {
+      rows.push(this.closeRow(existing, { closeResult: "advanced" }));
+    }
+    const current = {
+      agentId: input.agentId,
+      agentLaunchId: input.agentLaunchId,
+      agentLaunchIdPresent: input.agentLaunchIdPresent,
+      serverId: input.serverId,
+      machineId: input.machineId,
+      runtime: input.runtime,
+      driver: input.driver,
+      launchSource: input.launchSource,
+      state: input.state,
+      stateInstanceId: randomUUID5(),
+      isWaitState: input.isWaitState,
+      fenceKind: input.fenceKind,
+      deadlineUnixMs: typeof input.deadlineUnixMs === "number" ? input.deadlineUnixMs : void 0,
+      failureKind: input.failureKind,
+      negativeEvidenceBucket: input.negativeEvidenceBucket
+    };
+    this.open.set(input.agentId, current);
+    rows.push(this.enterRow(current));
+    return rows;
+  }
+  close(agentId, input) {
+    const existing = this.open.get(agentId);
+    if (!existing) return [];
+    this.open.delete(agentId);
+    return [this.closeRow(existing, input)];
+  }
+  enterRow(open2) {
+    return this.baseRow(open2, {
+      transition_kind: "enter",
+      phase_result: "entered",
+      is_wait_state: open2.isWaitState,
+      fence_kind: open2.fenceKind,
+      deadline_unix_ms: open2.deadlineUnixMs,
+      failure_kind: open2.failureKind,
+      negative_evidence_bucket: open2.negativeEvidenceBucket
+    });
+  }
+  closeRow(open2, input) {
+    return this.baseRow(open2, {
+      transition_kind: "close",
+      close_result: input.closeResult,
+      is_wait_state: open2.isWaitState,
+      fence_kind: open2.fenceKind,
+      deadline_unix_ms: open2.deadlineUnixMs,
+      failure_kind: input.failureKind ?? open2.failureKind,
+      negative_evidence_bucket: input.negativeEvidenceBucket ?? open2.negativeEvidenceBucket
+    });
+  }
+  baseRow(open2, attrs) {
+    const transitionSeq = ++this.transitionSeq;
+    const row = {
+      span_name: "launch_residency_transition",
+      phase: "process_residency",
+      agent_launch_id: open2.agentLaunchId,
+      agent_id: open2.agentId,
+      server_id: open2.serverId,
+      machine_id: open2.machineId,
+      runtime: open2.runtime,
+      driver: open2.driver,
+      launch_source: open2.launchSource,
+      state_instance_id: open2.stateInstanceId,
+      residency_state_instance_id: open2.stateInstanceId,
+      transition_seq: transitionSeq,
+      residency_transition_seq: transitionSeq,
+      transition_kind: attrs.transition_kind,
+      state: open2.state,
+      residency: open2.state,
+      agent_launch_id_present: open2.agentLaunchIdPresent
+    };
+    return withoutUndefined({
+      ...row,
+      phase_result: attrs.phase_result,
+      close_result: attrs.close_result,
+      is_wait_state: attrs.is_wait_state,
+      fence_kind: attrs.fence_kind,
+      deadline_unix_ms: attrs.deadline_unix_ms,
+      failure_kind: attrs.failure_kind,
+      negative_evidence_bucket: attrs.negative_evidence_bucket
+    });
+  }
+};
+function withoutUndefined(input) {
+  return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== void 0));
+}
+var AgentNoProcessResidency = class {
+  static assertInvariants(context, snapshot) {
+    const running = new Set(snapshot.runningAgentIds);
+    const idle = new Set(snapshot.idleAgentIds);
+    const terminal = new Set(snapshot.terminalFailureAgentIds);
+    const activeCooldown = new Set(snapshot.activeCooldownAgentIds);
+    const queued = new Set(snapshot.queuedAgentIds);
+    const starting = new Set(snapshot.startingAgentIds);
+    for (const agentId of activeCooldown) {
+      if (!idle.has(agentId)) {
+        throw new Error(`Agent no-process residency invariant violation after ${context}: active cooldown without restart config for ${agentId}`);
+      }
+    }
+    for (const agentId of terminal) {
+      if (idle.has(agentId)) {
+        throw new Error(`Agent no-process residency invariant violation after ${context}: terminal failure and idle restart config both present for ${agentId}`);
+      }
+      if (running.has(agentId)) {
+        throw new Error(`Agent no-process residency invariant violation after ${context}: terminal failure while process is still registered for ${agentId}`);
+      }
+    }
+    const allowedPending = this.allowedStartPendingSnapshot(snapshot);
+    const allowed = /* @__PURE__ */ new Set([
+      ...allowedPending.queuedAgentIds,
+      ...allowedPending.startingAgentIds,
+      ...allowedPending.terminalRecoveryAgentIds,
+      ...allowedPending.cooldownAgentIds
+    ]);
+    for (const agentId of snapshot.pendingDeliveryAgentIds) {
+      if (!allowed.has(agentId)) {
+        throw new Error(`Agent no-process residency invariant violation after ${context}: pending delivery without queued/starting/terminal/cooldown residency for ${agentId}`);
+      }
+    }
+    for (const agentId of snapshot.fingerprintFenceAgentIds) {
+      if (!running.has(agentId) && !idle.has(agentId) && !terminal.has(agentId)) {
+        throw new Error(`Agent no-process residency invariant violation after ${context}: fingerprint fence without running process, idle retry config, or terminal failure for ${agentId}`);
+      }
+    }
+    for (const agentId of queued) {
+      if (starting.has(agentId)) {
+        throw new Error(`Agent no-process residency invariant violation after ${context}: queued and starting facts overlap for ${agentId}`);
+      }
+    }
+  }
+  static allowedStartPendingSnapshot(snapshot) {
+    const idle = new Set(snapshot.idleAgentIds);
+    const cooldownAgentIds = snapshot.activeCooldownAgentIds.filter((agentId) => idle.has(agentId));
+    return {
+      queuedAgentIds: [...snapshot.queuedAgentIds],
+      startingAgentIds: [...snapshot.startingAgentIds],
+      terminalRecoveryAgentIds: [...snapshot.terminalFailureAgentIds],
+      cooldownAgentIds
+    };
+  }
+};
+
+// src/launchPhaseTransition.ts
+var LAUNCH_RUNTIME_READINESS_TRANSITION_SPAN = "launch_runtime_readiness_transition";
+function launchReadinessNegativeEvidence(identity) {
+  return identity.agent_launch_id ? null : "missing_launch_id";
+}
+function buildLaunchReadinessEnterAttrs(state) {
+  return {
+    ...state.identity,
+    phase: "runtime_readiness",
+    span_name: LAUNCH_RUNTIME_READINESS_TRANSITION_SPAN,
+    transition_kind: "enter",
+    phase_result: "entered",
+    state: "awaiting_runtime_ready",
+    state_instance_id: state.stateInstanceId,
+    transition_seq: state.enterSeq,
+    is_wait_state: true,
+    fence_kind: state.fenceKind,
+    deadline_unix_ms: state.deadlineUnixMs ?? void 0,
+    negative_evidence_bucket: state.negativeEvidenceBucket ?? void 0
+  };
+}
+function buildLaunchReadinessCloseAttrs(state, closeResult, closeSeq) {
+  return {
+    ...state.identity,
+    phase: "runtime_readiness",
+    span_name: LAUNCH_RUNTIME_READINESS_TRANSITION_SPAN,
+    transition_kind: "close",
+    state: "awaiting_runtime_ready",
+    state_instance_id: state.stateInstanceId,
+    transition_seq: closeSeq,
+    close_result: closeResult,
+    negative_evidence_bucket: state.negativeEvidenceBucket ?? void 0
+  };
+}
+var LAUNCH_ACTIVATION_DELIVERY_TRANSITION_SPAN = "launch_activation_delivery_transition";
+function buildLaunchActivationEnterAttrs(state) {
+  return {
+    ...state.identity,
+    phase: "activation_delivery",
+    span_name: LAUNCH_ACTIVATION_DELIVERY_TRANSITION_SPAN,
+    transition_kind: "enter",
+    phase_result: "entered",
+    state: "awaiting_activation_delivery",
+    state_instance_id: state.stateInstanceId,
+    transition_seq: state.enterSeq,
+    // Activation delivery has no independent fence yet — the launch's phase-5
+    // readiness wait (fenced by the startup timeout) is the upstream deadline.
+    // A stuck activation (session never ready-for-delivery) surfaces as an open
+    // row, not a fenced one.
+    is_wait_state: true,
+    fence_kind: "none",
+    negative_evidence_bucket: state.negativeEvidenceBucket ?? void 0
+  };
+}
+function buildLaunchActivationCloseAttrs(state, closeResult, closeSeq, deliveredVia) {
+  return {
+    ...state.identity,
+    phase: "activation_delivery",
+    span_name: LAUNCH_ACTIVATION_DELIVERY_TRANSITION_SPAN,
+    transition_kind: "close",
+    state: "awaiting_activation_delivery",
+    state_instance_id: state.stateInstanceId,
+    transition_seq: closeSeq,
+    close_result: closeResult,
+    delivered_via: deliveredVia ?? void 0,
+    negative_evidence_bucket: state.negativeEvidenceBucket ?? void 0
+  };
+}
+
 // src/agentVisibleDeliveryLedger.ts
 function getMessageShortId(messageId2) {
   return messageId2.startsWith("thread-") ? messageId2.slice(7) : messageId2.slice(0, 8);
@@ -12954,7 +13486,9 @@ Do not copy these answers verbatim.
 
 ## FAQ 15: How do I create agents or channels?
 ### Answer idea
-- When the owner agrees to a new agent or channel, **post an action card** with \`raft action prepare\`. The card lives inline in chat; the owner clicks the action button, the matching create dialog opens prefilled with your values (editable), and the resource is created under their identity when they submit.
+- If you have \`channel:create\` scope and your server role has channel-management authority, create channels directly with \`raft channel create --name <name>\` (add \`--private\` for private channels). This creates the channel under your agent identity and joins you to it.
+- If you also have the matching channel-management scopes and authority, edit regular channels with \`raft channel update --target "#channel-name" --name "#new-name"\`, add humans or agents with \`raft channel add-member --target "#channel-name" --user @alice\` or \`--agent @scout\`, and remove them with \`raft channel remove-member --target "#channel-name" --user @alice\` or \`--agent @scout\`. Adding members is the direct follow-up for private channels you create under your agent identity.
+- When a human should review/commit the action, or when creating a new agent, **post an action card** with \`raft action prepare\`. The card lives inline in chat; the owner clicks the action button, the matching create dialog opens prefilled with your values (editable), and the resource is created under their identity when they submit.
 - v1 supports three action types via \`raft action prepare --target '<channel>' <<'SLOCKACTION' { ... } SLOCKACTION\`:
   - \`{type: "channel:create", name, visibility: "public" | "private", description?, initialHumans?: ["@alice"], initialAgents?: ["@scout"], draftHint?}\`
   - \`{type: "agent:create", name, description?, suggestedComputer?, requiredComputer?, draftHint?}\` \u2014 runtime / model / reasoning effort are the owner's call. Use \`requiredComputer\` only when the owner explicitly says the new agent must run on that computer; use \`suggestedComputer\` for a soft preference.
@@ -12964,12 +13498,12 @@ Do not copy these answers verbatim.
 - Manual fallback (only when the owner explicitly wants to do it themselves or asks how to repeat it): the + buttons in the Agents and Channels sidebar sections. Lead with the action card; mention the + button only on request.
 
 ### Next step
-- Prefill the values you have, post the action card with a short \`draftHint\` explaining why these values, and tell the owner: "click the button on the card to review and commit." Then propose the first task to send once the card flips to Done.
+- For direct channel creation, name the channel, create it, add needed members if requested/appropriate, then post the first useful update there. For human-committed actions, prefill the values you have, post the action card with a short \`draftHint\` explaining why these values, and tell the owner: "click the button on the card to review and commit." Then propose the first task to send once the card flips to Done.
 
 ### Guardrail
-- Do not imply you already created agents or channels unless the card state is \`executed\`.
+- Do not imply you created or edited a channel unless the corresponding \`raft channel create\` / \`raft channel update\` command succeeded. Do not imply you added or removed a channel member unless the corresponding member command succeeded. Do not imply you created an agent or a human-committed channel unless the card state is \`executed\`.
 - Do not prefill runtime / model / reasoning effort on \`agent:create\`. Computer placement is only allowed as the structured \`suggestedComputer\` / \`requiredComputer\` field when the owner's request includes that placement; never rely on \`draftHint\` for a computer constraint.
-- If the action type the user wants is not yet supported (e.g. \`channel:add_member\`), say so plainly and offer the manual UI path; do not invent action types the schema does not accept.
+- If the action type or direct CLI command the user wants is not yet supported, say so plainly and offer the manual UI path; do not invent action types the schema does not accept.
 `;
 }
 function buildOnboardingSeedFiles() {
@@ -13538,7 +14072,10 @@ var AgentProcessManager = class _AgentProcessManager {
   }
   agentStarts;
   startingInboxes = new AgentStartPendingDeliveryBuffer();
+  /** Monotonic ordering counter for launch phase-5/6 exported rows (audit only, not a pairing key). */
+  launchTransitionSeq = 0;
   terminalRuntimeFailures = /* @__PURE__ */ new Map();
+  noProcessResidencyTransitions = new AgentNoProcessResidencyTransitions();
   runtimeErrorFingerprintFences = /* @__PURE__ */ new Map();
   pendingStartRebinds = /* @__PURE__ */ new Map();
   /** Cached configs for agents whose process exited normally — enables auto-restart on next message */
@@ -13618,13 +14155,26 @@ var AgentProcessManager = class _AgentProcessManager {
     this.cliTransportTraceDir = traceDir;
   }
   assertStartPendingDeliveryInvariants(context) {
+    const residencySnapshot = this.noProcessResidencySnapshot();
+    AgentNoProcessResidency.assertInvariants(context, residencySnapshot);
+    this.startingInboxes.assertInvariants(
+      context,
+      AgentNoProcessResidency.allowedStartPendingSnapshot(residencySnapshot)
+    );
+  }
+  noProcessResidencySnapshot() {
     const startSnapshot = this.agentStarts.snapshot();
-    this.startingInboxes.assertInvariants(context, {
+    const now = this.clockNow();
+    return {
+      runningAgentIds: [...this.agents.keys()],
       queuedAgentIds: startSnapshot.queuedAgentIds,
       startingAgentIds: startSnapshot.startingAgentIds,
-      terminalRecoveryAgentIds: [...this.terminalRuntimeFailures.keys()],
-      cooldownAgentIds: [...this.agentSpawnFailBackoff.keys()]
-    });
+      idleAgentIds: [...this.idleAgentConfigs.keys()],
+      terminalFailureAgentIds: [...this.terminalRuntimeFailures.keys()],
+      activeCooldownAgentIds: [...this.agentSpawnFailBackoff.entries()].filter(([, state]) => state.untilMs > now).map(([agentId]) => agentId),
+      fingerprintFenceAgentIds: [...this.runtimeErrorFingerprintFences.keys()],
+      pendingDeliveryAgentIds: this.startingInboxes.agentIds()
+    };
   }
   getVisibleBoundary(agentId, target) {
     return this.agentVisibleDelivery.getBoundary(agentId, target);
@@ -13682,15 +14232,17 @@ var AgentProcessManager = class _AgentProcessManager {
       if (s) {
         s.timer = null;
         s.untilMs = 0;
+        this.closeNoProcessResidency(agentId, "timeout", { negativeEvidenceBucket: "spawn_fail_cooldown_expired" });
       }
     }, Math.max(1, state.untilMs - this.clockNow()));
     return { backoffActive: true, attempts: state.attempts, untilMs: state.untilMs };
   }
-  resetSpawnFailBackoff(agentId) {
+  resetSpawnFailBackoff(agentId, closeResult = "advanced") {
     const state = this.agentSpawnFailBackoff.get(agentId);
     if (!state) return;
     if (state.timer) clearTimeout(state.timer);
     this.agentSpawnFailBackoff.delete(agentId);
+    this.closeNoProcessResidency(agentId, closeResult, { negativeEvidenceBucket: "spawn_fail_cooldown_reset" });
   }
   // ----- RUNTIME-ERROR FINGERPRINT FENCE (per-agent) ---------------------
   // The delivery backoff above is scoped to AgentProcess and is cleared when a
@@ -14223,19 +14775,19 @@ var AgentProcessManager = class _AgentProcessManager {
     if (input.decision !== "local_hold" && input.decision !== "syncing_hold") return;
     const ap = this.agents.get(agentId);
     const messageCount = input.decision === "syncing_hold" ? input.heldMessageCount ?? input.pendingCount ?? 0 : input.pendingCount ?? input.heldMessageCount ?? 0;
-    const entry = projectApmHeldFreshnessActivity({
+    const activity = projectApmHeldFreshnessActivity({
       producerFactId,
       action: input.action,
       decision: input.decision,
       target: input.target,
       messageCount
-    }).entry;
+    });
     this.sendToServer({
       type: "agent:activity",
       agentId,
-      activity: ap?.lastActivity || "online",
-      detail: ap?.lastActivityDetail || "",
-      entries: [entry],
+      activity: activity.statusEntry.activity,
+      detail: activity.statusEntry.detail,
+      entries: activity.entries,
       launchId: ap?.launchId || void 0,
       clientSeq: ap ? this.nextActivityClientSeq(agentId) : void 0
     });
@@ -14283,6 +14835,64 @@ var AgentProcessManager = class _AgentProcessManager {
     });
     span.end(status);
   }
+  emitNoProcessResidencyRows(rows) {
+    for (const row of rows) {
+      this.recordDaemonTrace("launch_residency_transition", row);
+    }
+  }
+  noProcessResidencyIdentity(agentId, config, launchId, launchSource, driverId) {
+    const runtimeContext = config.runtimeContext;
+    const agentLaunchIdPresent = typeof launchId === "string" && launchId.length > 0;
+    return {
+      agentId,
+      agentLaunchId: agentLaunchIdPresent ? launchId : "missing_launch_id",
+      agentLaunchIdPresent,
+      serverId: runtimeContext?.serverId || "unknown_server",
+      machineId: runtimeContext?.machineId || "unknown_machine",
+      runtime: config.runtime || "unknown_runtime",
+      driver: driverId || this.driverResolver(config.runtime || "claude").id,
+      launchSource
+    };
+  }
+  enterNoProcessResidency(state, identity, opts) {
+    const launchEvidence = identity.agentLaunchIdPresent ? {} : {
+      failureKind: opts.failureKind ?? "missing_launch_id",
+      negativeEvidenceBucket: opts.negativeEvidenceBucket ?? "missing_launch_id"
+    };
+    this.emitNoProcessResidencyRows(this.noProcessResidencyTransitions.enter({
+      ...identity,
+      state,
+      ...opts,
+      ...launchEvidence
+    }));
+  }
+  closeNoProcessResidency(agentId, closeResult, opts = {}) {
+    this.emitNoProcessResidencyRows(this.noProcessResidencyTransitions.close(agentId, {
+      closeResult,
+      failureKind: opts.failureKind,
+      negativeEvidenceBucket: opts.negativeEvidenceBucket
+    }));
+  }
+  startLaunchSource(config, wakeMessage, resumePrompt) {
+    if (config.runtimeProfileControl && !wakeMessage) return "runtime_profile";
+    if (config.sessionId || resumePrompt) return "session_resume";
+    if (wakeMessage) return "wake_message";
+    return "explicit_start";
+  }
+  enterSpawnFailCooldownResidency(agentId, cached, untilMs, source, reason) {
+    if (untilMs <= this.clockNow()) return;
+    this.enterNoProcessResidency(
+      "spawn_fail_cooldown",
+      this.noProcessResidencyIdentity(agentId, cached.config, cached.launchId, source),
+      {
+        isWaitState: true,
+        fenceKind: "spawn_fail_backoff",
+        deadlineUnixMs: untilMs,
+        failureKind: reason,
+        negativeEvidenceBucket: reason
+      }
+    );
+  }
   processLifecycleIdentityAttrs(agentId, ap) {
     const runtimeContext = ap.config.runtimeContext;
     return {
@@ -14510,6 +15120,15 @@ var AgentProcessManager = class _AgentProcessManager {
       this.agentStarts.enqueue(item);
       this.recordDaemonTrace("daemon.agent.start.queued", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
       const startSnapshot = this.agentStarts.snapshot();
+      this.enterNoProcessResidency(
+        "queued_start",
+        this.noProcessResidencyIdentity(agentId, config, launchId, this.startLaunchSource(config, wakeMessage, resumePrompt)),
+        {
+          isWaitState: true,
+          fenceKind: "start_scheduler",
+          deadlineUnixMs: this.clockNow() + Math.max(1, startSnapshot.minStartIntervalMs)
+        }
+      );
       logger.info(
         `[Agent ${agentId}] Start queued (queue=${startSnapshot.queueDepth}, active=${startSnapshot.activeStarts}, max=${startSnapshot.maxConcurrentStarts}, interval=${startSnapshot.minStartIntervalMs}ms)`
       );
@@ -14532,6 +15151,7 @@ var AgentProcessManager = class _AgentProcessManager {
     if (dequeued.kind === "empty") return;
     if (dequeued.kind === "stale") {
       const { item: item2 } = dequeued;
+      this.closeNoProcessResidency(item2.agentId, "suppressed", { negativeEvidenceBucket: "stale_queue_item" });
       this.recordDaemonTrace("daemon.agent.start.skipped", {
         ...this.startQueueTraceAttrs(item2.agentId, item2.config, item2.wakeMessage, item2.unreadSummary, item2.resumePrompt, item2.launchId, item2.wakeMessageTransient),
         reason: "stale_queue_item"
@@ -14541,6 +15161,7 @@ var AgentProcessManager = class _AgentProcessManager {
     }
     const { item } = dequeued;
     if (this.agents.has(item.agentId) || this.agentStarts.hasStarting(item.agentId)) {
+      this.closeNoProcessResidency(item.agentId, "suppressed", { negativeEvidenceBucket: "already_running_or_starting" });
       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"
@@ -14556,6 +15177,15 @@ var AgentProcessManager = class _AgentProcessManager {
       return;
     }
     this.agentStarts.claimStartSlot(item.agentId);
+    this.enterNoProcessResidency(
+      "starting_process",
+      this.noProcessResidencyIdentity(item.agentId, item.config, item.launchId, this.startLaunchSource(item.config, item.wakeMessage, item.resumePrompt)),
+      {
+        isWaitState: true,
+        fenceKind: "runtime_start_timeout",
+        deadlineUnixMs: this.clockNow() + runtimeStartTimeoutMs()
+      }
+    );
     const startSnapshot = this.agentStarts.snapshot();
     logger.info(
       `[Agent ${item.agentId}] Dequeued start (remaining=${startSnapshot.queueDepth}, active=${startSnapshot.activeStarts})`
@@ -14595,6 +15225,7 @@ var AgentProcessManager = class _AgentProcessManager {
   cancelQueuedAgentStart(agentId, reason) {
     const item = this.agentStarts.cancelQueued(agentId);
     if (!item) return false;
+    this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "start_cancelled" });
     this.startingInboxes.cancelStart(agentId);
     this.assertStartPendingDeliveryInvariants("cancel-queued-start");
     this.recordDaemonTrace("daemon.agent.start.cancelled", {
@@ -14607,6 +15238,7 @@ var AgentProcessManager = class _AgentProcessManager {
   }
   cancelAllQueuedAgentStarts(reason) {
     const cancelled = this.agentStarts.cancelAllQueued((item) => {
+      this.closeNoProcessResidency(item.agentId, "suppressed", { negativeEvidenceBucket: "start_cancelled" });
       this.recordDaemonTrace("daemon.agent.start.cancelled", {
         ...this.startQueueTraceAttrs(item.agentId, item.config, item.wakeMessage, item.unreadSummary, item.resumePrompt, item.launchId, item.wakeMessageTransient),
         reason
@@ -14687,6 +15319,15 @@ var AgentProcessManager = class _AgentProcessManager {
           wakeMessageTransient = pendingStartRebind.wakeMessageTransient === true;
         }
       }
+      this.enterNoProcessResidency(
+        "starting_process",
+        this.noProcessResidencyIdentity(agentId, config, launchId, this.startLaunchSource(config, wakeMessage, resumePrompt)),
+        {
+          isWaitState: true,
+          fenceKind: "runtime_start_timeout",
+          deadlineUnixMs: this.clockNow() + runtimeStartTimeoutMs()
+        }
+      );
       this.recordDaemonTrace("daemon.agent.spawn.started", this.startQueueTraceAttrs(agentId, config, wakeMessage, unreadSummary, resumePrompt, launchId, wakeMessageTransient));
       const driver = this.driverResolver(config.runtime || "claude");
       const legacyWakeRuntimeProfile = wakeMessage ? runtimeProfileNotificationFromMessage(wakeMessage) : null;
@@ -14795,6 +15436,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       if (canDeferEmptyStart) {
         const pendingMessages = this.startingInboxes.drainOnSpawn(agentId);
         this.agentStarts.clearStarting(agentId);
+        this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "defer_until_concrete_message" });
         this.assertStartPendingDeliveryInvariants("defer-empty-start-drain");
         this.idleAgentConfigs.set(agentId, {
           config: this.buildRestartSafeConfig(runtimeConfig, runtimeConfig.sessionId || null),
@@ -14838,7 +15480,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       };
       const initialSessionId = this.initialAgentProcessSessionId(driver, liveProcessConfig);
       const restartSessionId = initialSessionId || (driver.requiresSessionInitForDelivery ? liveProcessConfig.sessionId || null : null);
-      const processInstanceId = randomUUID5();
+      const processInstanceId = randomUUID6();
       agentProcess = {
         runtime,
         driver,
@@ -14854,6 +15496,9 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         activityHeartbeat: null,
         startupTimeoutTimer: null,
         startupReadinessSatisfied: false,
+        readinessTransition: null,
+        activationTransition: null,
+        initialActivationDelivered: false,
         compactionWatchdog: null,
         compactionStartedAt: null,
         runtimeProgress: new RuntimeProgressState(Date.now()),
@@ -14879,7 +15524,6 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         gatedSteering: createGatedSteeringState()
       };
       this.startingInboxes.drainOnSpawn(agentId);
-      this.assertStartPendingDeliveryInvariants("spawn-drain");
       this.agents.set(agentId, agentProcess);
       this.idleAgentConfigs.set(agentId, {
         config: this.buildRestartSafeConfig(runtimeConfig, restartSessionId),
@@ -15004,6 +15648,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           if (ap.activityHeartbeat) {
             clearInterval(ap.activityHeartbeat);
           }
+          this.closeRuntimeReadinessTransition(ap, "terminal");
+          this.closeActivationTransition(ap, "terminal");
           this.clearRuntimeStartupTimeout(ap);
           this.clearStalledRecoverySigtermWatchdog(ap);
           const finalCode = ap.exitCode ?? code;
@@ -15096,6 +15742,24 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
               this.startAgent(agentId, nextConfig, queuedWakeMessage, unreadSummary2, void 0, ap.launchId || void 0).catch((err) => {
                 logger.error(`[Agent ${agentId}] Failed to continue with queued message`, err);
                 if (this.reportRunnerCredentialMintFailure(agentId, err, ap.launchId, "queued_continuation")) {
+                  this.idleAgentConfigs.set(agentId, {
+                    config: nextConfig,
+                    sessionId: ap.sessionId,
+                    launchId: ap.launchId
+                  });
+                  const report = this.recordSpawnFailure(agentId, "runner_credential_mint");
+                  this.assertStartPendingDeliveryInvariants("queued-continuation-runner-credential-mint-failure");
+                  if (report.backoffActive) {
+                    this.enterSpawnFailCooldownResidency(agentId, { config: nextConfig, launchId: ap.launchId }, report.untilMs, "queued_continuation", "runner_credential_mint");
+                  }
+                  this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
+                    agentId,
+                    source: "queued_continuation",
+                    reason: "runner_credential_mint",
+                    attempts: report.attempts,
+                    cooldown_active: report.backoffActive,
+                    until_ms: report.untilMs
+                  });
                   return;
                 }
                 this.idleAgentConfigs.set(agentId, {
@@ -15170,7 +15834,11 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         }, "error");
         throw new Error(`Runtime session failed to start: ${startResult.reason}${startResult.error ? ` (${startResult.error})` : ""}`);
       }
-      this.terminalRuntimeFailures.delete(agentId);
+      this.closeNoProcessResidency(agentId, "advanced");
+      if (this.terminalRuntimeFailures.delete(agentId)) {
+        this.closeNoProcessResidency(agentId, "advanced", { negativeEvidenceBucket: "terminal_recovery_start_succeeded" });
+      }
+      this.assertStartPendingDeliveryInvariants("spawn-drain");
       this.recordDaemonTrace("daemon.agent.spawn.created", {
         ...this.startQueueTraceAttrs(agentId, effectiveConfig, wakeMessage, unreadSummary, resumePrompt, agentProcess.launchId || void 0, wakeMessageTransient),
         detached: false,
@@ -15192,9 +15860,16 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         this.sendToServer({ type: "agent:session", agentId, sessionId: agentProcess.sessionId, launchId: agentProcess.launchId || void 0 });
       }
       this.broadcastActivity(agentId, "working", "Starting\u2026");
-      this.startRuntimeStartupTimeout(agentId, agentProcess);
+      this.startRuntimeStartupTimeout(agentId, agentProcess, startCause);
+      if (wakeMessage || startingInboxMessages.length > 0) {
+        this.openActivationTransition(agentId, agentProcess, startCause);
+        if (wakeMessageDeliveredAsInboxUpdate || startingInboxDeliveredAsInput) {
+          this.closeActivationTransition(agentProcess, "advanced", "spawn_prompt");
+        }
+      }
     } catch (err) {
       this.agentStarts.clearStarting(agentId);
+      this.closeNoProcessResidency(agentId, "terminal", { negativeEvidenceBucket: "runtime_start_failed" });
       this.pendingStartRebinds.delete(agentId);
       this.cleanupFailedRuntimeStart(agentId, agentProcess, err);
       throw err;
@@ -15216,6 +15891,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       clearTimeout(ap.compactionWatchdog);
       ap.compactionWatchdog = null;
     }
+    this.closeRuntimeReadinessTransition(ap, "terminal");
+    this.closeActivationTransition(ap, "terminal");
     this.clearRuntimeStartupTimeout(ap);
     this.clearStalledRecoverySigtermWatchdog(ap);
     this.endRuntimeTrace(ap, "error", {
@@ -15228,7 +15905,9 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     this.revokeManagedRunnerCredential(agentId, ap.config, ap.launchId);
     this.agents.delete(agentId);
     this.idleAgentConfigs.delete(agentId);
-    this.terminalRuntimeFailures.delete(agentId);
+    if (this.terminalRuntimeFailures.delete(agentId)) {
+      this.closeNoProcessResidency(agentId, "terminal", { negativeEvidenceBucket: "runtime_start_failed" });
+    }
   }
   cleanupTerminalRuntimeFailure(agentId, ap, detail) {
     if (this.agents.get(agentId) !== ap) return;
@@ -15243,6 +15922,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       ap.activityHeartbeat = null;
     }
     this.clearCompactionWatchdog(ap);
+    this.closeRuntimeReadinessTransition(ap, "terminal");
+    this.closeActivationTransition(ap, "terminal");
     this.clearRuntimeStartupTimeout(ap);
     this.clearStalledRecoverySigtermWatchdog(ap);
     cleanupAgentCredentialProxy(agentId, ap.launchId);
@@ -15251,9 +15932,18 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     if (ap.inbox.length > 0) {
       this.startingInboxes.bufferMessagesDuringStart(agentId, ap.inbox);
     }
+    this.agents.delete(agentId);
     this.terminalRuntimeFailures.set(agentId, { detail, launchId: ap.launchId });
+    this.enterNoProcessResidency(
+      "terminal_runtime_error",
+      this.noProcessResidencyIdentity(agentId, ap.config, ap.launchId, "terminal_runtime_error", ap.driver.id),
+      {
+        isWaitState: false,
+        failureKind: "terminal_runtime_error",
+        negativeEvidenceBucket: "terminal_runtime_error"
+      }
+    );
     this.assertStartPendingDeliveryInvariants("terminal-runtime-failure-cleanup");
-    this.agents.delete(agentId);
     const diagnostics = buildRuntimeErrorDiagnosticEnvelope(detail);
     this.recordDaemonTrace("daemon.agent.terminal_runtime_error.cleanup", {
       agentId,
@@ -15517,7 +16207,9 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     this.cancelQueuedAgentStart(agentId, "stop requested");
     this.pendingStartRebinds.delete(agentId);
     this.idleAgentConfigs.delete(agentId);
-    this.terminalRuntimeFailures.delete(agentId);
+    if (this.terminalRuntimeFailures.delete(agentId)) {
+      this.closeNoProcessResidency(agentId, "suppressed", { negativeEvidenceBucket: "explicit_stop" });
+    }
     const ap = this.agents.get(agentId);
     if (!ap) {
       if (!silent) {
@@ -15538,7 +16230,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     if (!silent) {
       this.activityClientSeqByAgent.delete(agentId);
       this.agentVisibleDelivery.clearAgent(agentId);
-      this.resetSpawnFailBackoff(agentId);
+      this.resetSpawnFailBackoff(agentId, "suppressed");
       this.resetRuntimeErrorFingerprintFence(agentId, "explicit_stop", ap);
     }
     this.runtimeExitTraceAttrs.set(ap.runtime, {
@@ -15676,6 +16368,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           const state = this.agentSpawnFailBackoff.get(agentId);
           const startingInboxCount = this.startingInboxes.bufferDuringStart(agentId, message);
           this.assertStartPendingDeliveryInvariants("delivery-spawn-fail-cooldown");
+          this.enterSpawnFailCooldownResidency(agentId, cached, state.untilMs, "idle_auto_restart", "spawn_fail_cooldown_active");
           this.recordDaemonTrace("daemon.agent.delivery.routed", this.deliveryTraceAttrs(agentId, message, {
             outcome: "spawn_fail_cooldown_active",
             accepted: true,
@@ -15702,11 +16395,17 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         }));
         return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0, transientDelivery).then(() => {
           this.resetSpawnFailBackoff(agentId);
+          this.assertStartPendingDeliveryInvariants("idle-auto-restart-success");
           return true;
         }, (err) => {
           logger.error(`[Agent ${agentId}] Failed to auto-restart`, err);
           if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "idle_auto_restart")) {
+            this.idleAgentConfigs.set(agentId, cached);
             const report2 = this.recordSpawnFailure(agentId, "runner_credential_mint");
+            this.assertStartPendingDeliveryInvariants("idle-auto-restart-runner-credential-mint-failure");
+            if (report2.backoffActive) {
+              this.enterSpawnFailCooldownResidency(agentId, cached, report2.untilMs, "idle_auto_restart", "runner_credential_mint");
+            }
             this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
               agentId,
               source: "idle_auto_restart",
@@ -15719,6 +16418,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
           }
           this.idleAgentConfigs.set(agentId, cached);
           const report = this.recordSpawnFailure(agentId, "spawn_error");
+          this.assertStartPendingDeliveryInvariants("idle-auto-restart-spawn-failure");
+          if (report.backoffActive) {
+            this.enterSpawnFailCooldownResidency(agentId, cached, report.untilMs, "idle_auto_restart", "spawn_error");
+          }
           this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
             agentId,
             source: "idle_auto_restart",
@@ -16336,6 +17039,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       logger.info(`[Agent ${agentId}] Starting from idle state for runtime profile ${kind} ${key}`);
       if (this.isSpawnFailBackoffActive(agentId)) {
         const state = this.agentSpawnFailBackoff.get(agentId);
+        this.enterSpawnFailCooldownResidency(agentId, cached, state.untilMs, "runtime_profile_auto_restart", "spawn_fail_cooldown_active");
         span.end("ok", {
           attrs: {
             outcome: "spawn_fail_cooldown_active",
@@ -16350,11 +17054,17 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       this.idleAgentConfigs.delete(agentId);
       return this.startAgent(agentId, cached.config, message, void 0, void 0, cached.launchId || void 0).then(() => {
         this.resetSpawnFailBackoff(agentId);
+        this.assertStartPendingDeliveryInvariants("runtime-profile-auto-restart-success");
         return true;
       }, (err) => {
         logger.error(`[Agent ${agentId}] Failed to auto-restart for runtime profile notification`, err);
         if (this.reportRunnerCredentialMintFailure(agentId, err, cached.launchId, "runtime_profile_auto_restart")) {
+          this.idleAgentConfigs.set(agentId, cached);
           const report2 = this.recordSpawnFailure(agentId, "runner_credential_mint");
+          this.assertStartPendingDeliveryInvariants("runtime-profile-auto-restart-runner-credential-mint-failure");
+          if (report2.backoffActive) {
+            this.enterSpawnFailCooldownResidency(agentId, cached, report2.untilMs, "runtime_profile_auto_restart", "runner_credential_mint");
+          }
           this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
             agentId,
             source: "runtime_profile_auto_restart",
@@ -16374,6 +17084,10 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
         }
         this.idleAgentConfigs.set(agentId, cached);
         const report = this.recordSpawnFailure(agentId, "spawn_error");
+        this.assertStartPendingDeliveryInvariants("runtime-profile-auto-restart-spawn-failure");
+        if (report.backoffActive) {
+          this.enterSpawnFailCooldownResidency(agentId, cached, report.untilMs, "runtime_profile_auto_restart", "spawn_error");
+        }
         this.recordDaemonTrace("daemon.agent.spawn.fail_backoff", {
           agentId,
           source: "runtime_profile_auto_restart",
@@ -16677,7 +17391,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       const gzipped = gzipSync(raw);
       const bundleSha256 = createHash3("sha256").update(gzipped).digest("hex");
       const bundleSizeBytes = gzipped.byteLength;
-      const bundleId = randomUUID5();
+      const bundleId = randomUUID6();
       const uploadResult = await uploadWithSignedCapability({
         serverUrl: this.serverUrl,
         apiKey: this.daemonApiKey,
@@ -17458,9 +18172,100 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
     }
     return true;
   }
-  startRuntimeStartupTimeout(agentId, ap) {
+  launchIdentityAttrs(agentId, ap, launchSource) {
+    const runtimeContext = ap.config.runtimeContext;
+    return {
+      agent_launch_id: ap.launchId ?? null,
+      agent_id: agentId,
+      server_id: runtimeContext?.serverId ?? null,
+      machine_id: runtimeContext?.machineId ?? null,
+      runtime: ap.config.runtime,
+      driver: ap.driver.id,
+      launch_source: launchSource
+    };
+  }
+  /**
+   * Phase-5 exported-row ENTER: opens the runtime-readiness wait row (task
+   * #149). Idempotent — a second call while a row is open is a no-op so the
+   * (agent_launch_id, state_instance_id) pair keeps exactly-one enter.
+   */
+  openRuntimeReadinessTransition(agentId, ap, launchSource, fenceKind, deadlineUnixMs) {
+    if (ap.readinessTransition) return;
+    const identity = this.launchIdentityAttrs(agentId, ap, launchSource);
+    const state = {
+      stateInstanceId: randomUUID6(),
+      enterSeq: this.launchTransitionSeq++,
+      identity,
+      fenceKind,
+      deadlineUnixMs,
+      negativeEvidenceBucket: launchReadinessNegativeEvidence(identity)
+    };
+    ap.readinessTransition = state;
+    this.recordDaemonTrace(LAUNCH_RUNTIME_READINESS_TRANSITION_SPAN, buildLaunchReadinessEnterAttrs(state));
+  }
+  /**
+   * Phase-5 exported-row CLOSE: closes the open runtime-readiness wait row with
+   * a closed `close_result` (task #149). Idempotent — no-op when no row is open,
+   * so overlapping close paths (ready event, timeout fire, process exit,
+   * cleanup) emit exactly one close.
+   */
+  closeRuntimeReadinessTransition(ap, closeResult) {
+    const state = ap.readinessTransition;
+    if (!state) return;
+    ap.readinessTransition = null;
+    this.recordDaemonTrace(
+      LAUNCH_RUNTIME_READINESS_TRANSITION_SPAN,
+      buildLaunchReadinessCloseAttrs(state, closeResult, this.launchTransitionSeq++),
+      closeResult === "advanced" ? "ok" : "error"
+    );
+  }
+  /**
+   * Phase-6 exported-row ENTER: opens the activation-delivery wait row when a
+   * launch carries an initial activation (wake / buffered inbox) not yet
+   * delivered (task #149). Idempotent + only opens when there is something to
+   * deliver, so explicit starts with no activation produce no phase-6 row.
+   */
+  openActivationTransition(agentId, ap, launchSource) {
+    if (ap.activationTransition || ap.initialActivationDelivered) return;
+    const identity = this.launchIdentityAttrs(agentId, ap, launchSource);
+    const state = {
+      stateInstanceId: randomUUID6(),
+      enterSeq: this.launchTransitionSeq++,
+      identity,
+      negativeEvidenceBucket: launchReadinessNegativeEvidence(identity)
+    };
+    ap.activationTransition = state;
+    this.recordDaemonTrace(LAUNCH_ACTIVATION_DELIVERY_TRANSITION_SPAN, buildLaunchActivationEnterAttrs(state));
+  }
+  /**
+   * Phase-6 exported-row CLOSE: closes the open activation-delivery wait with a
+   * closed `close_result` (+ `delivered_via` on advanced). Idempotent — no-op
+   * when no row is open, so overlapping paths (spawn-prompt, first stdin,
+   * process exit, cleanup) emit exactly one close. Marks the initial activation
+   * delivered on `advanced` so later normal deliveries are not re-counted.
+   */
+  closeActivationTransition(ap, closeResult, deliveredVia) {
+    if (closeResult === "advanced") ap.initialActivationDelivered = true;
+    const state = ap.activationTransition;
+    if (!state) return;
+    ap.activationTransition = null;
+    this.recordDaemonTrace(
+      LAUNCH_ACTIVATION_DELIVERY_TRANSITION_SPAN,
+      buildLaunchActivationCloseAttrs(state, closeResult, this.launchTransitionSeq++, deliveredVia),
+      closeResult === "advanced" ? "ok" : "error"
+    );
+  }
+  startRuntimeStartupTimeout(agentId, ap, launchSource) {
     const timeoutMs = runtimeStartTimeoutMs();
-    if (timeoutMs <= 0) return;
+    const fenced = timeoutMs > 0;
+    this.openRuntimeReadinessTransition(
+      agentId,
+      ap,
+      launchSource,
+      fenced ? "runtime_startup_timeout" : "none",
+      fenced ? Date.now() + timeoutMs : null
+    );
+    if (!fenced) return;
     ap.startupTimeoutTimer = setTimeout(() => {
       this.handleRuntimeStartupTimeout(agentId, ap, timeoutMs);
     }, timeoutMs);
@@ -17487,6 +18292,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       this.clearRuntimeStartupTimeout(ap);
       return;
     }
+    this.closeRuntimeReadinessTransition(ap, "timeout");
     this.clearRuntimeStartupTimeout(ap);
     this.commitGatedSteeringDecisionState(agentId, ap, reduction.nextState);
     const terminalFailureDetail = classifyTerminalFailure(ap);
@@ -17524,6 +18330,8 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
   handleRuntimeStartupRequestError(agentId, ap, event) {
     const current = this.agents.get(agentId);
     if (current !== ap) return;
+    this.closeRuntimeReadinessTransition(ap, "terminal");
+    this.closeActivationTransition(ap, "terminal");
     this.clearRuntimeStartupTimeout(ap);
     this.interruptCompactionIfActive(agentId);
     this.interruptReviewIfActive(agentId);
@@ -17727,6 +18535,7 @@ Use \`raft message read\` to catch up on the channels listed above, then stop. R
       const wasStalled = ap.runtimeProgress.isStale;
       if (this.runtimeStartupReadinessSatisfiedByEvent(ap, event)) {
         ap.startupReadinessSatisfied = true;
+        this.closeRuntimeReadinessTransition(ap, "advanced");
         this.clearRuntimeStartupTimeout(ap);
       }
       this.noteRuntimeTraceCounter(ap, event);
@@ -18443,6 +19252,7 @@ ${formatAgentInboxDelta(inboxRows, { totalPendingMessages: inboxCount })}]`;
       cursors_advanced: "none"
     });
     ap.notifications.recordNoticeWritten(computeInboxNoticeFingerprint(messages), ap.sessionId, messages);
+    this.closeActivationTransition(ap, "advanced", "stdin");
     return true;
   }
   /** Deliver a message to an agent via stdin, formatting it the same way as the MCP bridge */
@@ -18548,6 +19358,7 @@ ${RESPONSE_TARGET_HINT}`);
       outcome: "written",
       stdin_write_attempted: true
     });
+    this.closeActivationTransition(ap, "advanced", "stdin");
     return true;
   }
   /** List ONE level of a directory — directories returned without children (lazy-loaded on demand) */
@@ -18964,7 +19775,7 @@ var ReminderCache = class {
 };
 
 // src/machineLock.ts
-import { createHash as createHash4, randomUUID as randomUUID6 } from "crypto";
+import { createHash as createHash4, randomUUID as randomUUID7 } from "crypto";
 import { mkdirSync as mkdirSync5, readFileSync as readFileSync7, rmSync as rmSync3, statSync as statSync2, writeFileSync as writeFileSync5 } from "fs";
 import os7 from "os";
 import path15 from "path";
@@ -19021,7 +19832,7 @@ function acquireDaemonMachineLock(options) {
   const lockId = getDaemonMachineLockId(options.apiKey);
   const machineDir = path15.join(rootDir, lockId);
   const lockDir = path15.join(machineDir, "daemon.lock");
-  const token = randomUUID6();
+  const token = randomUUID7();
   mkdirSync5(machineDir, { recursive: true });
   for (let attempt = 0; attempt < 2; attempt += 1) {
     try {
@@ -19343,7 +20154,7 @@ function createTraceClient(options) {
 }
 
 // src/traceBundleUpload.ts
-import { createHash as createHash6, randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash6, randomUUID as randomUUID8 } from "crypto";
 import { gzipSync as gzipSync2 } from "zlib";
 import { mkdir as mkdir2, readFile as readFile2, readdir as readdir3, stat as stat3, writeFile as writeFile2 } from "fs/promises";
 import path17 from "path";
@@ -19474,7 +20285,7 @@ var DaemonTraceBundleUploader = class {
       }
       const gzipped = gzipSync2(raw);
       const bundleSha256 = sha256Hex(gzipped);
-      const bundleId = randomUUID7();
+      const bundleId = randomUUID8();
       await uploadWithSignedCapability({
         serverUrl: this.options.serverUrl,
         apiKey: this.options.apiKey,
@@ -19576,6 +20387,34 @@ var DAEMON_CORE_TRACE_ATTR_CONTRACTS = {
   "daemon.agent.spawn.failed": {
     spanAttrs: ["agentId", "launchId", "runtime", "model", "failure_reason", "failure_detail", "session_id_present"]
   },
+  "launch_residency_transition": {
+    spanAttrs: [
+      "span_name",
+      "phase",
+      "agent_launch_id",
+      "agent_id",
+      "server_id",
+      "machine_id",
+      "runtime",
+      "driver",
+      "launch_source",
+      "state_instance_id",
+      "residency_state_instance_id",
+      "transition_seq",
+      "residency_transition_seq",
+      "transition_kind",
+      "phase_result",
+      "close_result",
+      "state",
+      "residency",
+      "agent_launch_id_present",
+      "is_wait_state",
+      "fence_kind",
+      "deadline_unix_ms",
+      "failure_kind",
+      "negative_evidence_bucket"
+    ]
+  },
   "daemon.agent.delivery": {
     spanAttrs: ["agentId", "deliveryId", "delivery_correlation_id", "messageId", "message_id_present", "seq"],
     eventAttrs: {
@@ -19715,7 +20554,7 @@ function resolveSlockCliPathOrEmpty(moduleUrl = import.meta.url) {
 }
 async function runBundledSlockCli(argv) {
   process.argv = [process.execPath, "slock", ...argv];
-  await import("./dist-OGRAMTIO.js");
+  await import("./dist-PCKZII47.js");
 }
 function detectRuntimes(tracer = noopTracer) {
   const ids = [];