chatroom-cli 1.96.1 → 1.97.0

package/dist/index.js

@@ -98898,7 +98898,15 @@ var init_team_agent_settings = __esm(() => {
 });
 
 // ../../services/backend/src/domain/handoff/parse-session-augmentation.ts
-function resolveSessionAugmentationForRole(_handoffContent, role) {
+function resolveSessionAugmentationForTask(task, role) {
+  if (task.startInNewSession !== undefined)
+    return task.startInNewSession ? "new_session" : "none";
+  return resolveSessionAugmentationForRole(role);
+}
+function shouldEmitSessionAugmentation(role, mode) {
+  return roleSupportsSessionAugmentation(role) || mode === "new_session";
+}
+function resolveSessionAugmentationForRole(role) {
   if (!roleSupportsSessionAugmentation(role))
     return "none";
   return "new_session";
@@ -98913,6 +98921,71 @@ var init_parse_session_augmentation = __esm(() => {
   init_team_agent_settings();
 });
 
+// src/daemon/entry/native-delivery/native-cold-session-before-inject.ts
+function sleep5(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+async function waitForHarnessSessionId(agentMgr, chatroomId, role) {
+  const deadline = Date.now() + HARNESS_SESSION_READY_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    const id3 = agentMgr.getSlot(chatroomId, role)?.harnessSessionId;
+    if (id3)
+      return id3;
+    await sleep5(100);
+  }
+  return null;
+}
+async function ensureColdSessionBeforeNativeInject(task, deps) {
+  if (!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: "platform.task_start_in_new_session"
+  });
+  const spawn3 = await deps.agentMgr.ensureRunning({
+    chatroomId,
+    role,
+    agentHarness,
+    model,
+    workingDir,
+    reason: "platform.task_start_in_new_session",
+    wantResume: false
+  });
+  if (!spawn3.success)
+    return null;
+  const harnessSessionId = await waitForHarnessSessionId(deps.agentMgr, chatroomId, role);
+  if (!harnessSessionId)
+    return null;
+  await deps.backend.mutation(api.participants.join, {
+    sessionId: deps.sessionId,
+    chatroomId,
+    role,
+    action: NATIVE_WAITING_ACTION,
+    taskId
+  });
+  await deps.backend.mutation(api.machines.emitSessionAugmented, {
+    sessionId: deps.sessionId,
+    machineId: deps.machineId,
+    chatroomId,
+    role,
+    taskId,
+    mode: "new_session",
+    newSessionStarted: true,
+    harnessSessionId
+  });
+  return harnessSessionId;
+}
+var init_native_cold_session_before_inject = __esm(() => {
+  init_reliability();
+  init_participant();
+  init_api3();
+});
+
 // src/daemon/entry/native-delivery/native-task-injector.ts
 async function emitTaskDeliveryFailed(deps, args2) {
   try {
@@ -98926,35 +98999,132 @@ async function emitTaskDeliveryFailed(deps, args2) {
     });
   } catch {}
 }
