@jun133/athlete 0.0.6 → 0.0.7

package/dist/cli.js

@@ -37,7 +37,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@jun133/athlete",
-      version: "0.0.6",
+      version: "0.0.7",
       description: "A global terminal AI coding assistant.",
       keywords: [
         "athlete",
@@ -8376,9 +8376,11 @@ var init_store5 = __esm({
 async function reconcileTeamState(rootDir) {
   const teamStore = new TeamStore(rootDir);
   const taskStore = new TaskStore(rootDir);
+  const executionStore = new ExecutionStore(rootDir);
   const members = await teamStore.listMembers();
   const staleMembers = [];
   const releasedTasks = [];
+  const closedExecutions = [];
   for (const member of members) {
     if (member.status === "shutdown" || typeof member.pid !== "number") {
       continue;
@@ -8389,11 +8391,27 @@ async function reconcileTeamState(rootDir) {
     staleMembers.push(await teamStore.updateMemberStatus(member.name, "shutdown"));
   }
   for (const member of staleMembers) {
+    const runningExecutions = await executionStore.listRelevant({
+      actorName: member.name,
+      profile: "teammate",
+      statuses: ["running"]
+    });
+    for (const execution of runningExecutions) {
+      closedExecutions.push(
+        await executionStore.close(execution.id, {
+          status: "failed",
+          summary: "teammate execution failed after worker exited unexpectedly",
+          output: `Teammate worker '${member.name}' exited unexpectedly before reporting completion.`,
+          statusDetail: "worker_exited_unexpectedly"
+        })
+      );
+    }
     releasedTasks.push(...await taskStore.releaseOwner(member.name));
   }
   return {
     staleMembers,
-    releasedTasks
+    releasedTasks,
+    closedExecutions
   };
 }
 function isProcessAlive2(pid) {
@@ -8409,6 +8427,7 @@ var init_reconcile = __esm({
   "src/team/reconcile.ts"() {
     "use strict";
     import_node_process2 = __toESM(require("process"));
+    init_store3();
     init_store5();
     init_store4();
   }
@@ -21244,6 +21263,86 @@ var init_session2 = __esm({
   }
 });
 
+// src/execution/reconcile.ts
+async function reconcileActiveExecutions(rootDir) {
+  const store = new ExecutionStore(rootDir);
+  const executions = await store.listRelevant({
+    statuses: ["queued", "running"]
+  });
+  const reconciledExecutions = [];
+  for (const execution of executions) {
+    const reconciled = await reconcileExecution(store, execution);
+    if (reconciled) {
+      reconciledExecutions.push(reconciled);
+    }
+  }
+  return {
+    reconciledExecutions
+  };
+}
+async function reconcileExecution(store, execution) {
+  if (execution.launch === "inline") {
+    return failExecution(store, execution, {
+      summary: `${execution.profile} execution failed after the host process exited unexpectedly`,
+      output: `Inline ${execution.profile} execution '${execution.id}' was interrupted because the host process exited before completion.`,
+      statusDetail: "host_exited_unexpectedly"
+    });
+  }
+  if (typeof execution.pid === "number") {
+    if (isProcessAlive3(execution.pid)) {
+      if (execution.status === "queued") {
+        return store.start(execution.id, {
+          pid: execution.pid,
+          sessionId: execution.sessionId,
+          cwd: execution.cwd,
+          worktreeName: execution.worktreeName
+        });
+      }
+      return null;
+    }
+    return failExecution(store, execution, {
+      summary: `${execution.profile} execution failed after worker exited unexpectedly`,
+      output: `Worker-backed ${execution.profile} execution '${execution.id}' exited unexpectedly before reporting completion.`,
+      statusDetail: "worker_exited_unexpectedly"
+    });
+  }
+  return failExecution(store, execution, {
+    summary: `${execution.profile} execution failed because worker launch never completed`,
+    output: `Worker-backed ${execution.profile} execution '${execution.id}' never reached a live worker before the host process exited.`,
+    statusDetail: "worker_never_started"
+  });
+}
+async function failExecution(store, execution, input) {
+  const current = execution.status === "queued" ? await store.start(execution.id, {
+    pid: execution.pid,
+    sessionId: execution.sessionId,
+    cwd: execution.cwd,
+    worktreeName: execution.worktreeName
+  }) : execution;
+  return store.close(current.id, {
+    status: "failed",
+    summary: input.summary,
+    output: input.output,
+    statusDetail: input.statusDetail
+  });
+}
+function isProcessAlive3(pid) {
+  try {
+    import_node_process3.default.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var import_node_process3;
+var init_reconcile2 = __esm({
+  "src/execution/reconcile.ts"() {
+    "use strict";
+    import_node_process3 = __toESM(require("process"));
+    init_store3();
+  }
+});
+
 // src/orchestrator/taskLifecycleShared.ts
 function leadActor() {
   return LEAD_ACTOR;
@@ -22226,6 +22325,7 @@ var init_dispatch = __esm({
 
 // src/orchestrator/progress.ts
 async function loadOrchestratorProgress(input) {
+  await reconcileActiveExecutions(input.rootDir);
   await reconcileTeamState(input.rootDir);
   await reconcileBackgroundJobs(input.rootDir);
   const taskStore = new TaskStore(input.rootDir);
@@ -22306,6 +22406,7 @@ var init_progress2 = __esm({
   "src/orchestrator/progress.ts"() {
     "use strict";
     init_background();
+    init_reconcile2();
     init_store3();
     init_policyStore();
     init_requestStore();
@@ -23001,66 +23102,66 @@ async function terminateKnownProcesses(pids) {
   const terminated = [];
   for (const pid of uniquePids) {
     const killed = await terminateProcessTree(pid);
-    if (killed || !isProcessAlive3(pid)) {
+    if (killed || !isProcessAlive4(pid)) {
       terminated.push(pid);
     }
   }
   return terminated;
 }
-function isProcessAlive3(pid) {
+function isProcessAlive4(pid) {
   if (!Number.isFinite(pid) || pid <= 0) {
     return false;
   }
   try {
-    import_node_process3.default.kill(pid, 0);
+    import_node_process4.default.kill(pid, 0);
     return true;
   } catch {
     return false;
   }
 }
 async function terminateProcessTree(pid) {
-  if (!isProcessAlive3(pid)) {
+  if (!isProcessAlive4(pid)) {
     return false;
   }
-  if (import_node_process3.default.platform === "win32") {
+  if (import_node_process4.default.platform === "win32") {
     await (0, import_execa5.execa)("taskkill", ["/PID", String(pid), "/T", "/F"], {
       reject: false,
       timeout: 1e4,
       windowsHide: true
     }).catch(() => null);
     await waitForProcessExit(pid, 40, 50);
-    return !isProcessAlive3(pid);
+    return !isProcessAlive4(pid);
   }
   try {
-    import_node_process3.default.kill(pid, "SIGTERM");
+    import_node_process4.default.kill(pid, "SIGTERM");
   } catch {
     return false;
   }
   await waitForProcessExit(pid, 20, 50);
-  if (!isProcessAlive3(pid)) {
+  if (!isProcessAlive4(pid)) {
     return true;
   }
   try {
-    import_node_process3.default.kill(pid, "SIGKILL");
+    import_node_process4.default.kill(pid, "SIGKILL");
   } catch {
     return false;
   }
   await waitForProcessExit(pid, 20, 50);
-  return !isProcessAlive3(pid);
+  return !isProcessAlive4(pid);
 }
 async function waitForProcessExit(pid, attempts, delayMs) {
   for (let attempt = 0; attempt < attempts; attempt += 1) {
-    if (!isProcessAlive3(pid)) {
+    if (!isProcessAlive4(pid)) {
       return;
     }
     await new Promise((resolve) => setTimeout(resolve, delayMs));
   }
 }
-var import_node_process3, import_execa5;
+var import_node_process4, import_execa5;
 var init_processControl = __esm({
   "src/utils/processControl.ts"() {
     "use strict";
-    import_node_process3 = __toESM(require("process"));
+    import_node_process4 = __toESM(require("process"));
     import_execa5 = require("execa");
   }
 });
@@ -23093,11 +23194,11 @@ async function collectRunningProcesses(cwd) {
   ];
 }
 async function terminateProcesses(processes) {
-  const terminatedPids = await terminateKnownProcesses(processes.map((process6) => process6.pid));
+  const terminatedPids = await terminateKnownProcesses(processes.map((process8) => process8.pid));
   const terminated = new Set(terminatedPids);
   return {
     terminatedPids,
-    failedPids: processes.map((process6) => process6.pid).filter((pid) => !terminated.has(pid))
+    failedPids: processes.map((process8) => process8.pid).filter((pid) => !terminated.has(pid))
   };
 }
 var defaultInteractiveExitGuard;
@@ -23612,6 +23713,7 @@ async function handleLocalCommand(input, context, output) {
   if (TASKS_COMMANDS.has(normalized) || TEAM_COMMANDS.has(normalized) || BACKGROUND_COMMANDS.has(normalized) || INBOX_COMMANDS.has(normalized) || WORKTREES_COMMANDS.has(normalized)) {
     const projectContext = await loadProjectContext(context.cwd);
     const rootDir = projectContext.stateRootDir;
+    await reconcileActiveExecutions(rootDir).catch(() => null);
     if (TASKS_COMMANDS.has(normalized)) {
       await reconcileTeamState(rootDir).catch(() => null);
       output.plain(await new TaskStore(rootDir).summarize());
@@ -23645,6 +23747,7 @@ var init_localCommands = __esm({
     "use strict";
     init_session2();
     init_background();
+    init_reconcile2();
     init_projectContext();
     init_reset();
     init_store5();
@@ -23680,7 +23783,11 @@ var init_sessionDriver = __esm({
   "src/interaction/sessionDriver.ts"() {
     "use strict";
     init_errors2();
+    init_projectContext();
+    init_background();
+    init_reconcile2();
     init_turn2();
+    init_reconcile();
     init_exitGuard();
     init_localCommands();
     InteractiveSessionDriver = class {
@@ -23693,6 +23800,7 @@ var init_sessionDriver = __esm({
       turnAbortController = null;
       lastInterruptNoticeAt = 0;
       async run() {
+        await this.reconcileInteractiveRuntime();
         const releaseInterrupt = this.options.shell.input.bindInterrupt(() => {
           this.handleInterrupt();
         });
@@ -23716,6 +23824,17 @@ var init_sessionDriver = __esm({
           releaseInterrupt();
         }
       }
+      async reconcileInteractiveRuntime() {
+        try {
+          const projectContext = await loadProjectContext(this.options.cwd);
+          const rootDir = projectContext.stateRootDir;
+          await reconcileActiveExecutions(rootDir);
+          await reconcileTeamState(rootDir);
+          await reconcileBackgroundJobs(rootDir);
+        } catch (error) {
+          this.options.shell.output.warn(`Runtime recovery skipped: ${getErrorMessage(error)}`);
+        }
+      }
       async handleInput(input) {
         let localCommandResult;
         try {
@@ -23755,7 +23874,7 @@ var init_sessionDriver = __esm({
           return "quit";
         }
         this.options.shell.output.warn("Running background processes detected. Exiting now will kill them all.");
-        this.options.shell.output.plain(runningProcesses.map((process6) => process6.summary).join("\n"));
+        this.options.shell.output.plain(runningProcesses.map((process8) => process8.summary).join("\n"));
         const confirmation = await this.options.shell.input.readInput(
           "Kill all running background processes and exit? [y/N] "
         );
@@ -23936,8 +24055,8 @@ var init_output = __esm({
 async function readPersistentInput(promptLabel, onInterrupt) {
   return new Promise((resolve) => {
     const rl = import_node_readline.default.createInterface({
-      input: process.stdin,
-      output: process.stdout,
+      input: import_node_process5.default.stdin,
+      output: import_node_process5.default.stdout,
       terminal: true
     });
     let settled = false;
@@ -23977,8 +24096,8 @@ async function readPersistentInput(promptLabel, onInterrupt) {
 async function readMultilineInput(onInterrupt, promptLabel = "\u2026 ") {
   return new Promise((resolve) => {
     const rl = import_node_readline.default.createInterface({
-      input: process.stdin,
-      output: process.stdout,
+      input: import_node_process5.default.stdin,
+      output: import_node_process5.default.stdout,
       terminal: true
     });
     const lines = [];
@@ -24028,11 +24147,31 @@ async function readMultilineInput(onInterrupt, promptLabel = "\u2026 ") {
 }
 function createReadlineInputPort() {
   const listeners = /* @__PURE__ */ new Set();
+  let releaseProcessInterrupt = null;
   const notifyInterrupt = () => {
     for (const listener of listeners) {
       listener();
     }
   };
+  const ensureProcessInterruptBinding = () => {
+    if (releaseProcessInterrupt) {
+      return;
+    }
+    const handler = () => {
+      notifyInterrupt();
+    };
+    import_node_process5.default.on("SIGINT", handler);
+    releaseProcessInterrupt = () => {
+      import_node_process5.default.off("SIGINT", handler);
+      releaseProcessInterrupt = null;
+    };
+  };
+  const maybeReleaseProcessInterruptBinding = () => {
+    if (listeners.size > 0) {
+      return;
+    }
+    releaseProcessInterrupt?.();
+  };
   return {
     async readInput(promptLabel = "> ") {
       const value = await readPersistentInput(promptLabel, notifyInterrupt);
@@ -24047,17 +24186,20 @@ function createReadlineInputPort() {
     },
     bindInterrupt(handler) {
       listeners.add(handler);
+      ensureProcessInterruptBinding();
       return () => {
         listeners.delete(handler);
+        maybeReleaseProcessInterruptBinding();
       };
     }
   };
 }
-var import_node_readline;
+var import_node_readline, import_node_process5;
 var init_readlineInput = __esm({
   "src/shell/cli/readlineInput.ts"() {
     "use strict";
     import_node_readline = __toESM(require("readline"));
+    import_node_process5 = __toESM(require("process"));
   }
 });
 
@@ -24996,7 +25138,7 @@ async function runAgentExecution(rootDir, config, execution) {
   } : null;
   const store = new ExecutionStore(rootDir);
   await store.start(execution.id, {
-    pid: import_node_process4.default.pid,
+    pid: import_node_process6.default.pid,
     sessionId: session.id,
     cwd: prepared.cwd,
     worktreeName: prepared.worktree?.name
@@ -25050,7 +25192,7 @@ async function runAgentExecution(rootDir, config, execution) {
 async function runCommandExecution(rootDir, execution) {
   const store = new ExecutionStore(rootDir);
   await store.start(execution.id, {
-    pid: import_node_process4.default.pid
+    pid: import_node_process6.default.pid
   });
   try {
     const result = await runCommandWithPolicy({
@@ -25105,7 +25247,7 @@ async function loadAgentSession(rootDir, execution, sessionStore, cwd) {
       "working",
       {
         sessionId: saved.id,
-        pid: import_node_process4.default.pid
+        pid: import_node_process6.default.pid
       }
     );
   }
@@ -25176,11 +25318,11 @@ function readProcessOutput2(error) {
 function isTimedOutError2(error) {
   return Boolean(error.timedOut);
 }
-var import_node_process4;
+var import_node_process6;
 var init_worker = __esm({
   "src/execution/worker.ts"() {
     "use strict";
-    import_node_process4 = __toESM(require("process"));
+    import_node_process6 = __toESM(require("process"));
     init_turn();
     init_runTurn();
     init_session2();
@@ -27254,10 +27396,10 @@ __export(processLock_exports, {
 async function acquireTelegramProcessLock(options) {
   const processId = options.processId ?? process.pid;
   const pidFilePath = import_node_path54.default.join(options.stateDir, "service.pid");
-  const isProcessAlive4 = options.isProcessAlive ?? defaultIsProcessAlive;
+  const isProcessAlive5 = options.isProcessAlive ?? defaultIsProcessAlive;
   await import_promises46.default.mkdir(options.stateDir, { recursive: true });
   const existingPid = await readPidFile(pidFilePath);
-  if (existingPid && existingPid !== processId && await isProcessAlive4(existingPid)) {
+  if (existingPid && existingPid !== processId && await isProcessAlive5(existingPid)) {
     throw new Error(
       `Telegram service already running with PID ${existingPid}. Stop the existing process before starting a new one.`
     );
@@ -29558,10 +29700,10 @@ __export(processLock_exports2, {
 async function acquireWeixinProcessLock(options) {
   const processId = options.processId ?? process.pid;
   const pidFilePath = import_node_path61.default.join(options.stateDir, "service.pid");
-  const isProcessAlive4 = options.isProcessAlive ?? defaultIsProcessAlive2;
+  const isProcessAlive5 = options.isProcessAlive ?? defaultIsProcessAlive2;
   await import_promises52.default.mkdir(options.stateDir, { recursive: true });
   const existingPid = await readPidFile2(pidFilePath);
-  if (existingPid && existingPid !== processId && await isProcessAlive4(existingPid)) {
+  if (existingPid && existingPid !== processId && await isProcessAlive5(existingPid)) {
     throw new Error(`Weixin service already running with PID ${existingPid}. Stop the existing process before starting a new one.`);
   }
   await import_promises52.default.writeFile(pidFilePath, `${processId}