chatroom-cli 1.107.2 → 1.108.1

package/dist/index.js

@@ -79451,21 +79451,7 @@ function getNextTaskCommand(params) {
 var init_command = () => {};
 
 // ../../services/backend/src/domain/entities/participant.ts
-var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", GET_NEXT_TASK_STARTED_ACTION = "get-next-task:started", NATIVE_HANDOFF_REMINDER = "Reminder: Use the handoff command to send your response to the team.", ONLINE_OR_STARTING_STATUSES;
-var init_participant = __esm(() => {
-  ONLINE_OR_STARTING_STATUSES = new Set([
-    "agent.waiting",
-    "agent.requestStart",
-    "agent.restart",
-    "agent.started",
-    "task.acknowledged",
-    "task.inProgress",
-    "task.completed",
-    "agent.requestStop",
-    "agent.awaitingHandoff",
-    "agent.enhancing"
-  ]);
-});
+var NATIVE_WAITING_ACTION = "native:waiting", NATIVE_TASK_INJECTED_ACTION = "native:task-injected", GET_NEXT_TASK_STARTED_ACTION = "get-next-task:started", NATIVE_HANDOFF_REMINDER = "Reminder: Use the handoff command to send your response to the team.";
 
 // src/commands/get-next-task/session.ts
 class GetNextTaskSession {
@@ -79725,7 +79711,6 @@ To reconnect, run:`);
 var init_session2 = __esm(() => {
   init_errorCodes();
   init_command();
-  init_participant();
   init_values();
   init_api3();
   init_client2();
@@ -80309,6 +80294,24 @@ var init_builder_to_planner = __esm(() => {
   init_role_guidance_disclosure();
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/builder.ts
+var duoBuilderHandoffContract;
+var init_builder = __esm(() => {
+  init_builder_to_planner();
+  duoBuilderHandoffContract = {
+    role: "builder",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: (query) => getBuilderToPlannerHandoffTemplate({
+        chatroomId: query.chatroomId,
+        role: query.role,
+        cliEnvPrefix: query.cliEnvPrefix
+      })
+    }
+  };
+});
+
 // ../../services/backend/src/domain/usecase/enhancer/enhancer-handoff-content.ts
 var ENHANCER_USER_MESSAGE_PLACEHOLDER = "{{USER_MESSAGE}}";
 
@@ -80503,6 +80506,20 @@ var init_enhancer_to_planner = __esm(() => {
   init_handoff_templates();
 });
 
+// ../../services/backend/prompts/teams/duo/handoff-templates/enhancer.ts
+var duoEnhancerHandoffContract;
+var init_enhancer = __esm(() => {
+  init_enhancer_to_planner();
+  duoEnhancerHandoffContract = {
+    role: "enhancer",
+    receivesFrom: ["planner"],
+    returnsTo: ["planner"],
+    outboundTemplates: {
+      planner: () => getEnhancerToPlannerHandoffTemplate()
+    }
+  };
+});
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/planner-to-builder.ts
 function getPlannerToBuilderHandoffTemplate() {
   return `${getHandoffRecipientVisibilityCallout("builder")}
@@ -80758,32 +80775,107 @@ var init_planner_to_user = __esm(() => {
   init_handoff_report_template_body();
 });
 
+// ../../services/backend/prompts/utils/chat-handoff-template.ts
+function getChatToUserHandoffTemplate() {
+  return `${getHandoffRecipientVisibilityCallout("user")}
+
+**Chat Response Template**
+
+\`\`\`markdown
+<write only the concise response the user should see; do not add handoff XML sections, proofs, context evidence, or placeholder text>
+\`\`\``;
+}
+var init_chat_handoff_template = () => {};
+
+// ../../services/backend/prompts/teams/duo/handoff-templates/planner.ts
+var duoPlannerHandoffContract;
+var init_planner = __esm(() => {
+  init_planner_to_builder();
+  init_planner_to_enhancer();
+  init_planner_to_user();
+  init_chat_handoff_template();
+  duoPlannerHandoffContract = {
+    role: "planner",
+    receivesFrom: ["user", "builder", "enhancer"],
+    returnsTo: ["builder", "enhancer", "user"],
+    outboundTemplates: {
+      builder: () => getPlannerToBuilderHandoffTemplate(),
+      enhancer: () => getPlannerToEnhancerHandoffTemplate(),
+      user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getPlannerToUserReportTemplate({
+        chatroomId: query.chatroomId,
+        role: query.role,
+        cliEnvPrefix: query.cliEnvPrefix
+      })
+    }
+  };
+});
+
+// ../../services/backend/prompts/cli/handoff-templates/contracts.ts
+function validateRoleHandoffContracts(contracts) {
+  const byRole = new Map;
+  for (const contract of contracts) {
+    const key = contract.role.toLowerCase();
+    if (byRole.has(key)) {
+      throw new Error(`Duplicate role handoff contract: "${contract.role}"`);
+    }
+    byRole.set(key, contract);
+  }
+  for (const contract of contracts) {
+    const ownerKey = contract.role.toLowerCase();
+    for (const target of Object.keys(contract.outboundTemplates)) {
+      const targetKey = target.toLowerCase();
+      if (targetKey === "user")
+        continue;
+      const targetContract = byRole.get(targetKey);
+      if (!targetContract) {
+        throw new Error(`Role "${contract.role}" declares an outbound template to "${target}", which is neither 'user' nor a role listed in the catalogue`);
+      }
+      const declaresOwner = (targetContract.receivesFrom ?? []).some((from) => from.toLowerCase() === ownerKey);
+      if (!declaresOwner) {
+        throw new Error(`Reciprocity failure: role "${targetContract.role}" receives from "${contract.role}" (via the ${contract.role} → ${target} template) but does not declare "${contract.role}" in receivesFrom`);
+      }
+    }
+  }
+}
+
 // ../../services/backend/prompts/teams/duo/handoff-templates/index.ts
+function listDuoRoleHandoffContracts() {
+  return validatedDuoRoleHandoffContracts;
+}
 function getDuoHandoffTemplate(query) {
-  const getter = DUO_HANDOFF_TEMPLATES[`${query.fromRole.toLowerCase()}:${query.toRole.toLowerCase()}`];
+  const fromRole = query.fromRole.toLowerCase();
+  const toRole = query.toRole.toLowerCase();
+  const contract = validatedDuoRoleHandoffContracts.find((candidate) => candidate.role.toLowerCase() === fromRole);
+  const getter = contract?.outboundTemplates[toRole];
   return getter?.(query) ?? null;
 }
-var DUO_HANDOFF_TEMPLATES;
+var DUO_ROLE_HANDOFF_CONTRACTS, validatedDuoRoleHandoffContracts;
 var init_handoff_templates2 = __esm(() => {
-  init_builder_to_planner();
-  init_enhancer_to_planner();
-  init_planner_to_builder();
-  init_planner_to_enhancer();
-  init_planner_to_user();
-  DUO_HANDOFF_TEMPLATES = {
-    "planner:builder": () => getPlannerToBuilderHandoffTemplate(),
-    "planner:enhancer": () => getPlannerToEnhancerHandoffTemplate(),
-    "enhancer:planner": () => getEnhancerToPlannerHandoffTemplate(),
-    "planner:user": (query) => getPlannerToUserReportTemplate({
-      chatroomId: query.chatroomId,
-      role: query.role,
-      cliEnvPrefix: query.cliEnvPrefix
-    }),
-    "builder:planner": (query) => getBuilderToPlannerHandoffTemplate({
-      chatroomId: query.chatroomId,
-      role: query.role,
-      cliEnvPrefix: query.cliEnvPrefix
-    })
+  init_builder();
+  init_enhancer();
+  init_planner();
+  DUO_ROLE_HANDOFF_CONTRACTS = [
+    duoPlannerHandoffContract,
+    duoBuilderHandoffContract,
+    duoEnhancerHandoffContract
+  ];
+  validatedDuoRoleHandoffContracts = (() => {
+    validateRoleHandoffContracts(DUO_ROLE_HANDOFF_CONTRACTS);
+    return DUO_ROLE_HANDOFF_CONTRACTS;
+  })();
+});
+
+// ../../services/backend/prompts/teams/solo/handoff-templates/enhancer.ts
+var soloEnhancerHandoffContract;
+var init_enhancer2 = __esm(() => {
+  init_handoff_templates();
+  soloEnhancerHandoffContract = {
+    role: "enhancer",
+    receivesFrom: ["solo"],
+    returnsTo: ["solo"],
+    outboundTemplates: {
+      solo: () => getEnhancerToEntryPointHandoffTemplate("solo")
+    }
   };
 });
 
@@ -80801,27 +80893,94 @@ var init_solo_to_user = __esm(() => {
   init_handoff_report_template_body();
 });
 
+// ../../services/backend/prompts/teams/solo/handoff-templates/solo.ts
+var soloHandoffContract;
+var init_solo = __esm(() => {
+  init_solo_to_user();
+  init_handoff_templates();
+  init_chat_handoff_template();
+  soloHandoffContract = {
+    role: "solo",
+    receivesFrom: ["user", "enhancer"],
+    returnsTo: ["user", "enhancer"],
+    outboundTemplates: {
+      enhancer: () => getEntryPointToEnhancerHandoffTemplate("solo"),
+      user: (query) => query.conversationMode === "chat" ? getChatToUserHandoffTemplate() : getSoloToUserReportTemplate({
+        chatroomId: query.chatroomId,
+        role: query.role,
+        cliEnvPrefix: query.cliEnvPrefix
+      })
+    }
+  };
+});
+
 // ../../services/backend/prompts/teams/solo/handoff-templates/index.ts
+function listSoloRoleHandoffContracts() {
+  return validatedSoloRoleHandoffContracts;
+}
 function getSoloHandoffTemplate(query) {
-  const getter = SOLO_HANDOFF_TEMPLATES[`${query.fromRole.toLowerCase()}:${query.toRole.toLowerCase()}`];
+  const fromRole = query.fromRole.toLowerCase();
+  const toRole = query.toRole.toLowerCase();
+  const contract = validatedSoloRoleHandoffContracts.find((candidate) => candidate.role.toLowerCase() === fromRole);
+  const getter = contract?.outboundTemplates[toRole];
   return getter?.(query) ?? null;
 }
-var SOLO_HANDOFF_TEMPLATES;
+var SOLO_ROLE_HANDOFF_CONTRACTS, validatedSoloRoleHandoffContracts;
 var init_handoff_templates3 = __esm(() => {
-  init_solo_to_user();
-  init_handoff_templates();
-  SOLO_HANDOFF_TEMPLATES = {
-    "solo:enhancer": () => getEntryPointToEnhancerHandoffTemplate("solo"),
-    "enhancer:solo": () => getEnhancerToEntryPointHandoffTemplate("solo"),
-    "solo:user": (query) => getSoloToUserReportTemplate({
-      chatroomId: query.chatroomId,
-      role: query.role,
-      cliEnvPrefix: query.cliEnvPrefix
-    })
-  };
+  init_enhancer2();
+  init_solo();
+  SOLO_ROLE_HANDOFF_CONTRACTS = [
+    soloHandoffContract,
+    soloEnhancerHandoffContract
+  ];
+  validatedSoloRoleHandoffContracts = (() => {
+    validateRoleHandoffContracts(SOLO_ROLE_HANDOFF_CONTRACTS);
+    return SOLO_ROLE_HANDOFF_CONTRACTS;
+  })();
 });
 
 // ../../services/backend/prompts/cli/handoff-templates/index.ts
+function resolveTeamContracts(teamId) {
+  const team = (teamId ?? "duo").toLowerCase();
+  if (team === "duo")
+    return listDuoRoleHandoffContracts();
+  if (team === "solo")
+    return listSoloRoleHandoffContracts();
+  return null;
+}
+function listHandoffTemplates(query) {
+  const teamId = (query.teamId ?? "duo").toLowerCase();
+  const contracts = resolveTeamContracts(teamId);
+  if (!contracts)
+    return null;
+  const contract = contracts.find((candidate) => candidate.role.toLowerCase() === query.role.toLowerCase());
+  if (!contract)
+    return null;
+  const templates = [];
+  for (const toRole of Object.keys(contract.outboundTemplates).sort()) {
+    const getter = contract.outboundTemplates[toRole];
+    const template = getter({
+      fromRole: contract.role,
+      toRole,
+      teamId,
+      nativeIntegration: query.nativeIntegration,
+      chatroomId: query.chatroomId,
+      role: contract.role,
+      cliEnvPrefix: query.cliEnvPrefix,
+      conversationMode: query.conversationMode
+    });
+    if (!template)
+      continue;
+    templates.push({ fromRole: contract.role, toRole, template });
+  }
+  return {
+    teamId,
+    role: contract.role,
+    receivesFrom: [...contract.receivesFrom],
+    returnsTo: [...contract.returnsTo],
+    templates
+  };
+}
 function getHandoffTemplate(query) {
   const team = (query.teamId ?? "duo").toLowerCase();
   if (team === "duo")
@@ -80870,6 +81029,60 @@ var init_view_template3 = __esm(() => {
   init_view_template2();
 });
 
+// ../../services/backend/prompts/cli/handoff-templates/list-templates.ts
+function formatHandoffTemplateListing(listing) {
+  const receives = listing.receivesFrom.length ? listing.receivesFrom.map((role) => `\`${role}\``).join(", ") : "(none)";
+  const returns = listing.returnsTo.length ? listing.returnsTo.map((role) => `\`${role}\``).join(", ") : "(none)";
+  const lines = [
+    `Handoff contract for \`${listing.role}\` (team: \`${listing.teamId}\`)`,
+    "",
+    `Receives from: ${receives}`,
+    `Returns to: ${returns}`,
+    "",
+    "Renderable outbound templates:",
+    ...listing.templates.map((template) => `- \`${template.fromRole}\` → \`${template.toRole}\``)
+  ];
+  return lines.join(`
+`);
+}
+function listHandoffTemplatesCommand(params) {
+  const listing = listHandoffTemplates({
+    role: params.role,
+    teamId: params.teamId,
+    cliEnvPrefix: params.cliEnvPrefix
+  });
+  if (!listing) {
+    const teamId = params.teamId ?? "duo";
+    throw new Error(`No handoff contract for role "${params.role}" in team "${teamId}". Known roles: planner, builder, enhancer (duo) or solo, enhancer (solo).`);
+  }
+  return formatHandoffTemplateListing(listing);
+}
+var init_list_templates = __esm(() => {
+  init_handoff_templates4();
+});
+
+// src/commands/handoff/list-templates.ts
+var exports_list_templates = {};
+__export(exports_list_templates, {
+  printHandoffListTemplates: () => printHandoffListTemplates
+});
+function printHandoffListTemplates(options) {
+  try {
+    const output = listHandoffTemplatesCommand({
+      role: options.role,
+      teamId: options.teamId,
+      cliEnvPrefix: options.cliEnvPrefix
+    });
+    console.log(output);
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+}
+var init_list_templates2 = __esm(() => {
+  init_list_templates();
+});
+
 // src/utils/serialization/decode/index.ts
 var exports_decode = {};
 __export(exports_decode, {
@@ -81160,20 +81373,8 @@ var init_commands_reference = __esm(() => {
   init_command3();
   init_utils3();
 });
-
-// ../../services/backend/prompts/cli/roles/builder.ts
-var init_builder = () => {};
-
-// ../../services/backend/prompts/enhancer/history-retrieval.ts
-var init_history_retrieval = __esm(() => {
-  init_guidance();
-});
-
-// ../../services/backend/prompts/cli/roles/enhancer.ts
-var init_enhancer = __esm(() => {
-  init_history_retrieval();
-  init_env();
-});
+// ../../services/backend/prompts/cli/sections/core-responsibilities.ts
+var init_core_responsibilities = () => {};
 // ../../services/backend/prompts/cli/sections/handoff-rules.ts
 var init_handoff_rules = () => {};
 // ../../services/backend/prompts/cli/sections/proof-of-verification.ts
@@ -81184,13 +81385,31 @@ var init_operating_model = () => {};
 
 // ../../services/backend/prompts/cli/sections/index.ts
 var init_sections = __esm(() => {
+  init_core_responsibilities();
   init_handoff_rules();
   init_proof_of_verification();
   init_operating_model();
 });
 
+// ../../services/backend/prompts/cli/roles/builder.ts
+var init_builder2 = __esm(() => {
+  init_sections();
+});
+
+// ../../services/backend/prompts/enhancer/history-retrieval.ts
+var init_history_retrieval = __esm(() => {
+  init_guidance();
+});
+
+// ../../services/backend/prompts/cli/roles/enhancer.ts
+var init_enhancer3 = __esm(() => {
+  init_history_retrieval();
+  init_env();
+  init_sections();
+});
+
 // ../../services/backend/prompts/cli/roles/planner.ts
-var init_planner = __esm(() => {
+var init_planner2 = __esm(() => {
   init_env();
   init_sections();
 });
@@ -81201,39 +81420,39 @@ var init_planner_guidance_context = __esm(() => {
 });
 
 // ../../services/backend/prompts/teams/solo/prompts/solo.ts
-var init_solo = __esm(() => {
+var init_solo2 = __esm(() => {
   init_planner_guidance_context();
   init_sections();
 });
 
 // ../../services/backend/prompts/cli/roles/fromContext.ts
 var init_fromContext = __esm(() => {
-  init_builder();
-  init_enhancer();
-  init_planner();
-  init_solo();
+  init_builder2();
+  init_enhancer3();
+  init_planner2();
+  init_solo2();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/builder.ts
-var init_builder2 = __esm(() => {
-  init_builder();
+var init_builder3 = __esm(() => {
+  init_builder2();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/planner.ts
-var init_planner2 = __esm(() => {
+var init_planner3 = __esm(() => {
   init_planner_guidance_context();
   init_sections();
 });
 
 // ../../services/backend/prompts/teams/duo/prompts/fromContext.ts
 var init_fromContext2 = __esm(() => {
-  init_builder2();
-  init_planner2();
+  init_builder3();
+  init_planner3();
 });
 
 // ../../services/backend/prompts/teams/solo/prompts/fromContext.ts
 var init_fromContext3 = __esm(() => {
-  init_solo();
+  init_solo2();
 });
 // ../../services/backend/prompts/selector-context.ts
 var init_selector_context = __esm(() => {
@@ -85582,7 +85801,6 @@ var init_agent2 = __esm(() => {
     "platform.pending_task_wake",
     "platform.crash_recovery",
     "platform.auto_restart_on_new_context",
-    "platform.restart_offline_on_user_message",
     "platform.team_switch",
     "test"
   ];
@@ -85699,7 +85917,7 @@ var AgentLifecycleOutboxService, AgentLifecycleOutboxServiceLive = (registry2, m
   recover: () => exports_Effect.promise(() => mgr.recover()),
   getSlot: (chatroomId, role) => mgr.getSlot(chatroomId, role),
   listActive: () => mgr.listActive(),
-  clearStuckStoppingSlot: (chatroomId, role) => exports_Effect.promise(() => mgr.clearStuckStoppingSlot(chatroomId, role)),
+  clearStuckStoppingSlot: (chatroomId, role, options) => exports_Effect.promise(() => mgr.clearStuckStoppingSlot(chatroomId, role, options)),
   whenTurnEndsIdle: () => exports_Effect.promise(() => mgr.whenTurnEndsIdle()),
   resumeTurnForSlot: (args2) => exports_Effect.promise(() => mgr.resumeTurnForSlot(args2)),
   setLastInFlightTask: (chatroomId, role, taskId) => exports_Effect.sync(() => mgr.setLastInFlightTask(chatroomId, role, taskId)),
@@ -100874,7 +101092,8 @@ var init_assigned_task_snapshot_contract = __esm(() => {
     createdAt: exports_external.number(),
     workingDir: exports_external.string().optional(),
     assignedTo: exports_external.string().optional(),
-    sessionAugmentation: sessionAugmentationSchema.optional()
+    sessionAugmentation: sessionAugmentationSchema.optional(),
+    requestsNativeColdSession: exports_external.boolean().optional()
   };
   assignedTaskSignalSchema = exports_external.object(assignedTaskSignalBootstrapFields);
   assignedTaskPresenceSignalSchema = exports_external.object({
@@ -100899,7 +101118,8 @@ var init_assigned_task_snapshot_contract = __esm(() => {
     updatedAt: exports_external.number(),
     createdAt: exports_external.number(),
     agentConfig: assignedTaskAgentConfigSchema,
-    participant: assignedTaskParticipantSchema.optional()
+    participant: assignedTaskParticipantSchema.optional(),
+    requestsNativeColdSession: exports_external.boolean().optional()
   }).transform((row) => ({
     ...row,
     assignedTo: row.assignedTo
@@ -100916,30 +101136,44 @@ class NativeDeliveryLedger {
   isDelivered(taskId, harnessSessionId) {
     return this.delivered.has(this.deliveryKey(taskId, harnessSessionId));
   }
-  tryAcquire(taskId, harnessSessionId) {
-    const key = this.deliveryKey(taskId, harnessSessionId);
-    if (this.delivered.has(key) || this.inFlight.has(key)) {
+  isAttemptInFlight(taskId) {
+    return this.inFlight.has(taskId);
+  }
+  tryAcquire(taskId, existingSessionId) {
+    if (this.inFlight.has(taskId)) {
       return false;
     }
-    this.inFlight.add(key);
+    if (existingSessionId && this.delivered.has(this.deliveryKey(taskId, existingSessionId))) {
+      return false;
+    }
+    this.inFlight.add(taskId);
     return true;
   }
+  releaseAttempt(taskId) {
+    this.inFlight.delete(taskId);
+  }
   markDelivered(taskId, harnessSessionId) {
-    const key = this.deliveryKey(taskId, harnessSessionId);
-    this.inFlight.delete(key);
-    this.delivered.add(key);
+    this.inFlight.delete(taskId);
+    this.delivered.add(this.deliveryKey(taskId, harnessSessionId));
   }
   clearDelivery(taskId, harnessSessionId) {
-    const key = this.deliveryKey(taskId, harnessSessionId);
-    this.inFlight.delete(key);
-    this.delivered.delete(key);
+    this.inFlight.delete(taskId);
+    if (harnessSessionId) {
+      this.delivered.delete(this.deliveryKey(taskId, harnessSessionId));
+    } else {
+      const prefix = `${taskId}\x00`;
+      for (const key of [...this.delivered]) {
+        if (key.startsWith(prefix)) {
+          this.delivered.delete(key);
+        }
+      }
+    }
   }
   clearSession(harnessSessionId) {
     const suffix = `\x00${harnessSessionId}`;
-    for (const key of [...this.delivered, ...this.inFlight]) {
+    for (const key of [...this.delivered]) {
       if (key.endsWith(suffix)) {
         this.delivered.delete(key);
-        this.inFlight.delete(key);
       }
     }
   }
@@ -100950,10 +101184,31 @@ function getNativeDeliveryLedger() {
 }
 var sharedLedger;
 
+// src/daemon/domain/usecase/check-agent-slot.ts
+function isSlotIdle(state) {
+  return state === "idle";
+}
+function isSlotSpawning(state) {
+  return state === "spawning";
+}
+function isSlotRunning(state) {
+  return state === "running";
+}
+function isSlotStopping(state) {
+  return state === "stopping";
+}
+function isTurnPhaseIdle(phase) {
+  return phase === "idle";
+}
+var init_check_agent_slot = () => {};
+
 // src/daemon/infrastructure/agent-operational/agent-operational-read-model.ts
 function isOperationalDesiredRunning(row) {
   return row?.operationalState === "running" || row?.operationalState === "starting";
 }
+function isOperationalCircuitOpen(row) {
+  return row?.operationalState === "circuit_open";
+}
 function isOperationalStopIntentActive(row) {
   return row?.stopState === "stopped" || row?.stopState === "stopping" || row?.stopState === "pending";
 }
@@ -101003,6 +101258,43 @@ class AgentOperationalReadModel {
 }
 var roleKey = (chatroomId, role) => `${chatroomId}:${role.toLowerCase()}`;
 
+// src/daemon/entry/native-delivery/native-cold-session-delivery.ts
+function snapshotRequestsNativeColdSession(task) {
+  return task.requestsNativeColdSession === true;
+}
+function isColdStartEligibleSlotState(slot) {
+  if (!slot)
+    return true;
+  return isSlotIdle(slot.state);
+}
+function isNativeColdSessionDeliveryOwnedSpawn(task, slot) {
+  return snapshotRequestsNativeColdSession(task) && isColdStartEligibleSlotState(slot);
+}
+function explainColdSessionDeliveryBlock(task, slot, operational) {
+  if (!snapshotRequestsNativeColdSession(task))
+    return null;
+  if (isChatroomStopScopeActive(task.chatroomId)) {
+    return "chatroom_stop_scope_active";
+  }
+  if (isOperationalStopIntentActive(operational)) {
+    return "operational_stop_intent_active";
+  }
+  if (isOperationalCircuitOpen(operational)) {
+    return "operational_circuit_open";
+  }
+  if (slot && isSlotSpawning(slot.state)) {
+    return `slot_spawning (slotState=${slot.state})`;
+  }
+  if (slot && isSlotStopping(slot.state)) {
+    return `slot_stopping (slotState=${slot.state})`;
+  }
+  return null;
+}
+var init_native_cold_session_delivery = __esm(() => {
+  init_check_agent_slot();
+  init_execute_stop_targets_adapter();
+});
+
 // src/daemon/infrastructure/inbox/task-snapshot-state.ts
 function snapshotKey(taskId, role) {
   return `${taskId}:${role.toLowerCase()}`;
@@ -101075,24 +101367,6 @@ function isDeliverableTaskStatus(status3) {
 }
 var init_assigned_task = () => {};
 
-// src/daemon/domain/usecase/check-agent-slot.ts
-function isSlotIdle(state) {
-  return state === "idle";
-}
-function isSlotSpawning(state) {
-  return state === "spawning";
-}
-function isSlotRunning(state) {
-  return state === "running";
-}
-function isSlotStopping(state) {
-  return state === "stopping";
-}
-function isTurnPhaseIdle(phase) {
-  return phase === "idle";
-}
-var init_check_agent_slot = () => {};
-
 // src/daemon/entry/native-delivery/native-ready-invariant.ts
 function isAgentReadyForNativeDelivery(task, slot) {
   return explainAgentReadyForNativeDeliveryBlock(task, slot) === null;
@@ -101103,6 +101377,13 @@ function explainAgentReadyForNativeDeliveryBlock(task, slot) {
     return `not_native_harness (harness=${agentConfig.agentHarness})`;
   }
   const operational = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, agentConfig.role);
+  const coldBlock = explainColdSessionDeliveryBlock(task, slot, operational);
+  if (coldBlock) {
+    return coldBlock;
+  }
+  if (isNativeColdSessionDeliveryOwnedSpawn(task, slot)) {
+    return null;
+  }
   if (!isOperationalDesiredRunning(operational)) {
     return `operational_state_not_running (state=${operational?.operationalState ?? "missing"})`;
   }
@@ -101132,6 +101413,7 @@ function isDeliverableNativeTaskStatus(status3) {
 }
 var init_native_ready_invariant = __esm(() => {
   init_types();
+  init_native_cold_session_delivery();
   init_native_delivery_session_registry();
   init_assigned_task();
   init_check_agent_slot();
@@ -101226,7 +101508,10 @@ function explainInFlightDeliveryBlock(task, slot) {
   return null;
 }
 function explainLedgerDeliveryBlock(taskId, harnessSessionId, ledger) {
-  if (ledger.isDelivered(taskId, harnessSessionId)) {
+  if (ledger.isAttemptInFlight(taskId)) {
+    return "delivery_ledger_busy (duplicate inject in flight)";
+  }
+  if (harnessSessionId && ledger.isDelivered(taskId, harnessSessionId)) {
     return "already_delivered_this_session";
   }
   return null;
@@ -101247,6 +101532,120 @@ var init_native_task_injector_logic = __esm(() => {
   };
 });
 
+// ../shared/src/domain/conversation-mode.ts
+function legacyConversationMode(plannerEnhancerEnabled) {
+  return plannerEnhancerEnabled ? "code:enhanced" : "code";
+}
+var CONVERSATION_MODES;
+var init_conversation_mode = __esm(() => {
+  CONVERSATION_MODES = ["chat", "code", "code:enhanced"];
+});
+
+// ../shared/src/domain/task-envelope.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isConversationMode(value) {
+  return CONVERSATION_MODES.includes(value);
+}
+function isSessionPolicy(value) {
+  return TASK_SESSION_POLICIES.includes(value);
+}
+function isHandoffPreset(value) {
+  return HANDOFF_WORKFLOW_PRESETS.includes(value);
+}
+function isHandoffPhase(value) {
+  return HANDOFF_WORKFLOW_PHASES.includes(value);
+}
+function assertConversationMode(value, origin2) {
+  if (!isConversationMode(value)) {
+    throw new TypeError(`taskEnvelope: invalid conversationMode ${JSON.stringify(value)} in ${origin2}`);
+  }
+}
+function workflowPresetForMode(mode) {
+  return MODE_DEFAULT_PRESET[mode];
+}
+function buildTaskEnvelope(conversationMode, sessionPolicy) {
+  return {
+    version: TASK_ENVELOPE_VERSION,
+    conversationMode,
+    sessionPolicy,
+    handoffWorkflow: {
+      preset: workflowPresetForMode(conversationMode),
+      phase: "entry"
+    }
+  };
+}
+function copyTaskEnvelope(envelope) {
+  return {
+    version: TASK_ENVELOPE_VERSION,
+    conversationMode: envelope.conversationMode,
+    sessionPolicy: envelope.sessionPolicy,
+    handoffWorkflow: {
+      preset: envelope.handoffWorkflow.preset,
+      phase: envelope.handoffWorkflow.phase
+    }
+  };
+}
+function isEnvelopeRecordAndVersion(value) {
+  return isRecord(value) && value.version === TASK_ENVELOPE_VERSION;
+}
+function isWorkflowShape(workflow) {
+  return isRecord(workflow) && isHandoffPreset(workflow.preset) && isHandoffPhase(workflow.phase);
+}
+function isPresetChoice(workflow, mode) {
+  return workflow.preset === workflowPresetForMode(mode);
+}
+function isEnvelopeWorkflowValid(value, mode) {
+  return isWorkflowShape(value.handoffWorkflow) && isPresetChoice(value.handoffWorkflow, mode);
+}
+function isTaskEnvelopeV1(value) {
+  if (!isEnvelopeRecordAndVersion(value))
+    return false;
+  if (!isConversationMode(value.conversationMode))
+    return false;
+  if (!isSessionPolicy(value.sessionPolicy))
+    return false;
+  return isEnvelopeWorkflowValid(value, value.conversationMode);
+}
+function deriveLegacyMode(input) {
+  const rawMode = input.conversationMode;
+  if (rawMode !== undefined) {
+    assertConversationMode(rawMode, "normalizeTaskEnvelope");
+    return rawMode;
+  }
+  return legacyConversationMode(input.plannerEnhancerEnabled);
+}
+function deriveLegacySession(startInNewSession) {
+  return startInNewSession === true ? "new" : "continue";
+}
+function normalizeTaskEnvelope(input) {
+  if (input.taskEnvelope !== undefined) {
+    if (!isTaskEnvelopeV1(input.taskEnvelope)) {
+      throw new TypeError("taskEnvelope: invalid explicit TaskEnvelopeV1 value");
+    }
+    return copyTaskEnvelope(input.taskEnvelope);
+  }
+  return buildTaskEnvelope(deriveLegacyMode(input), deriveLegacySession(input.startInNewSession));
+}
+var TASK_ENVELOPE_VERSION = 1, HANDOFF_WORKFLOW_PRESETS, HANDOFF_WORKFLOW_PHASES, TASK_SESSION_POLICIES, MODE_DEFAULT_PRESET;
+var init_task_envelope = __esm(() => {
+  init_conversation_mode();
+  HANDOFF_WORKFLOW_PRESETS = ["direct", "team", "enhanced-team"];
+  HANDOFF_WORKFLOW_PHASES = [
+    "entry",
+    "enhancement",
+    "implementation",
+    "delivery"
+  ];
+  TASK_SESSION_POLICIES = ["continue", "new"];
+  MODE_DEFAULT_PRESET = {
+    chat: "direct",
+    code: "team",
+    "code:enhanced": "enhanced-team"
+  };
+});
+
 // ../../services/backend/src/domain/entities/team-agent-settings.ts
 function roleSupportsSessionAugmentation(role) {
   const normalized = role.toLowerCase();
@@ -101259,10 +101658,21 @@ var init_team_agent_settings = __esm(() => {
 
 // ../../services/backend/src/domain/handoff/parse-session-augmentation.ts
 function resolveSessionAugmentationForTask(task, role) {
-  if (task.startInNewSession !== undefined)
+  if (task.taskEnvelope !== undefined) {
+    const envelope = normalizeTaskEnvelope({ taskEnvelope: task.taskEnvelope });
+    return envelope.sessionPolicy === "new" ? "new_session" : "none";
+  }
+  if (task.startInNewSession !== undefined) {
     return task.startInNewSession ? "new_session" : "none";
+  }
   return resolveSessionAugmentationForRole(role);
 }
+function taskRequestsNativeColdSession(task) {
+  if (task.taskEnvelope !== undefined) {
+    return normalizeTaskEnvelope({ taskEnvelope: task.taskEnvelope }).sessionPolicy === "new";
+  }
+  return task.startInNewSession === true;
+}
 function shouldEmitSessionAugmentation(role, mode) {
   return roleSupportsSessionAugmentation(role) || mode === "new_session";
 }
@@ -101278,6 +101688,7 @@ function sessionAugmentationNewSessionStarted(mode) {
   return mode === "new_session";
 }
 var init_parse_session_augmentation = __esm(() => {
+  init_task_envelope();
   init_team_agent_settings();
 });
 
@@ -101296,17 +101707,31 @@ async function waitForHarnessSessionId(agentMgr, chatroomId, role) {
   return null;
 }
 async function ensureColdSessionBeforeNativeInject(task, deps) {
-  if (!task.startInNewSession)
+  if (!taskRequestsNativeColdSession({
+    content: task.taskContent ?? "",
+    taskEnvelope: task.taskEnvelope,
+    startInNewSession: task.startInNewSession
+  })) {
     return null;
+  }
   const { chatroomId, agentConfig, taskId } = task;
   const { role, agentHarness, model, workingDir } = agentConfig;
   if (!workingDir || !model)
     return null;
-  await deps.agentMgr.stop({
-    chatroomId,
-    role,
-    reason: AgentStopReasonEnum["platform.task_start_in_new_session"]
-  });
+  const slot = deps.agentMgr.getSlot(chatroomId, role);
+  const slotState = slot?.state;
+  if (slotState === "spawning" || slotState === "stopping") {
+    return null;
+  }
+  if (slotState === "running") {
+    const stopped = await deps.agentMgr.stop({
+      chatroomId,
+      role,
+      reason: AgentStopReasonEnum["platform.task_start_in_new_session"]
+    });
+    if (!stopped?.success)
+      return null;
+  }
   const spawn3 = await deps.agentMgr.ensureRunning({
     chatroomId,
     role,
@@ -101355,7 +101780,7 @@ async function ensureColdSessionBeforeNativeInject(task, deps) {
 var init_native_cold_session_before_inject = __esm(() => {
   init_reliability();
   init_agent2();
-  init_participant();
+  init_parse_session_augmentation();
   init_api3();
 });
 
@@ -101427,12 +101852,28 @@ function claimPendingTaskIfNeeded(task, deps) {
     }
   });
 }
+function resolveHarnessSessionPolicy(task, initialHarnessSessionId) {
+  if (!taskRequestsNativeColdSession({
+    content: task.taskContent ?? "",
+    taskEnvelope: task.taskEnvelope,
+    startInNewSession: task.startInNewSession
+  })) {
+    if (!initialHarnessSessionId)
+      return { kind: "missing" };
+    return { kind: "use-existing", harnessSessionId: initialHarnessSessionId };
+  }
+  return { kind: "cold-start" };
+}
 function resolveHarnessSessionForInject(task, deps, initialHarnessSessionId) {
   return exports_Effect.gen(function* () {
     const { chatroomId, taskId, agentConfig } = task;
     const { role } = agentConfig;
-    if (!task.startInNewSession) {
-      return { harnessSessionId: initialHarnessSessionId, sessionAugmentationEmitted: false };
+    const policy = resolveHarnessSessionPolicy(task, initialHarnessSessionId);
+    if (policy.kind === "missing") {
+      return yield* exports_Effect.fail(new Error("harness session missing for continue inject"));
+    }
+    if (policy.kind === "use-existing") {
+      return { harnessSessionId: policy.harnessSessionId, sessionAugmentationEmitted: false };
     }
     const coldSession = yield* applyColdSessionIfRequested(task, deps, chatroomId, role, taskId);
     if ("failed" in coldSession) {
@@ -101478,7 +101919,7 @@ function emitSessionAugmentationIfNeeded(task, deps, harnessSessionId, sessionAu
     catch: (err) => err
   }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
 }
-function resumeHarnessWithPrompt(task, deps, prompt) {
+function resumeHarnessWithPrompt(task, deps, prompt, harnessSessionId) {
   return exports_Effect.gen(function* () {
     const { chatroomId, taskId, agentConfig } = task;
     const { role } = agentConfig;
@@ -101509,7 +101950,12 @@ function resumeHarnessWithPrompt(task, deps, prompt) {
       }),
       catch: (err) => err
     }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-    deps.onTaskDelivered?.({ chatroomId, role, taskId });
+    deps.onTaskDelivered?.({
+      chatroomId,
+      role,
+      taskId,
+      harnessSessionId
+    });
   });
 }
 function loadNativeInjectionPrompt(task, deps) {
@@ -101535,7 +101981,11 @@ function loadNativeInjectionPrompt(task, deps) {
       });
       return yield* exports_Effect.fail(deliveryResult.left);
     }
-    const augmentationMode = resolveSessionAugmentationForTask({ content: taskContent, startInNewSession: task.startInNewSession }, role);
+    const augmentationMode = resolveSessionAugmentationForTask({
+      content: taskContent,
+      taskEnvelope: task.taskEnvelope,
+      startInNewSession: task.startInNewSession
+    }, role);
     return {
       augmentationMode,
       prompt: buildNativeInjectionPrompt({
@@ -101551,7 +102001,12 @@ function injectNativeTaskPrompt(task, deps, harnessSessionId, sessionAugmentatio
     const { role } = agentConfig;
     const { prompt, augmentationMode } = yield* loadNativeInjectionPrompt(task, deps);
     yield* exports_Effect.tryPromise({
-      try: () => deps.lifecycleOutbox ? deps.lifecycleOutbox.enqueue(buildActivityLifecycleFact({ chatroomId, role, action: NATIVE_TASK_INJECTED_ACTION, taskId })) : Promise.reject(new Error("lifecycle outbox missing")),
+      try: () => deps.lifecycleOutbox ? deps.lifecycleOutbox.enqueue(buildActivityLifecycleFact({
+        chatroomId,
+        role,
+        action: NATIVE_TASK_INJECTED_ACTION,
+        taskId
+      })) : Promise.reject(new Error("lifecycle outbox missing")),
       catch: (err) => err
     });
     yield* exports_Effect.tryPromise({
@@ -101566,7 +102021,7 @@ function injectNativeTaskPrompt(task, deps, harnessSessionId, sessionAugmentatio
       catch: (err) => err
     });
     yield* emitSessionAugmentationIfNeeded(task, deps, harnessSessionId, sessionAugmentationEmitted, augmentationMode);
-    yield* resumeHarnessWithPrompt(task, deps, prompt);
+    yield* resumeHarnessWithPrompt(task, deps, prompt, harnessSessionId);
   });
 }
 function runNativeInjectionEffect(task, initialHarnessSessionId, deps) {
@@ -101577,7 +102032,6 @@ function runNativeInjectionEffect(task, initialHarnessSessionId, deps) {
   });
 }
 var init_native_task_injector = __esm(() => {
-  init_participant();
   init_parse_session_augmentation();
   init_esm();
   init_native_cold_session_before_inject();
@@ -101606,13 +102060,15 @@ function mapAssignedTaskSnapshot(row) {
       circuitState: row.agentConfig.circuitState,
       configLifecycleRevision: row.agentConfig.configLifecycleRevision
     },
-    participant: row.participant
+    participant: row.participant,
+    requestsNativeColdSession: row.requestsNativeColdSession
   };
 }
 function mapAssignedTaskView(row) {
   return {
     ...mapAssignedTaskSnapshot(row),
     taskContent: row.taskContent,
+    taskEnvelope: row.taskEnvelope,
     startInNewSession: row.startInNewSession
   };
 }
@@ -101744,10 +102200,6 @@ class NativeTaskDeliveryCoordinator {
         continue;
       }
       const harnessSessionId = slot?.harnessSessionId;
-      if (!harnessSessionId) {
-        logNativeDeliverySkip(role, row.chatroomId, row.taskId, "harness_session_missing (pre-gate)");
-        continue;
-      }
       const ledgerBlock = explainLedgerDeliveryBlock(row.taskId, harnessSessionId, ledger);
       if (ledgerBlock) {
         logNativeDeliverySkip(role, row.chatroomId, row.taskId, ledgerBlock);
@@ -101758,7 +102210,7 @@ class NativeTaskDeliveryCoordinator {
         continue;
       }
       if (!deliveryState.tryAcquireDelivery(row.chatroomId, role)) {
-        ledger.clearDelivery(row.taskId, harnessSessionId);
+        ledger.releaseAttempt(row.taskId);
         logNativeDeliveryMutexSkip(role, row.chatroomId, row.taskId);
         continue;
       }
@@ -101793,9 +102245,14 @@ class NativeTaskDeliveryCoordinator {
             getSlot: (chatroomId, role2) => agentMgr.getSlot(chatroomId, role2)
           },
           convexUrl: sessionDeps.convexUrl,
-          onTaskDelivered: ({ chatroomId, role: role2, taskId: deliveredTaskId }) => {
+          onTaskDelivered: ({
+            chatroomId,
+            role: role2,
+            taskId: deliveredTaskId,
+            harnessSessionId: resolvedSessionId
+          }) => {
             deliveredToHarness = true;
-            ledger.markDelivered(deliveredTaskId, harnessSessionId);
+            ledger.markDelivered(deliveredTaskId, resolvedSessionId);
             exports_Effect.runSync(agentMgr.setLastInFlightTask(chatroomId, role2, deliveredTaskId));
             deliveryState.clearNativeNudgeFailures(chatroomId, role2);
           }
@@ -101803,7 +102260,7 @@ class NativeTaskDeliveryCoordinator {
       }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[NativeTaskDelivery] delivery failed for ${row.agentConfig.role}@${row.chatroomId}: ${getErrorMessage(err)}`))), exports_Effect.ensuring(exports_Effect.sync(() => {
         deliveryState.releaseDelivery(row.chatroomId, row.agentConfig.role);
         if (!deliveredToHarness) {
-          ledger.clearDelivery(taskId, harnessSessionId);
+          ledger.releaseAttempt(taskId);
         }
       }))));
       break;
@@ -101976,9 +102433,9 @@ async function deliverOneTask(deps, event, snapshot) {
         ensureRunning: (opts) => exports_Effect.runPromise(deps.agentMgr.ensureRunning(opts)),
         getSlot: (chatroomId, role) => deps.agentMgr.getSlot(chatroomId, role)
       },
-      onTaskDelivered: ({ chatroomId, role, taskId }) => {
+      onTaskDelivered: ({ chatroomId, role, taskId, harnessSessionId: resolvedSessionId }) => {
         deliveredToHarness = true;
-        ledger.markDelivered(taskId, harnessSessionId);
+        ledger.markDelivered(taskId, resolvedSessionId);
         deps.agentMgr.setLastInFlightTask(chatroomId, role, taskId);
       }
     }));
@@ -101988,7 +102445,7 @@ async function deliverOneTask(deps, event, snapshot) {
     return false;
   } finally {
     if (!deliveredToHarness) {
-      ledger.clearDelivery(snapshot.taskId, harnessSessionId);
+      ledger.releaseAttempt(snapshot.taskId);
     }
   }
 }
@@ -102057,7 +102514,6 @@ async function runRestartOrchestrator(deps, event) {
 }
 var init_restart_orchestrator = __esm(() => {
   init_reliability();
-  init_participant();
   init_build_agent_restart_event();
   init_assigned_task_snapshot_contract();
   init_esm();
@@ -103499,7 +103955,6 @@ function wireTokenActivityReporting(opts) {
 var NATIVE_TOKEN_ACTIVITY_THROTTLE_MS = 30000;
 var init_native_spawn_presence = __esm(() => {
   init_types();
-  init_participant();
   init_api3();
   init_execution_kind();
 });
@@ -104322,7 +104777,7 @@ class AgentProcessManager {
     }
     return result;
   }
-  async clearStuckStoppingSlot(chatroomId, role) {
+  async clearStuckStoppingSlot(chatroomId, role, options) {
     const key = agentKey3(chatroomId, role);
     const slot = this.slots.get(key);
     if (!slot || slot.state !== "stopping") {
@@ -104332,7 +104787,7 @@ class AgentProcessManager {
     if (elapsed3 < STOPPING_TIMEOUT_MS) {
       return false;
     }
-    await this.forceClearStuckStoppingSlot(key, slot, chatroomId, role, "daemon.stop_timeout");
+    await this.forceClearStuckStoppingSlot(key, slot, chatroomId, role, "daemon.stop_timeout", options?.clearStopIntent);
     console.warn(`[AgentProcessManager] ⚠️ Cleared stuck stopping slot for ${role}@${chatroomId}`);
     return true;
   }
@@ -105160,7 +105615,7 @@ class AgentProcessManager {
     slot.pendingOperation = undefined;
     slot.stoppingSince = undefined;
   }
-  async forceClearStuckStoppingSlot(key, slot, chatroomId, role, reason) {
+  async forceClearStuckStoppingSlot(key, slot, chatroomId, role, reason, clearStopIntent = false) {
     const pid = slot.pid;
     const harness = slot.harness;
     const stopCommandId = slot.stopCommandId;
@@ -105168,6 +105623,9 @@ class AgentProcessManager {
     const durationMs = slot.stoppingSince ? this.deps.clock.now() - slot.stoppingSince : STOPPING_TIMEOUT_MS;
     this.bumpStopGeneration(slot);
     this.clearSlotRuntimeState(slot);
+    if (clearStopIntent) {
+      this.clearStopIntent(slot);
+    }
     logDaemonAuditEvent(this.deps.logEvent, {
       type: "agent.stopTimeout",
       chatroomId,
@@ -105276,7 +105734,6 @@ var AGENT_EXIT_RETRY_INTERVAL_MS = 1e4, STOPPING_TIMEOUT_MS = 30000;
 var init_agent_process_manager = __esm(() => {
   init_agent2();
   init_types();
-  init_participant();
   init_esm();
   init_execute_stop_targets_adapter();
   init_stop_agent_confirmed_adapter();
@@ -117581,9 +118038,57 @@ function isNativeAgentSlotDown(task, health, now = Date.now()) {
   }
   return isSlotUnavailableForPid(slot, pid, health.isPidAlive, now);
 }
-function isNativeActiveTaskAgentDown(task, health, now) {
+function roleKey4(chatroomId, role) {
+  return `${chatroomId}:${role.toLowerCase()}`;
+}
+function isCandidateDeliverableForOwnership(task) {
+  if (!isDeliverableTaskStatus(task.status))
+    return false;
+  if (task.status === "acknowledged") {
+    return task.assignedTo?.toLowerCase() === task.agentConfig.role.toLowerCase();
+  }
+  return true;
+}
+function comparePendingFirst(a, b) {
+  const pendingDelta = (a.status === "pending" ? 0 : 1) - (b.status === "pending" ? 0 : 1);
+  return pendingDelta !== 0 ? pendingDelta : a.createdAt - b.createdAt;
+}
+function selectNextCandidatePerRole(tasks) {
+  const byRole = new Map;
+  for (const task of tasks) {
+    if (!isCandidateDeliverableForOwnership(task))
+      continue;
+    const key = roleKey4(task.chatroomId, task.agentConfig.role);
+    const list = byRole.get(key) ?? [];
+    list.push(task);
+    byRole.set(key, list);
+  }
+  const selected = new Map;
+  for (const [key, list] of byRole) {
+    const first = [...list].sort(comparePendingFirst)[0];
+    if (first)
+      selected.set(key, first);
+  }
+  return selected;
+}
+function selectColdOwnedRoles(tasks, health, now) {
+  const owned = new Set;
+  for (const [key, candidate] of selectNextCandidatePerRole(tasks)) {
+    if (!isNativeHarness(candidate.agentConfig.agentHarness))
+      continue;
+    if (!snapshotRequestsNativeColdSession(candidate))
+      continue;
+    if (!isNativeAgentSlotDown(candidate, health, now))
+      continue;
+    owned.add(key);
+  }
+  return owned;
+}
+function isNativeActiveTaskAgentDown(task, health, now, coldOwnedRoles) {
   if (!isNativeHarness(task.agentConfig.agentHarness))
     return false;
+  if (coldOwnedRoles?.has(roleKey4(task.chatroomId, task.agentConfig.role)))
+    return false;
   const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, task.agentConfig.role);
   if (!isOperationalDesiredRunning(op))
     return false;
@@ -117592,8 +118097,9 @@ function isNativeActiveTaskAgentDown(task, health, now) {
   return isNativeAgentSlotDown(task, health, now);
 }
 function listNativeTasksNeedingRevive(tasks, health, now, cooldown) {
+  const coldOwnedRoles = selectColdOwnedRoles(tasks, health, now);
   return tasks.filter((task) => {
-    if (!isNativeActiveTaskAgentDown(task, health, now))
+    if (!isNativeActiveTaskAgentDown(task, health, now, coldOwnedRoles))
       return false;
     const { chatroomId, agentConfig } = task;
     if (!agentConfig.workingDir)
@@ -117604,23 +118110,35 @@ function listNativeTasksNeedingRevive(tasks, health, now, cooldown) {
     return true;
   });
 }
-function isNativePendingTaskNeedingWake(task) {
+function isNativePendingTaskNeedingWake(task, coldOwnedRoles) {
   if (!isNativeHarness(task.agentConfig.agentHarness))
     return false;
   if (task.status !== "pending")
     return false;
+  if (snapshotRequestsNativeColdSession(task))
+    return false;
+  if (coldOwnedRoles?.has(roleKey4(task.chatroomId, task.agentConfig.role)))
+    return false;
   if (isChatroomStopScopeActive(task.chatroomId))
     return false;
   const op = getNativeDeliverySession()?.agentOperationalReadModel?.get(task.chatroomId, task.agentConfig.role);
   if (isOperationalDesiredRunning(op))
     return false;
+  if (isOperationalCircuitOpen(op))
+    return false;
   if (isOperationalStopIntentActive(op))
     return false;
   return Boolean(task.agentConfig.workingDir);
 }
 function listNativePendingTasksNeedingWake(tasks, cooldown, now) {
+  const coldOwnedRoles = new Set;
+  for (const [key, candidate] of selectNextCandidatePerRole(tasks)) {
+    if (candidate.status === "pending" && isNativeHarness(candidate.agentConfig.agentHarness) && snapshotRequestsNativeColdSession(candidate)) {
+      coldOwnedRoles.add(key);
+    }
+  }
   return tasks.filter((task) => {
-    if (!isNativePendingTaskNeedingWake(task))
+    if (!isNativePendingTaskNeedingWake(task, coldOwnedRoles))
       return false;
     const { chatroomId, agentConfig } = task;
     if (!cooldown.canAttempt(chatroomId, agentConfig.role, "wake", now))
@@ -117647,16 +118165,22 @@ class RecoveryCooldown {
 }
 var RECOVERY_COOLDOWN_MS = 60000;
 var init_task_delivery_logic = __esm(() => {
+  init_assigned_task();
   init_check_agent_slot();
   init_agent_process_manager();
   init_execute_stop_targets_adapter();
+  init_native_cold_session_delivery();
   init_native_delivery_session_registry();
   init_native_task_injector_logic();
 });
 
 // src/daemon/entry/native-delivery/task-delivery-processor.ts
 function resolveTaskWantResume(task) {
-  return sessionAugmentationToWantResume(resolveSessionAugmentationForTask({ content: task.taskContent ?? "", startInNewSession: task.startInNewSession }, task.agentConfig.role));
+  return sessionAugmentationToWantResume(resolveSessionAugmentationForTask({
+    content: task.taskContent ?? "",
+    taskEnvelope: task.taskEnvelope,
+    startInNewSession: task.startInNewSession
+  }, task.agentConfig.role));
 }
 function resolveTaskRunnerContextFromFull(task) {
   const { chatroomId, agentConfig } = task;
@@ -117679,7 +118203,7 @@ function runNativeReviveEffect(task, runtime4, effectContext2, agentMgr) {
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
   console.log(`[TaskMonitor] native revive ${role}@${chatroomId} — backend PID stale or missing locally for pending task ${task.taskId}`);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
-    yield* agentMgr.ensureRunning({
+    const result = yield* agentMgr.ensureRunning({
       chatroomId,
       role,
       agentHarness: agentConfig.agentHarness,
@@ -117690,6 +118214,9 @@ function runNativeReviveEffect(task, runtime4, effectContext2, agentMgr) {
       lifecycleRevision: task.agentConfig.configLifecycleRevision,
       taskId: task.taskId
     });
+    if (!result.success) {
+      yield* exports_Effect.sync(() => console.warn(`[TaskMonitor] native revive rejected for ${role}@${chatroomId}: ${result.error ?? "unknown error"}`));
+    }
   }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] native revive failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
 }
 function runNativeWakeEffect(task, runtime4, effectContext2, agentMgr) {
@@ -117699,7 +118226,7 @@ function runNativeWakeEffect(task, runtime4, effectContext2, agentMgr) {
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
   console.log(`[TaskMonitor] native wake ${role}@${chatroomId} — operational_state=stopped with pending task ${task.taskId}`);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
-    yield* agentMgr.ensureRunning({
+    const result = yield* agentMgr.ensureRunning({
       chatroomId,
       role,
       agentHarness: agentConfig.agentHarness,
@@ -117710,6 +118237,9 @@ function runNativeWakeEffect(task, runtime4, effectContext2, agentMgr) {
       lifecycleRevision: task.agentConfig.configLifecycleRevision,
       taskId: task.taskId
     });
+    if (!result.success) {
+      yield* exports_Effect.sync(() => console.warn(`[TaskMonitor] native wake rejected for ${role}@${chatroomId}: ${result.error ?? "unknown error"}`));
+    }
   }).pipe(exports_Effect.provide(effectContext2), exports_Effect.catchAll((err) => exports_Effect.sync(() => console.warn(`[TaskMonitor] native wake failed for ${role}@${chatroomId}: ${getErrorMessage(err)}`)))));
 }
 async function fetchTaskForAction(sessionDeps, machineId, snapshotRow) {
@@ -117721,17 +118251,30 @@ async function fetchTaskForAction(sessionDeps, machineId, snapshotRow) {
   });
   return result ? mapAssignedTaskView(result) : null;
 }
-async function clearStuckStoppingSlotIfNeeded(agentMgr, chatroomId, role) {
-  const cleared = await agentMgr.clearStuckStoppingSlot(chatroomId, role);
+async function clearStuckStoppingSlotIfNeeded(agentMgr, chatroomId, role, clearStopIntent) {
+  const cleared = await agentMgr.clearStuckStoppingSlot(chatroomId, role, {
+    clearStopIntent
+  });
   if (cleared) {
     console.log(`[TaskMonitor] cleared stuck stopping slot for ${role}@${chatroomId}`);
   }
 }
+async function normalizeStuckStoppingSlots(tasks, agentMgr) {
+  const seen = new Set;
+  for (const row of tasks) {
+    const key = `${row.chatroomId}:${row.agentConfig.role.toLowerCase()}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    if (isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role))
+      continue;
+    await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role, row.agentConfig.desiredState === "running");
+  }
+}
 async function reviveNativeTasks(tasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId) {
   for (const row of listNativeTasksNeedingRevive(tasks, localHealth, now, cooldown)) {
     if (isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role))
       continue;
-    await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
@@ -117742,7 +118285,6 @@ async function wakeStoppedAgentsForPendingTasks(tasks, now, cooldown, runtime4,
   for (const row of listNativePendingTasksNeedingWake(tasks, cooldown, now)) {
     if (isRestartOrchestratorInFlight(row.chatroomId, row.agentConfig.role))
       continue;
-    await clearStuckStoppingSlotIfNeeded(agentMgr, row.chatroomId, row.agentConfig.role);
     const full = await fetchTaskForAction(sessionDeps, machineId, row);
     if (!full)
       continue;
@@ -117759,6 +118301,7 @@ async function processTasksUpdate(runtime4, effectContext2, cooldown, agentMgr,
     getSlot: (chatroomId, role) => agentMgr.getSlot(chatroomId, role),
     isPidAlive: (pid) => isProcessAlive((p) => process.kill(p, 0), pid)
   };
+  await normalizeStuckStoppingSlots(filteredTasks, agentMgr);
   await wakeStoppedAgentsForPendingTasks(filteredTasks, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   await reviveNativeTasks(filteredTasks, localHealth, now, cooldown, runtime4, effectContext2, agentMgr, sessionDeps, machineId);
   if (filteredTasks.length > 0) {
@@ -135494,16 +136037,50 @@ teamCommand.command("set").description("Set the team preset for a chatroom").req
   const { setTeam: setTeam2 } = await Promise.resolve().then(() => (init_team(), exports_team));
   await setTeam2(options.chatroomId, options.team);
 });
-handoffCommandGroup.command("view-template").description("Print the handoff message template for a role pair").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Target role for the handoff").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async (options) => {
+handoffCommandGroup.command("view-template").description("Print the handoff message template for a role pair").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
+  const parentOpts = this.parent?.opts() ?? {};
+  if (!parentOpts.role || !parentOpts.nextRole) {
+    console.error(parentOpts.role ? `error: required option '--next-role <nextRole>' not specified` : `error: required option '--role <role>' not specified`);
+    process.exit(1);
+  }
   const { printHandoffViewTemplate: printHandoffViewTemplate2 } = await Promise.resolve().then(() => (init_view_template3(), exports_view_template));
   try {
-    printHandoffViewTemplate2(options);
+    printHandoffViewTemplate2({
+      role: parentOpts.role,
+      nextRole: parentOpts.nextRole,
+      teamId: options.teamId
+    });
+  } catch (err) {
+    console.error(`❌ ${err.message}`);
+    process.exit(1);
+  }
+});
+handoffCommandGroup.command("list-templates").description("List the role-owned handoff contract and renderable templates (static, no chatroom required)").option("--team-id <teamId>", "Team id (solo, duo); defaults to duo").action(async function(options) {
+  const parentOpts = this.parent?.opts() ?? {};
+  if (!parentOpts.role) {
+    console.error(`error: required option '--role <role>' not specified`);
+    process.exit(1);
+  }
+  const { printHandoffListTemplates: printHandoffListTemplates2 } = await Promise.resolve().then(() => (init_list_templates2(), exports_list_templates));
+  try {
+    printHandoffListTemplates2({ role: parentOpts.role, teamId: options.teamId });
   } catch (err) {
     console.error(`❌ ${err.message}`);
     process.exit(1);
   }
 });
-handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").requiredOption("--role <role>", "Your role").requiredOption("--next-role <nextRole>", "Role to hand off to").action(async (options) => {
+handoffCommandGroup.option("--chatroom-id <id>", "Chatroom identifier").option("--role <role>", "Your role").option("--next-role <nextRole>", "Role to hand off to").action(async (options) => {
+  const missing = [
+    ["--chatroom-id", options.chatroomId],
+    ["--role", options.role],
+    ["--next-role", options.nextRole]
+  ].filter(([, value2]) => !value2);
+  if (missing.length > 0) {
+    const [flag] = missing[0];
+    console.error(`error: required option '${flag} <...>' not specified`);
+    process.exit(1);
+  }
+  const { chatroomId, role, nextRole } = options;
   await maybeRequireAuth();
   const { decode: decode6 } = await Promise.resolve().then(() => exports_decode);
   const stdinContent = await readStdin();
@@ -135522,10 +136099,10 @@ handoffCommandGroup.requiredOption("--chatroom-id <id>", "Chatroom identifier").
     process.exit(1);
   }
   const { handoff: handoff2 } = await Promise.resolve().then(() => (init_handoff(), exports_handoff));
-  await handoff2(options.chatroomId, {
-    role: options.role,
+  await handoff2(chatroomId, {
+    role,
     message,
-    nextRole: options.nextRole
+    nextRole
   });
 });
 var agenticQueryCommand = program2.command("agentic-query").description("Agentic search/ask query commands");
@@ -135907,4 +136484,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=FF0641D1EDD955EA64756E2164756E21
+//# debugId=190F58A249CBBB8164756E2164756E21