-function runNativeInjectionEffect(task, harnessSessionId, deps) {
+function reportDeliveryFailureEffect(deps, args2) {
+  return exports_Effect.tryPromise({
+    try: () => emitTaskDeliveryFailed(deps, args2),
+    catch: () => {
+      return;
+    }
+  }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+}
+function applyColdSessionIfRequested(task, deps, chatroomId, role, taskId) {
+  return exports_Effect.gen(function* () {
+    const coldSessionResult = yield* exports_Effect.tryPromise({
+      try: () => ensureColdSessionBeforeNativeInject(task, deps),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (coldSessionResult._tag === "Left" || !coldSessionResult.right) {
+      const error51 = coldSessionResult._tag === "Left" ? getErrorMessage(coldSessionResult.left) : "cold session restart failed";
+      yield* reportDeliveryFailureEffect(deps, {
+        chatroomId,
+        role,
+        taskId,
+        error: error51
+      });
+      return { failed: true, error: error51 };
+    }
+    return { harnessSessionId: coldSessionResult.right };
+  });
+}
+function claimPendingTaskIfNeeded(task, deps) {
   return exports_Effect.gen(function* () {
-    const { chatroomId, taskId, taskContent, agentConfig, status: status3 } = task;
+    if (task.status !== "pending")
+      return;
+    const { chatroomId, taskId, agentConfig } = task;
     const { role } = agentConfig;
-    if (status3 === "pending") {
-      const claimResult = yield* exports_Effect.tryPromise({
-        try: () => deps.backend.mutation(api.tasks.claimTask, {
-          sessionId: deps.sessionId,
-          chatroomId,
-          role,
-          taskId
-        }),
-        catch: (err) => err
-      }).pipe(exports_Effect.either);
-      if (claimResult._tag === "Left") {
-        yield* exports_Effect.tryPromise({
-          try: () => emitTaskDeliveryFailed(deps, {
-            chatroomId,
-            role,
-            taskId,
-            error: getErrorMessage(claimResult.left)
-          }),
-          catch: () => {
-            return;
-          }
-        }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-        return yield* exports_Effect.fail(claimResult.left);
-      }
+    const claimResult = yield* exports_Effect.tryPromise({
+      try: () => deps.backend.mutation(api.tasks.claimTask, {
+        sessionId: deps.sessionId,
+        chatroomId,
+        role,
+        taskId
+      }),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (claimResult._tag === "Left") {
+      yield* reportDeliveryFailureEffect(deps, {
+        chatroomId,
+        role,
+        taskId,
+        error: getErrorMessage(claimResult.left)
+      });
+      return yield* exports_Effect.fail(claimResult.left);
+    }
+  });
+}
+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 coldSession = yield* applyColdSessionIfRequested(task, deps, chatroomId, role, taskId);
+    if ("failed" in coldSession) {
+      return yield* exports_Effect.fail(new Error(coldSession.error));
+    }
+    return {
+      harnessSessionId: coldSession.harnessSessionId,
+      sessionAugmentationEmitted: true
+    };
+  });
+}
+function emitSessionAugmentationIfNeeded(task, deps, harnessSessionId, sessionAugmentationEmitted, augmentationMode) {
+  const { chatroomId, taskId, agentConfig } = task;
+  const { role } = agentConfig;
+  if (!shouldEmitSessionAugmentation(role, augmentationMode) || sessionAugmentationEmitted) {
+    return exports_Effect.void;
+  }
+  return exports_Effect.tryPromise({
+    try: () => deps.backend.mutation(api.machines.emitSessionAugmented, {
+      sessionId: deps.sessionId,
+      machineId: deps.machineId,
+      chatroomId,
+      role,
+      taskId,
+      mode: augmentationMode,
+      newSessionStarted: sessionAugmentationNewSessionStarted(augmentationMode),
+      harnessSessionId
+    }),
+    catch: (err) => err
+  }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+}
+function resumeHarnessWithPrompt(task, deps, prompt) {
+  return exports_Effect.gen(function* () {
+    const { chatroomId, taskId, agentConfig } = task;
+    const { role } = agentConfig;
+    const resumeResult = yield* exports_Effect.tryPromise({
+      try: () => deps.agentMgr.resumeTurnForSlot({ chatroomId, role, prompt }),
+      catch: (err) => err
+    }).pipe(exports_Effect.either);
+    if (resumeResult._tag === "Left") {
+      const error51 = getErrorMessage(resumeResult.left);
+      console.warn(`[NativeTaskInjector] resumeTurn failed for ${role}@${chatroomId}: ${error51}`);
+      yield* reportDeliveryFailureEffect(deps, {
+        chatroomId,
+        role,
+        taskId,
+        error: error51
+      });
+      return;
     }
+    yield* exports_Effect.tryPromise({
+      try: () => deps.backend.mutation(api.machines.emitTaskDelivered, {
+        sessionId: deps.sessionId,
+        machineId: deps.machineId,
+        chatroomId,
+        role,
+        taskId
+      }),
+      catch: (err) => err
+    }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+    deps.onTaskDelivered?.({ chatroomId, role, taskId });
+  });
+}
+function loadNativeInjectionPrompt(task, deps) {
+  return exports_Effect.gen(function* () {
+    const { chatroomId, taskId, taskContent, agentConfig } = task;
+    const { role } = agentConfig;
     const deliveryResult = yield* exports_Effect.tryPromise({
       try: () => deps.backend.query(api.messages.getTaskDeliveryPrompt, {
         sessionId: deps.sessionId,
@@ -98966,25 +99136,29 @@ function runNativeInjectionEffect(task, harnessSessionId, deps) {
       catch: (err) => err
     }).pipe(exports_Effect.either);
     if (deliveryResult._tag === "Left") {
-      yield* exports_Effect.tryPromise({
-        try: () => emitTaskDeliveryFailed(deps, {
-          chatroomId,
-          role,
-          taskId,
-          error: getErrorMessage(deliveryResult.left)
-        }),
-        catch: () => {
-          return;
-        }
-      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
+      yield* reportDeliveryFailureEffect(deps, {
+        chatroomId,
+        role,
+        taskId,
+        error: getErrorMessage(deliveryResult.left)
+      });
       return yield* exports_Effect.fail(deliveryResult.left);
     }
-    const delivery = deliveryResult.right;
-    const augmentationMode = resolveSessionAugmentationForRole(taskContent, role);
-    const prompt = buildNativeInjectionPrompt({
-      taskDeliveryOutput: delivery.fullCliOutput,
-      augmentationMode
-    });
+    const augmentationMode = resolveSessionAugmentationForTask({ content: taskContent, startInNewSession: task.startInNewSession }, role);
+    return {
+      augmentationMode,
+      prompt: buildNativeInjectionPrompt({
+        taskDeliveryOutput: deliveryResult.right.fullCliOutput,
+        augmentationMode
+      })
+    };
+  });
+}
+function injectNativeTaskPrompt(task, deps, harnessSessionId, sessionAugmentationEmitted) {
+  return exports_Effect.gen(function* () {
+    const { chatroomId, taskId, agentConfig } = task;
+    const { role } = agentConfig;
+    const { prompt, augmentationMode } = yield* loadNativeInjectionPrompt(task, deps);
     yield* exports_Effect.tryPromise({
       try: () => deps.backend.mutation(api.participants.join, {
         sessionId: deps.sessionId,
@@ -99006,59 +99180,22 @@ function runNativeInjectionEffect(task, harnessSessionId, deps) {
       }),
       catch: (err) => err
     });
-    if (roleSupportsSessionAugmentation(role)) {
-      yield* exports_Effect.tryPromise({
-        try: () => deps.backend.mutation(api.machines.emitSessionAugmented, {
-          sessionId: deps.sessionId,
-          machineId: deps.machineId,
-          chatroomId,
-          role,
-          taskId,
-          mode: augmentationMode,
-          newSessionStarted: sessionAugmentationNewSessionStarted(augmentationMode),
-          harnessSessionId
-        }),
-        catch: (err) => err
-      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-    }
-    const resumeResult = yield* exports_Effect.tryPromise({
-      try: () => deps.agentMgr.resumeTurnForSlot({ chatroomId, role, prompt }),
-      catch: (err) => err
-    }).pipe(exports_Effect.either);
-    if (resumeResult._tag === "Left") {
-      const error51 = getErrorMessage(resumeResult.left);
-      console.warn(`[NativeTaskInjector] resumeTurn failed for ${role}@${chatroomId}: ${error51}`);
-      yield* exports_Effect.tryPromise({
-        try: () => emitTaskDeliveryFailed(deps, {
-          chatroomId,
-          role,
-          taskId,
-          error: error51
-        }),
-        catch: () => {
-          return;
-        }
-      }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-      return;
-    }
-    yield* exports_Effect.tryPromise({
-      try: () => deps.backend.mutation(api.machines.emitTaskDelivered, {
-        sessionId: deps.sessionId,
-        machineId: deps.machineId,
-        chatroomId,
-        role,
-        taskId
-      }),
-      catch: (err) => err
-    }).pipe(exports_Effect.catchAll(() => exports_Effect.void));
-    deps.onTaskDelivered?.({ chatroomId, role, taskId });
+    yield* emitSessionAugmentationIfNeeded(task, deps, harnessSessionId, sessionAugmentationEmitted, augmentationMode);
+    yield* resumeHarnessWithPrompt(task, deps, prompt);
+  });
+}
+function runNativeInjectionEffect(task, initialHarnessSessionId, deps) {
+  return exports_Effect.gen(function* () {
+    yield* claimPendingTaskIfNeeded(task, deps);
+    const session2 = yield* resolveHarnessSessionForInject(task, deps, initialHarnessSessionId);
+    yield* injectNativeTaskPrompt(task, deps, session2.harnessSessionId, session2.sessionAugmentationEmitted);
   });
 }
 var init_native_task_injector = __esm(() => {
   init_participant();
-  init_team_agent_settings();
   init_parse_session_augmentation();
   init_esm();
+  init_native_cold_session_before_inject();
   init_native_task_injector_logic();
   init_api3();
   init_convex_error();
@@ -99089,7 +99226,8 @@ function mapAssignedTaskSnapshot(row) {
 function mapAssignedTaskView(row) {
   return {
     ...mapAssignedTaskSnapshot(row),
-    taskContent: row.taskContent
+    taskContent: row.taskContent,
+    startInNewSession: row.startInNewSession
   };
 }
 function mapAssignedTaskSnapshotList(rows) {
@@ -99288,7 +99426,10 @@ class NativeTaskDeliveryCoordinator {
           machineId: sessionDeps.machineId,
           backend: sessionDeps.backend,
           agentMgr: {
-            resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2))
+            resumeTurnForSlot: (args2) => exports_Effect.runPromise(agentMgr.resumeTurnForSlot(args2)),
+            stop: (opts) => exports_Effect.runPromise(agentMgr.stop(opts)),
+            ensureRunning: (opts) => exports_Effect.runPromise(agentMgr.ensureRunning(opts)),
+            getSlot: (chatroomId, role2) => agentMgr.getSlot(chatroomId, role2)
           },
           convexUrl: sessionDeps.convexUrl,
           onTaskDelivered: ({ chatroomId, role: role2, taskId: deliveredTaskId }) => {
@@ -99363,10 +99504,10 @@ async function emitPhase(deps, event, phase, detail) {
     detail
   });
 }
-function sleep5(ms) {
+function sleep6(ms) {
   return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
-async function waitForHarnessSessionId(deps, event, pid) {
+async function waitForHarnessSessionId2(deps, event, pid) {
   const initial = deps.agentMgr.getSlot(event.chatroomId, event.role);
   if (initial?.harnessSessionId) {
     return initial.harnessSessionId;
@@ -99377,7 +99518,7 @@ async function waitForHarnessSessionId(deps, event, pid) {
     if (slot?.harnessSessionId) {
       return slot.harnessSessionId;
     }
-    await sleep5(100);
+    await sleep6(100);
   }
   await deps.agentMgr.stop({
     chatroomId: event.chatroomId,
@@ -99443,7 +99584,10 @@ async function deliverOneTask(deps, event, snapshot) {
       agentMgr: {
         resumeTurnForSlot: async (args2) => {
           await exports_Effect.runPromise(deps.agentMgr.resumeTurnForSlot(args2));
-        }
+        },
+        stop: (opts) => exports_Effect.runPromise(deps.agentMgr.stop(opts)),
+        ensureRunning: (opts) => exports_Effect.runPromise(deps.agentMgr.ensureRunning(opts)),
+        getSlot: (chatroomId, role) => deps.agentMgr.getSlot(chatroomId, role)
       },
       onTaskDelivered: ({ chatroomId, role, taskId }) => {
         deliveredToHarness = true;
@@ -99500,7 +99644,7 @@ async function runRestartOrchestrator(deps, event) {
       return;
     }
     await emitPhase(deps, event, "await_session");
-    const harnessSessionId = await waitForHarnessSessionId(deps, event, spawnResult.pid);
+    const harnessSessionId = await waitForHarnessSessionId2(deps, event, spawnResult.pid);
     if (!harnessSessionId) {
       await emitPhase(deps, event, "failed", "harnessSessionId timeout");
       return;
@@ -99764,7 +99908,7 @@ function logWaitingForShutdown(pid) {
 function logDaemonAlreadyRunning(pid) {
   console.error(`❌ Daemon already running for ${getConvexUrl()} (PID: ${pid})`);
 }
-async function waitForLockOrTimeout(deadline, intervalMs, sleep6) {
+async function waitForLockOrTimeout(deadline, intervalMs, sleep7) {
   let loggedWait = false;
   while (Date.now() < deadline) {
     if (tryAcquireLock()) {
@@ -99775,16 +99919,16 @@ async function waitForLockOrTimeout(deadline, intervalMs, sleep6) {
       logWaitingForShutdown(pid);
       loggedWait = true;
     }
-    await sleep6(intervalMs);
+    await sleep7(intervalMs);
   }
   return false;
 }
 async function acquireLockWithRetry(options) {
   const intervalMs = options?.intervalMs ?? LOCK_RETRY_INTERVAL_MS;
   const maxWaitMs = options?.maxWaitMs ?? LOCK_RETRY_MAX_WAIT_MS;
-  const sleep6 = options?.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
+  const sleep7 = options?.sleep ?? ((ms) => new Promise((resolve4) => setTimeout(resolve4, ms)));
   const deadline = Date.now() + maxWaitMs;
-  if (await waitForLockOrTimeout(deadline, intervalMs, sleep6)) {
+  if (await waitForLockOrTimeout(deadline, intervalMs, sleep7)) {
     return true;
   }
   const { pid } = isDaemonRunning();
@@ -113937,13 +114081,13 @@ var init_task_monitor_logic = __esm(() => {
 
 // src/daemon/entry/task-monitor-runtime.ts
 function resolveTaskWantResume(task) {
-  return sessionAugmentationToWantResume(resolveSessionAugmentationForRole(task.taskContent ?? "", task.agentConfig.role));
+  return sessionAugmentationToWantResume(resolveSessionAugmentationForTask({ content: task.taskContent ?? "", startInNewSession: task.startInNewSession }, task.agentConfig.role));
 }
 function buildCliNudgeLogLine(task) {
   const { chatroomId, agentConfig } = task;
   const { role } = agentConfig;
   const lastSeenAction = task.participant?.lastSeenAction ?? "unknown";
-  const augmentationMode = resolveSessionAugmentationForRole(task.taskContent ?? "", role);
+  const augmentationMode = resolveSessionAugmentationForTask({ content: task.taskContent ?? "", startInNewSession: task.startInNewSession }, role);
   const wantResume = resolveTaskWantResume(task);
   return `[TaskMonitor] nudging ${role}@${chatroomId} — pending task ${task.taskId}, lastSeenAction=${lastSeenAction}, session_augmentation=${augmentationMode}, wantResume=${wantResume}`;
 }
@@ -113966,7 +114110,7 @@ function executeCliNudge(task, runtime4, effectContext2, agentMgr, sessionDeps,
   if (!ctx)
     return;
   const { chatroomId, agentConfig, role, workingDir, wantResume } = ctx;
-  const augmentationMode = resolveSessionAugmentationForRole(task.taskContent ?? "", role);
+  const augmentationMode = resolveSessionAugmentationForTask({ content: task.taskContent ?? "", startInNewSession: task.startInNewSession }, role);
   exports_Runtime.runFork(runtime4)(exports_Effect.gen(function* () {
     yield* agentMgr.stop({ chatroomId, role, reason: "platform.task_monitor_nudge" });
     yield* agentMgr.ensureRunning({
@@ -113978,7 +114122,7 @@ function executeCliNudge(task, runtime4, effectContext2, agentMgr, sessionDeps,
       reason: "platform.task_monitor_nudge",
       wantResume
     });
-    if (roleSupportsSessionAugmentation(role)) {
+    if (shouldEmitSessionAugmentation(role, augmentationMode)) {
       yield* exports_Effect.tryPromise({
         try: () => sessionDeps.backend.mutation(api.machines.emitSessionAugmented, {
           sessionId: sessionDeps.sessionId,
@@ -114223,7 +114367,7 @@ var startTaskMonitorEffect = (wsClient2) => exports_Effect.gen(function* () {
 var init_task_monitor_runtime = __esm(() => {
   init_reliability();
   init_participant();
-  init_team_agent_settings();
+  init_parse_session_augmentation();
   init_parse_session_augmentation();
   init_assigned_task_monitor_contract();
   init_esm();
@@ -129009,4 +129153,4 @@ program2.hook("preAction", async (_thisCommand, actionCommand) => {
 });
 program2.parse();
 
-//# debugId=BCEF43321DDB187C64756E2164756E21
+//# debugId=8169BF8DA0BD25A464756E2164756E21