@kenkaiiii/gg-boss 4.3.153 → 4.3.154

package/dist/{chunk-2SKO3MTH.js → chunk-WGJRDNT6.js}

@@ -91403,6 +91403,81 @@ var bossStore = {
 };
 
 // src/worker.ts
+var CONTEXT_OVERFLOW_PATTERNS = [
+  /context_length_exceeded/i,
+  /context length exceeded/i,
+  /context window/i,
+  // OpenAI Codex / Responses
+  /maximum context length/i,
+  // OpenAI / OpenRouter / Mistral
+  /prompt is too long/i,
+  // Anthropic
+  /request_too_large/i,
+  // Anthropic HTTP 413
+  /input is too long/i,
+  // Bedrock
+  /input token count.*exceeds the maximum/i,
+  // Gemini
+  /maximum prompt length/i,
+  // xAI / Grok
+  /reduce the length of the messages/i,
+  // Groq
+  /too large for model/i,
+  // Mistral
+  /token limit/i
+  // generic
+];
+var RATE_LIMIT_PATTERNS2 = [
+  /rate[ _-]?limit/i,
+  /\b429\b/,
+  /too many requests/i,
+  /tokens per minute/i,
+  /requests per minute/i
+];
+var BILLING_PATTERNS = [
+  /insufficient balance/i,
+  /insufficient[ _]quota/i,
+  /quota exceeded/i,
+  /quota_exceeded/i,
+  /credit balance/i,
+  /please recharge/i,
+  /payment required/i,
+  /\b402\b/
+];
+var AUTH_PATTERNS = [
+  /invalid[ _]api[ _]key/i,
+  /unauthorized/i,
+  /\b401\b/,
+  /authentication[ _]failed/i,
+  /please run \/login/i
+  // Anthropic Claude Code-style hint
+];
+function matchesAny(message, patterns) {
+  return patterns.some((p) => p.test(message));
+}
+function classifyWorkerError(message) {
+  if (matchesAny(message, CONTEXT_OVERFLOW_PATTERNS)) {
+    return `[context_overflow] Worker context window exceeded \u2014 the conversation is too large to continue. Recovery: call reset_worker(project) to wipe history, then re-prompt with the task. Re-prompting WITHOUT reset will fail the same way.
+
+Original: ${message}`;
+  }
+  if (matchesAny(message, BILLING_PATTERNS)) {
+    return `[billing] Provider billing/quota issue. Recovery: surface to the user \u2014 they need to top up or switch providers. Do NOT retry.
+
+Original: ${message}`;
+  }
+  if (matchesAny(message, AUTH_PATTERNS)) {
+    return `[auth] Provider authentication failed. Recovery: surface to the user \u2014 they need to re-login. Do NOT retry.
+
+Original: ${message}`;
+  }
+  if (matchesAny(message, RATE_LIMIT_PATTERNS2)) {
+    return `[rate_limited] Provider rate limit hit. Recovery: wait ~30s, then re-prompt the same worker (no reset needed).
+
+Original: ${message}`;
+  }
+  return message;
+}
 function safeBusHandler(workerName, handlerName, fn, onError) {
   return (event) => {
     try {
@@ -91427,10 +91502,19 @@ var Worker = class {
   currentText = "";
   currentTools = [];
   activeTools = /* @__PURE__ */ new Map();
+  /** Parent (orchestrator-wide) signal — fires only on full shutdown. */
+  parentSignal;
+  /** Per-turn AbortController so the boss can cancel one worker mid-flight without taking down the whole pool. */
+  turnAc = null;
+  /** Set true when cancel() fired so the silent-death guard reports "Cancelled by boss" instead of a generic abort error. */
+  wasCancelled = false;
+  startedAt = null;
+  lastEventAt = null;
   constructor(opts) {
     this.name = opts.name;
     this.cwd = opts.cwd;
     this.queue = opts.queue;
+    this.parentSignal = opts.signal;
     this.session = new AgentSession({
       provider: opts.provider,
       model: opts.model,
@@ -91454,10 +91538,44 @@ var Worker = class {
     bossStore.setWorkerStatus(this.name, "working");
     this.currentText = "";
     this.currentTools = [];
-    void this.session.prompt(text).catch((err) => {
-      const message = err instanceof Error ? err.message : String(err);
+    this.activeTools.clear();
+    this.wasCancelled = false;
+    this.startedAt = Date.now();
+    this.lastEventAt = null;
+    const turnAc = new AbortController();
+    this.turnAc = turnAc;
+    const onParentAbort = () => turnAc.abort();
+    if (this.parentSignal.aborted) turnAc.abort();
+    else this.parentSignal.addEventListener("abort", onParentAbort, { once: true });
+    this.session.setSignal(turnAc.signal);
+    void this.session.prompt(text).then(() => {
+      if (this.status === "working") {
+        const message = this.wasCancelled ? "Cancelled by boss." : "Session ended without agent_done \u2014 likely a silently swallowed abort or stream interruption.";
+        const ts = (/* @__PURE__ */ new Date()).toISOString();
+        this.status = "error";
+        this.startedAt = null;
+        log2(
+          this.wasCancelled ? "INFO" : "ERROR",
+          "worker",
+          this.wasCancelled ? "cancelled" : "silent session end",
+          { worker: this.name }
+        );
+        this.queue.removeStuckFor(this.name);
+        bossStore.appendWorkerError(this.name, message, ts);
+        this.queue.push({
+          kind: "worker_error",
+          project: this.name,
+          message,
+          timestamp: ts
+        });
+      }
+    }).catch((err) => {
+      const rawMessage = this.wasCancelled ? "Cancelled by boss." : err instanceof Error ? err.message : String(err);
+      const message = this.wasCancelled ? rawMessage : classifyWorkerError(rawMessage);
       this.status = "error";
+      this.startedAt = null;
       const ts = (/* @__PURE__ */ new Date()).toISOString();
+      this.queue.removeStuckFor(this.name);
       bossStore.appendWorkerError(this.name, message, ts);
       this.queue.push({
         kind: "worker_error",
@@ -91465,8 +91583,64 @@ var Worker = class {
         message,
         timestamp: ts
       });
+    }).finally(() => {
+      this.parentSignal.removeEventListener("abort", onParentAbort);
+      if (this.turnAc === turnAc) this.turnAc = null;
     });
   }
+  /**
+   * Cancel the current turn. Aborts only this worker's per-turn controller —
+   * other workers keep running. The aborted turn surfaces as a `worker_error`
+   * event with message "Cancelled by boss." so the orchestrator clears its
+   * in-flight task entry and the boss is notified.
+   *
+   * Returns true if a turn was actually cancelled.
+   */
+  cancel() {
+    if (this.status !== "working" || !this.turnAc) return false;
+    this.wasCancelled = true;
+    this.turnAc.abort();
+    return true;
+  }
+  /**
+   * Snapshot of the worker's current activity. Cheap to call; safe while the
+   * worker is mid-turn. Used by the boss's get_worker_activity tool to peek
+   * inside a long-running turn without waiting for completion.
+   */
+  getActivity() {
+    const now2 = Date.now();
+    const TEXT_TAIL = 400;
+    const tail = this.currentText.length > TEXT_TAIL ? "\u2026" + this.currentText.slice(-TEXT_TAIL) : this.currentText;
+    return {
+      status: this.status,
+      startedAt: this.startedAt ? new Date(this.startedAt).toISOString() : null,
+      lastEventAt: this.lastEventAt ? new Date(this.lastEventAt).toISOString() : null,
+      workingSeconds: this.startedAt ? Math.floor((now2 - this.startedAt) / 1e3) : 0,
+      silentSeconds: this.lastEventAt ? Math.floor((now2 - this.lastEventAt) / 1e3) : 0,
+      activeTools: [...this.activeTools.values()],
+      completedTools: [...this.currentTools],
+      textTail: tail,
+      lastEventAtMs: this.lastEventAt
+    };
+  }
+  /**
+   * Hard reset: cancel any in-flight turn, wipe conversation history, force
+   * status back to idle. Use when a worker is wedged in `error` or stuck on a
+   * bad context that re-prompting can't recover from.
+   */
+  async reset() {
+    this.cancel();
+    await this.session.newSession();
+    this.turnCount = 0;
+    this.currentText = "";
+    this.currentTools = [];
+    this.activeTools.clear();
+    this.startedAt = null;
+    this.lastEventAt = null;
+    this.wasCancelled = false;
+    this.status = "idle";
+    bossStore.setWorkerStatus(this.name, "idle");
+  }
   async dispose() {
     await this.session.dispose();
   }
@@ -91485,9 +91659,11 @@ var Worker = class {
   }
   wireEvents() {
     const bus = this.session.eventBus;
-    const reportError2 = (message) => {
+    const reportError2 = (rawMessage) => {
       const ts = (/* @__PURE__ */ new Date()).toISOString();
+      const message = classifyWorkerError(rawMessage);
       this.status = "error";
+      this.queue.removeStuckFor(this.name);
       bossStore.appendWorkerError(this.name, message, ts);
       this.queue.push({
         kind: "worker_error",
@@ -91503,6 +91679,7 @@ var Worker = class {
         "text_delta",
         ({ text }) => {
           this.currentText += text;
+          this.lastEventAt = Date.now();
         },
         reportError2
       )
@@ -91514,6 +91691,7 @@ var Worker = class {
         "tool_call_start",
         ({ toolCallId, name }) => {
           this.activeTools.set(toolCallId, name);
+          this.lastEventAt = Date.now();
         },
         reportError2
       )
@@ -91527,6 +91705,7 @@ var Worker = class {
           const name = this.activeTools.get(toolCallId);
           this.activeTools.delete(toolCallId);
           if (name) this.currentTools.push({ name, ok: !isError });
+          this.lastEventAt = Date.now();
         },
         reportError2
       )
@@ -91549,7 +91728,11 @@ var Worker = class {
           };
           this.currentText = "";
           this.currentTools = [];
+          this.activeTools.clear();
+          this.startedAt = null;
+          this.lastEventAt = null;
           this.status = "idle";
+          this.queue.removeStuckFor(this.name);
           bossStore.appendWorkerEvent(summary);
           this.queue.push({ kind: "worker_turn_complete", summary });
         },
@@ -91598,6 +91781,19 @@ var EventQueue = class {
   size() {
     return this.user.length + this.rest.length;
   }
+  /**
+   * Drop any queued `worker_stuck` events for the given project. Called when a
+   * `worker_turn_complete` or `worker_error` fires — the worker is no longer
+   * running, so any pending stuck ping is now stale and would mislead the boss
+   * (e.g. tell it to cancel a worker that already finished).
+   *
+   * Returns the number of events dropped.
+   */
+  removeStuckFor(project) {
+    const before = this.rest.length;
+    this.rest = this.rest.filter((e) => !(e.kind === "worker_stuck" && e.project === project));
+    return before - this.rest.length;
+  }
 };
 
 // src/settings.ts
@@ -91659,6 +91855,7 @@ Every user-role message is one of:
 1. A direct user message \u2014 respond to the user.
 2. \`[event:worker_turn_complete]\` \u2014 a worker finished a turn. Contains project, turn number, tools used (\u2713/\u2717), the worker's final text, AND a trailing \`other_workers:\` line listing every other project's current status (e.g. \`other_workers: B(working) C(idle) D(working)\`).
 3. \`[event:worker_error]\` \u2014 a worker hit an error. Diagnose, then retry or surface to the user. Same \`other_workers:\` trailer.
+4. \`[event:worker_stuck]\` \u2014 a queued ping from the orchestrator's watchdog: a worker has been silent or running unusually long. Includes \`reason\` (silent | long_running), \`working_seconds\`, \`silent_seconds\`, \`active_tools\`, \`completed_this_turn\`, and a \`text_tail\` snippet. The worker is STILL RUNNING \u2014 this is informational, not an error. Decide: wait (most cases), \`cancel_worker\`, or surface. The watchdog won't ping again for the same worker until it emits new activity AND stalls again, so you won't be spammed.
 
 **Always read the \`other_workers:\` trailer before deciding "the run is done".** During a parallel dispatch you receive ONE event per finishing worker, in arrival order. It is wrong to treat the event you're processing as "the last one" unless \`other_workers:\` shows every other worker is \`idle\` (or \`error\`). If any are \`working\`, more events are coming \u2014 finish your routing for THIS event, then wait.
 
@@ -91678,6 +91875,9 @@ Worker dispatch:
 - \`get_worker_status(project)\` \u2014 single-project status check.
 - \`prompt_worker(project, message, fresh?)\` \u2014 send a prompt directly to a worker. FIRE-AND-FORGET. Returns immediately; you'll get \`worker_turn_complete\` later. NEVER call this on a worker whose status is "working".
 - \`get_worker_summary(project)\` \u2014 most recent turn summary. Use to inspect what was actually done.
+- \`get_worker_activity(project)\` \u2014 mid-turn peek: working/silent seconds, active tools, text tail. Use ONLY when a worker has been \`working\` long enough to wonder if it's stuck.
+- \`cancel_worker(project)\` \u2014 abort the current turn. Surfaces as a \`worker_error\` ("Cancelled by boss."). Other workers untouched.
+- \`reset_worker(project)\` \u2014 last resort: cancel + wipe history + force idle. Only when re-prompting can't recover.
 
 Task plan (persistent backlog, visible in the user's Ctrl+T overlay):
 
@@ -91796,6 +91996,30 @@ The worker has full context of its prior turn (you set fresh=false), so don't re
 
 This keeps the loop bounded \u2014 workers don't grind forever on a stuck task.
 
+# Recoverable error tags on worker_error
+
+Worker errors are pre-classified \u2014 the message starts with a tag like \`[context_overflow]\`, \`[rate_limited]\`, \`[billing]\`, or \`[auth]\` when recovery is well-defined. Route off the tag, NOT a generic re-prompt:
+
+- \`[context_overflow]\` \u2014 conversation outgrew the model's window. Call \`reset_worker(project)\` first, THEN re-prompt with the task. Re-prompting without reset fails the same way. Tell the user briefly that you reset.
+- \`[rate_limited]\` \u2014 wait for the next event (~30s of natural delay) or briefly note to user, then re-prompt the same worker. No reset.
+- \`[billing]\` / \`[auth]\` \u2014 surface to the user. Do not retry. The user must fix it.
+- Untagged \u2014 fall back to the normal BLOCKED handling (one corrective re-prompt, then surface).
+
+# Checking on a stuck or slow worker
+
+The orchestrator's watchdog will queue a \`[event:worker_stuck]\` ping if a worker is silent for too long. **It arrives like every other event \u2014 you process it AFTER finishing your current turn.** It does NOT interrupt you. Don't drop what you're doing to chase it; just route it when it's its turn.
+
+When a stuck ping arrives (or you otherwise suspect a hang):
+
+1. The ping itself usually has enough info (\`silent_seconds\`, \`active_tools\`, \`text_tail\`). Only call \`get_worker_activity(project)\` if you need a fresher snapshot \u2014 the ping data may already be 30+ seconds old by the time you read it.
+   - Active tool + recent activity \u2192 it's working, leave it alone. Stay silent or briefly note to the user.
+   - High \`silent_seconds\` with no active tool \u2192 likely a stalled stream. Cancel.
+   - Active \`bash\` for several minutes \u2192 probably a long command (test suite, build). Wait unless the user is impatient.
+2. \`cancel_worker(project)\` if you decide to intervene. A \`worker_error\` arrives; treat it as a normal failed turn (re-prompt with a tighter instruction, or surface to the user).
+3. \`reset_worker(project)\` ONLY if the worker is in \`error\` and re-prompting fails repeatedly, OR its context is clearly poisoned. Reset wipes history \u2014 the worker forgets everything. Always tell the user when you reset.
+
+Don't poll \`get_worker_activity\` \u2014 call it at most once per concern. Don't cancel routinely; the user is mostly fine waiting.
+
 # Style
 
 - Terse with the user. They want results, not narration.
@@ -91859,6 +92083,15 @@ var promptWorkerParams = external_exports.object({
 var getWorkerSummaryParams = external_exports.object({
   project: external_exports.string().describe("Project name as listed by list_workers.")
 });
+var getWorkerActivityParams = external_exports.object({
+  project: external_exports.string().describe("Project name as listed by list_workers.")
+});
+var cancelWorkerParams = external_exports.object({
+  project: external_exports.string().describe("Project name as listed by list_workers.")
+});
+var resetWorkerParams = external_exports.object({
+  project: external_exports.string().describe("Project name as listed by list_workers.")
+});
 function createBossTools(deps) {
   const { workers, lastSummaries } = deps;
   const listWorkers = {
@@ -91921,7 +92154,58 @@ Final text:
 ${summary.finalText || "(empty)"}`;
     }
   };
-  return [listWorkers, getWorkerStatus, promptWorker, getWorkerSummary];
+  const getWorkerActivity = {
+    name: "get_worker_activity",
+    description: "Peek at what a worker is doing RIGHT NOW (mid-turn). Returns working/silent durations in seconds, currently-running tool names, completed tools so far, and the tail of its streamed text. Use this when a worker has been `working` for a long time to decide whether it's making progress, hung, or worth cancelling.",
+    parameters: getWorkerActivityParams,
+    execute(args) {
+      const w = workers.get(args.project);
+      if (!w) return `Unknown project: ${args.project}`;
+      const a = w.getActivity();
+      const lines = [
+        `Project: ${args.project}`,
+        `Status: ${a.status}`,
+        `Working: ${a.workingSeconds}s (last event ${a.silentSeconds}s ago)`,
+        `Active tools: ${a.activeTools.length > 0 ? a.activeTools.join(", ") : "(none)"}`,
+        `Completed this turn: ${a.completedTools.length > 0 ? a.completedTools.map((t) => `${t.ok ? "\u2713" : "\u2717"}${t.name}`).join(", ") : "(none)"}`,
+        "",
+        "Text tail:",
+        a.textTail || "(no text yet)"
+      ];
+      return lines.join("\n");
+    }
+  };
+  const cancelWorker = {
+    name: "cancel_worker",
+    description: "Abort a worker's current turn. Other workers are untouched. The cancelled worker emits a `worker_error` event with message 'Cancelled by boss.' so any in-flight task is cleared. After cancelling, you can re-prompt or reset the worker. No-op if the worker isn't `working`.",
+    parameters: cancelWorkerParams,
+    execute(args) {
+      const w = workers.get(args.project);
+      if (!w) return `Unknown project: ${args.project}`;
+      const cancelled = w.cancel();
+      return cancelled ? `Cancellation requested for "${args.project}". A worker_error event will arrive shortly.` : `Worker "${args.project}" is not working \u2014 nothing to cancel (status: ${w.getStatus()}).`;
+    }
+  };
+  const resetWorker = {
+    name: "reset_worker",
+    description: "Hard reset: cancel any in-flight turn, wipe conversation history, force status back to idle. Use as a last resort when a worker is wedged in `error` or its context is so polluted that re-prompting won't recover. Equivalent to `fresh: true` plus a forced unstuck. After reset, the worker is ready for a new prompt_worker call.",
+    parameters: resetWorkerParams,
+    async execute(args) {
+      const w = workers.get(args.project);
+      if (!w) return `Unknown project: ${args.project}`;
+      await w.reset();
+      return `Worker "${args.project}" reset \u2014 status is idle, history wiped.`;
+    }
+  };
+  return [
+    listWorkers,
+    getWorkerStatus,
+    promptWorker,
+    getWorkerSummary,
+    getWorkerActivity,
+    cancelWorker,
+    resetWorker
+  ];
 }
 
 // src/task-tools.ts
@@ -92553,6 +92837,9 @@ async function getSessionById(id2) {
 }
 
 // src/orchestrator.ts
+var WATCHDOG_INTERVAL_MS = 3e4;
+var SILENT_THRESHOLD_SEC = 90;
+var WORKING_THRESHOLD_SEC = 600;
 var GGBoss = class {
   workers = /* @__PURE__ */ new Map();
   lastSummaries = /* @__PURE__ */ new Map();
@@ -92591,6 +92878,23 @@ var GGBoss = class {
    * message that didn't dispatch any workers.
    */
   hadWorkerActivitySinceReady = false;
+  /**
+   * Watchdog for stuck workers. Fires every WATCHDOG_INTERVAL_MS; if any
+   * "working" worker has been silent past SILENT_THRESHOLD_SEC or running
+   * past WORKING_THRESHOLD_SEC, push a `worker_stuck` event onto the queue.
+   * The boss processes it like any other event — AFTER its current turn
+   * (queue is FIFO, boss is single-event-at-a-time), so this never
+   * interrupts an in-flight boss turn.
+   */
+  watchdogTimer = null;
+  /**
+   * Per-project debounce. Stores the worker's lastEventAtMs at the moment we
+   * pushed the stuck event. If the worker's lastEventAt advances past that,
+   * we know the worker recovered (emitted a new event), so we clear the entry
+   * and become eligible to fire again on the next stall. Also cleared on
+   * worker_turn_complete / worker_error.
+   */
+  stuckPushedAt = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.opts = opts;
   }
@@ -92884,6 +93188,7 @@ var GGBoss = class {
   }
   async run() {
     this.running = true;
+    this.startWatchdog();
     while (this.running) {
       try {
         await this.runIteration();
@@ -92906,6 +93211,7 @@ var GGBoss = class {
     }
     let finishedTaskId = null;
     if (event.kind === "worker_turn_complete") {
+      this.stuckPushedAt.delete(event.summary.project);
       void playDoneAudio();
       this.hadWorkerActivitySinceReady = true;
       this.lastSummaries.set(event.summary.project, event.summary);
@@ -92935,6 +93241,7 @@ var GGBoss = class {
     }
     if (event.kind === "worker_error") {
       this.hadWorkerActivitySinceReady = true;
+      this.stuckPushedAt.delete(event.project);
       log2("ERROR", "worker_error", event.message, { project: event.project });
       const taskId = this.inFlightTaskByProject.get(event.project);
       if (taskId) {
@@ -92945,6 +93252,14 @@ var GGBoss = class {
         });
       }
     }
+    if (event.kind === "worker_stuck") {
+      log2("WARN", "worker_stuck", `worker silent\u2014pinging boss`, {
+        project: event.project,
+        reason: event.reason,
+        silentSeconds: event.snapshot.silentSeconds,
+        workingSeconds: event.snapshot.workingSeconds
+      });
+    }
     await this.runCompaction(false);
     const workerSnapshot = [...this.workers.entries()].map(([name, w]) => ({
       name,
@@ -93052,8 +93367,62 @@ var GGBoss = class {
     await this.dispatchTaskByDescription(project, next.description, next.fresh === true, next.id);
     this.pendingAutoChainNotices.push({ project, title: next.title });
   }
+  /**
+   * Start the stuck-worker watchdog. Idempotent.
+   *
+   * Safety properties:
+   *  - Pushes onto the same FIFO queue the boss already drains, so the boss
+   *    never gets interrupted mid-turn — stuck pings are processed AFTER
+   *    whatever it's currently doing.
+   *  - Per-worker debounce (`stuckPushedAt`) prevents spam; a worker only
+   *    gets re-flagged after it emits a new event AND stalls again, or after
+   *    it completes/errors and stalls on a fresh turn.
+   */
+  startWatchdog() {
+    if (this.watchdogTimer) return;
+    this.watchdogTimer = setInterval(() => {
+      try {
+        this.checkStuckWorkers();
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        log2("ERROR", "watchdog", "tick threw", { message });
+      }
+    }, WATCHDOG_INTERVAL_MS);
+    this.watchdogTimer.unref?.();
+  }
+  stopWatchdog() {
+    if (this.watchdogTimer) {
+      clearInterval(this.watchdogTimer);
+      this.watchdogTimer = null;
+    }
+  }
+  checkStuckWorkers() {
+    for (const [name, worker] of this.workers) {
+      const decision = decideStuckEvent({
+        status: worker.getStatus(),
+        activity: worker.getStatus() === "working" ? worker.getActivity() : null,
+        lastPushedAt: this.stuckPushedAt.has(name) ? this.stuckPushedAt.get(name) ?? null : void 0,
+        silentThresholdSec: SILENT_THRESHOLD_SEC,
+        workingThresholdSec: WORKING_THRESHOLD_SEC
+      });
+      if (decision.kind === "clear_debounce") {
+        this.stuckPushedAt.delete(name);
+        continue;
+      }
+      if (decision.kind === "skip") continue;
+      this.stuckPushedAt.set(name, decision.lastEventAtMs);
+      this.queue.push({
+        kind: "worker_stuck",
+        project: name,
+        reason: decision.reason,
+        snapshot: decision.snapshot,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
   async dispose() {
     this.running = false;
+    this.stopWatchdog();
     this.ac.abort();
     this.queue.push({
       kind: "user_message",
@@ -93078,6 +93447,37 @@ function reportedToTaskStatus(reported, anyToolFailed) {
   if (reported === "UNVERIFIED" || reported === "PARTIAL") return "in_progress";
   return anyToolFailed ? "blocked" : "done";
 }
+function decideStuckEvent(input) {
+  const { status, activity, lastPushedAt, silentThresholdSec, workingThresholdSec } = input;
+  if (status !== "working" || !activity) {
+    return lastPushedAt !== void 0 ? { kind: "clear_debounce" } : { kind: "skip" };
+  }
+  if (lastPushedAt !== void 0) {
+    const lastEvent = activity.lastEventAtMs;
+    if (lastEvent === null || lastPushedAt === null || lastEvent <= lastPushedAt) {
+      return { kind: "skip" };
+    }
+  }
+  let reason = null;
+  if (activity.lastEventAtMs !== null && activity.silentSeconds >= silentThresholdSec) {
+    reason = "silent";
+  } else if (activity.workingSeconds >= workingThresholdSec) {
+    reason = "long_running";
+  }
+  if (!reason) return { kind: "skip" };
+  return {
+    kind: "push",
+    reason,
+    lastEventAtMs: activity.lastEventAtMs,
+    snapshot: {
+      workingSeconds: activity.workingSeconds,
+      silentSeconds: activity.silentSeconds,
+      activeTools: activity.activeTools,
+      completedTools: activity.completedTools,
+      textTail: activity.textTail
+    }
+  };
+}
 function formatEventForBoss(event, workerSnapshot, autoChainNotices) {
   if (event.kind === "user_message") {
     return event.text;
@@ -93095,15 +93495,27 @@ auto_dispatched_since_last_event:
 ${lines.join("\n")}`;
   };
   if (event.kind === "worker_turn_complete") {
-    const s = event.summary;
-    const tools = s.toolsUsed.length > 0 ? s.toolsUsed.map((t) => `${t.ok ? "\u2713" : "\u2717"}${t.name}`).join(", ") : "(none)";
-    return `[event:worker_turn_complete] project="${s.project}" turn=${s.turnIndex} timestamp=${s.timestamp}
+    const s2 = event.summary;
+    const tools = s2.toolsUsed.length > 0 ? s2.toolsUsed.map((t) => `${t.ok ? "\u2713" : "\u2717"}${t.name}`).join(", ") : "(none)";
+    return `[event:worker_turn_complete] project="${s2.project}" turn=${s2.turnIndex} timestamp=${s2.timestamp}
 tools_used: ${tools}
 final_text:
-${s.finalText || "(empty)"}${renderOthers(s.project)}${renderAutoChain()}`;
+${s2.finalText || "(empty)"}${renderOthers(s2.project)}${renderAutoChain()}`;
   }
-  return `[event:worker_error] project="${event.project}" timestamp=${event.timestamp}
+  if (event.kind === "worker_error") {
+    return `[event:worker_error] project="${event.project}" timestamp=${event.timestamp}
 ${event.message}${renderOthers(event.project)}${renderAutoChain()}`;
+  }
+  const s = event.snapshot;
+  const completed = s.completedTools.length > 0 ? s.completedTools.map((t) => `${t.ok ? "\u2713" : "\u2717"}${t.name}`).join(", ") : "(none)";
+  const active = s.activeTools.length > 0 ? s.activeTools.join(", ") : "(none)";
+  return `[event:worker_stuck] project="${event.project}" reason=${event.reason} timestamp=${event.timestamp}
+working_seconds: ${s.workingSeconds}
+silent_seconds: ${s.silentSeconds}
+active_tools: ${active}
+completed_this_turn: ${completed}
+text_tail:
+${s.textTail || "(no text yet)"}${renderOthers(event.project)}${renderAutoChain()}`;
 }
 function computeContextUsed(usage, provider) {
   const inputContext = (usage.inputTokens ?? 0) + (usage.cacheRead ?? 0) + (usage.cacheWrite ?? 0);
@@ -93293,4 +93705,4 @@ react/cjs/react-jsx-runtime.development.js:
    * LICENSE file in the root directory of this source tree.
    *)
 */
-//# sourceMappingURL=chunk-2SKO3MTH.js.map
+//# sourceMappingURL=chunk-WGJRDNT6.js.map