pi-extended-teams 2.4.2 → 2.5.0

package/docs/reference.md

@@ -104,6 +104,24 @@ Public spawns respect each role's concurrency limit. Enabled overflow queues acc
 
 Spawned sessions are private by default under `~/.pi/teams/<team>/agent-sessions/`, outside Pi's normal `/resume` picker.
 
+### Idle watchdog
+
+The runtime checks agents every 30 seconds. After five idle minutes it sends the lead a visible Pi message with the agent name, team, run ID, last activity time, and assignment excerpt. After ten idle minutes it requests normal shutdown and reports whether cleanup finished or remains pending. A late cleanup result sends a confirmation or the failure details.
+
+```json
+{
+  "watchdog": {
+    "idleWarningMinutes": 5,
+    "idleStopMinutes": 10,
+    "idleAutoStop": true
+  }
+}
+```
+
+Both thresholds accept positive finite numbers in minutes. Settings are read on each check; project values override global values. Set `idleAutoStop` to `false` to keep warnings without automatic idle cancellation. Heartbeat-failure cleanup is separate and unchanged except that tracked active work is protected.
+
+Messages, streamed text or reasoning, tool activity, and progress updates reset the idle timer. Heartbeats alone do not. Active tools (including silent long-running commands), checks, compaction, and parents with accepted queued or running children are protected. Queued, starting, and finishing agents are excluded. Warnings occur once per idle period. Terminal agents need current activity telemetry; missing telemetry does not authorize an idle stop.
+
 ## Task outcomes and full reports
 
 A completed agent, a successful task, passed verification, and lead acceptance are separate facts.

package/extensions/agents/read-agent.ts

@@ -4,6 +4,7 @@ import path from "node:path";
 import os from "node:os";
 import { buildPiCommand, getPiLaunchCommand, shellQuote } from "../internal/pi-command";
 import { herdrCommand } from "../runtime/herdr";
+import { recordAgentActivity } from "../runtime/agent-activity";
 import * as runtime from "../../src/utils/runtime";
 import * as teams from "../../src/utils/teams";
 import * as messaging from "../../src/utils/messaging";
@@ -327,6 +328,7 @@ export function handleReadAgentSessionEvent(
   renderReadAgentStatus: () => void
 ): void {
   const eventType = event.type;
+  recordAgentActivity(state, event);
   if (eventType === "agent_start" || eventType === "turn_start") {
     markReadAgentActivity(state, "thinking", "thinking");
   }

package/extensions/events/register-events.ts

@@ -5,6 +5,7 @@ import * as paths from "../../src/utils/paths";
 import * as runtime from "../../src/utils/runtime";
 import * as messaging from "../../src/utils/messaging";
 import * as teams from "../../src/utils/teams";
+import { recordAgentActivity, type AgentActivity } from "../runtime/agent-activity";
 import { cleanupAgentSessionFolders, cleanupOrphanedTeams } from "../internal/session-files";
 import { summarizeSessionUsage } from "../internal/session-usage";
 import { formatElapsed, formatTokenCount } from "../ui/renderers";
@@ -76,6 +77,8 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
   let teammateInboxDisposed = false;
   let teammateLifecycleRunId: string | undefined = process.env.PI_LIFECYCLE_RUN_ID;
   const teammateOneShotTimers = new Set<NodeJS.Timeout>();
+  const activity: AgentActivity = {};
+  let activityPublishedAt = 0;
 
   const scheduleTeammateOneShot = (callback: () => void, delayMs: number) => {
     const timer = setTimeout(() => {
@@ -127,6 +130,8 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
     }
     return {
       ...updates,
+      lastActivityAt: activity.lastActivityAt,
+      activeWorkCount: activity.activeWork?.size ?? 0,
       ...(typeof usage.tokensUsed === "number" ? { tokensUsed: usage.tokensUsed } : {}),
       contextUsage,
     };
@@ -149,6 +154,24 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
 
   registerAgentReportRenderer(pi);
 
+  if (options.isTeammate) {
+    for (const type of ["agent_start", "agent_end", "turn_start", "turn_end", "message_start", "message_update", "message_end",
+      "tool_execution_start", "tool_execution_update", "tool_execution_end", "session_before_compact", "session_compact",
+      "session_compact_failed", "ui_prompt_start", "ui_prompt_end"]) {
+      pi.on(type, async (event: any) => {
+        recordAgentActivity(activity, { ...event, type });
+        const teamName = options.getTeamName();
+        if (!teamName || !teammateLifecycleRunId || teammateInboxDisposed) return;
+        // Stream events can arrive per token; persist at most once a second.
+        if ((type === "message_update" || type === "tool_execution_update") && Date.now() - activityPublishedAt < 1000) return;
+        activityPublishedAt = Date.now();
+        await writeTeammateRuntimeStatus(teamName, {
+          lastActivityAt: activity.lastActivityAt, activeWorkCount: activity.activeWork?.size ?? 0,
+        });
+      });
+    }
+  }
+
   pi.on("session_start", async (_event: any, ctx: any) => {
     paths.ensureDirs();
     // Local-only janitor pass: no model calls, no agent wakes. This prevents
@@ -194,6 +217,8 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
     if (options.isTeammate) {
       disposeTeammateInbox();
       teammateInboxDisposed = false;
+      activity.lastActivityAt = Date.now();
+      activity.activeWork = new Set();
       if (teamName) {
         if (teams.teamExists(teamName)) {
           const persistedRunId = await teams.ensureMemberLifecycleRunId(teamName, options.agentName, teammateLifecycleRunId);
@@ -213,6 +238,8 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
           pid: process.pid,
           startedAt: Date.now(),
           lastHeartbeatAt: Date.now(),
+          lastActivityAt: activity.lastActivityAt,
+          activeWorkCount: 0,
           ready: false,
           currentAction: "starting",
           activeToolName: undefined,
@@ -263,6 +290,8 @@ export function registerExtensionEvents(pi: any, options: RegisterEventsOptions)
             if (teammateInboxDisposed) return;
             await writeTeammateRuntimeStatus(teamName, {
               lastHeartbeatAt: Date.now(),
+              lastActivityAt: activity.lastActivityAt,
+              activeWorkCount: activity.activeWork?.size ?? 0,
             });
             if (unread.length > 0) {
               const content = `You have ${unread.length} new inbox message(s). Read them with read_inbox and act.`;

package/extensions/index.ts

@@ -139,6 +139,14 @@ function createExecutionRuntime(pi: ExtensionAPI, host?: ReturnType<typeof creat
     getSessionCwd: () => sessionCtx?.cwd,
     getTeamName: () => teamName,
     extensionInstanceId,
+    notifyIdleAgent: (content) => pi.sendMessage({
+      customType: "pi-extended-teams-idle", content, display: true,
+    }, { triggerTurn: true, deliverAs: "followUp" }),
+    hasPendingChildren: (targetTeamName, member) => !!member.lifecycleRunId && pendingChildController.hasPendingChildren({
+      teamName: targetTeamName,
+      parentName: member.name,
+      parentRunId: member.lifecycleRunId,
+    }),
     onWriterInactive: (targetTeamName, member) => {
       releaseWriteAgentSleepAssertion(targetTeamName, member);
       removeWriterScreenTab(writerScreenState, { teamName: targetTeamName, name: member.name, paneId: member.tmuxPaneId });

package/extensions/runtime/agent-activity.ts

@@ -0,0 +1,27 @@
+/** Actual work evidence, separate from a runtime's periodic liveness heartbeat. */
+export interface AgentActivity {
+  lastActivityAt?: number;
+  activeWork?: Set<string>;
+}
+
+const workStarts: Record<string, string> = {
+  compaction_start: "compaction", auto_compaction_start: "compaction", session_before_compact: "compaction",
+  auto_retry_start: "retry", ui_prompt_start: "user-prompt",
+};
+const workEnds: Record<string, string> = {
+  compaction_end: "compaction", auto_compaction_end: "compaction", session_compact: "compaction",
+  session_compact_failed: "compaction", auto_retry_end: "retry", ui_prompt_end: "user-prompt",
+};
+
+export function recordAgentActivity(
+  state: AgentActivity,
+  event: { type: string; toolCallId?: string; toolName?: string; assistantMessageEvent?: unknown },
+  now = Date.now(),
+): void {
+  state.lastActivityAt = now;
+  const work = state.activeWork ??= new Set();
+  if (event.type === "tool_execution_start") work.add(`tool:${event.toolCallId ?? event.toolName}`);
+  if (event.type === "tool_execution_end") work.delete(`tool:${event.toolCallId ?? event.toolName}`);
+  if (workStarts[event.type]) work.add(workStarts[event.type]);
+  if (workEnds[event.type]) work.delete(workEnds[event.type]);
+}

package/extensions/runtime/types.ts

@@ -13,6 +13,8 @@ export interface RunningReadAgent extends ManagedReadAgentLifecycleState {
   status: "starting" | "thinking" | "working" | "finishing";
   recentEvents: string[];
   lastActivityAt: number;
+  /** Exact tool calls and other work spans that must not be idle-stopped. */
+  activeWork?: Set<string>;
   activeToolName?: string;
   /** Monotonic identity for the current nested AgentSession turn. */
   operationGeneration?: number;

package/extensions/team/lifecycle.ts

@@ -10,7 +10,7 @@ import { createReportResult } from "../../src/results/report-result";
 import { VerificationController } from "../../src/results/verification-controller";
 import { CompletionGroup } from "../../src/results/completion-group";
 import { enqueueCompletionGroupDeliveries } from "../../src/results/completion-group-delivery";
-import { loadSettings } from "../../src/utils/settings";
+import { loadSettings, type WatchdogConfig } from "../../src/utils/settings";
 import type { Member } from "../../src/utils/models";
 import type { RunningReadAgent } from "../runtime/types";
 import {
@@ -46,12 +46,16 @@ export interface LifecycleRuntimeOptions {
   onTeammateClosing?(teamName: string, member: Member): void;
   onTeammateSettled?(teamName: string, member: Member): void;
   extensionInstanceId?: string;
+  notifyIdleAgent?(content: string): void | Promise<void>;
+  hasPendingChildren?(teamName: string, member: Member): boolean;
 }
 
 export interface ShutdownTeammateOptions {
   drainQueue?: boolean;
   removeMember?: boolean;
   reason?: unknown;
+  /** Revalidate automatic cancellation after asynchronous lifecycle reads. */
+  shouldStop?(): boolean;
 }
 
 interface ReapedTeammate {
@@ -68,6 +72,8 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
   let leadWatchdogTimer: NodeJS.Timeout | null = null;
   let leadWatchdogGeneration = 0;
   const extensionInstanceId = options.extensionInstanceId ?? generateExtensionInstanceId();
+  const idleObservations = new Map<string, { activityAt: number; since: number; warned: boolean; attempted: boolean }>();
+  let watchdogInFlight = false;
 
   async function finalizeTeammateRuntime(teamName: string, member: Member, expectedRunId: string): Promise<void> {
     const pidFile = path.join(paths.teamDir(teamName), `${member.name}.pid`);
@@ -161,13 +167,6 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
       }
       member.lifecycleRunId = expectedRunId;
     }
-    try {
-      options.onTeammateClosing?.(teamName, { ...member, lifecycleRunId: expectedRunId });
-    } catch {
-      // Lifecycle cancellation hooks are in-memory notifications only. Persisted
-      // teardown ownership remains authoritative if an observer fails.
-    }
-
     const persistedRuntime = await runtime.readRuntimeStatus(teamName, member.name).catch(() => null);
     if (persistedRuntime?.lifecycleRunId && persistedRuntime.lifecycleRunId !== expectedRunId) {
       return boundedQuarantineResult(
@@ -388,6 +387,15 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
       });
     };
 
+    if (shutdownOptions.shouldStop && !shutdownOptions.shouldStop()) {
+      return { ...baseResult(), finalized: false, error: "Idle cancellation skipped: activity or ownership changed." };
+    }
+    try {
+      options.onTeammateClosing?.(teamName, { ...member, lifecycleRunId: expectedRunId });
+    } catch {
+      // Lifecycle cancellation hooks are in-memory notifications only. Persisted
+      // teardown ownership remains authoritative if an observer fails.
+    }
     if (expectedState) {
       return requestReadAgentTeardown(expectedState, {
         reason,
@@ -461,12 +469,104 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
     )));
   }
 
+  async function notifyIdleAgent(teamName: string, content: string): Promise<void> {
+    if (options.notifyIdleAgent) await options.notifyIdleAgent(content);
+    else await messaging.sendPlainMessage(teamName, "watchdog", "team-lead", content, "Agent idle watchdog", "yellow");
+  }
+
+  async function checkIdleAgent(
+    teamName: string,
+    member: Member,
+    members: Member[],
+    status: runtime.AgentRuntimeStatus | null,
+    settings: WatchdogConfig,
+    shouldContinue: () => boolean,
+  ): Promise<void> {
+    if (!shouldContinue()) return;
+    const key = options.readAgentKey(teamName, member.name);
+    const state = options.runningReadAgents.get(key);
+    const runId = member.lifecycleRunId;
+    if (!runId || member.isActive === false || (state ? state.runId !== runId : status?.lifecycleRunId !== runId)) return;
+    const activityAt = state?.lastActivityAt ?? status?.lastActivityAt;
+    if (activityAt === undefined) return; // Old terminal runtimes have no trustworthy activity evidence.
+    const identity = `${teamName}:${member.name}:${runId}`;
+    let observation = idleObservations.get(identity);
+    if (!observation || observation.activityAt !== activityAt) {
+      observation = { activityAt, since: activityAt, warned: false, attempted: false };
+      idleObservations.set(identity, observation);
+    }
+    const isProtected = () => {
+      if (options.hasPendingChildren?.(teamName, member)) return true;
+      if (state) {
+        return state.status === "starting" || state.status === "finishing" || !!state.stopRequested
+          || state.acceptingMessages === false || !!state.activeToolName || !!state.activeWork?.size
+          || !!state.checkOperation || !!state.checkpointOperation;
+      }
+      return status?.ready !== true || status.currentAction === "starting" || status.currentAction === "finishing"
+        || status.currentAction === "done" || !!status.activeToolName || !!status.activeWorkCount;
+    };
+    const hasChild = members.some(child => child.isActive !== false && child.parentAgentName === member.name
+      && child.parentLifecycleRunId === runId);
+    if (isProtected() || hasChild) {
+      observation.since = Date.now();
+      observation.warned = false;
+      observation.attempted = false;
+      return;
+    }
+    const idleMs = Date.now() - observation.since;
+    const reference = `${member.name} (team ${teamName}, run ${runId})`;
+    const context = `Last activity: ${new Date(activityAt).toISOString()}.${member.prompt ? ` Assignment: ${member.prompt.slice(0, 300)}` : ""}`;
+    if (idleMs >= settings.idleWarningMinutes * 60_000 && !observation.warned) {
+      observation.warned = true;
+      try {
+        await notifyIdleAgent(teamName, `Agent ${reference} is idle: no messages, tokens, or work activity for ${Math.floor(idleMs / 60_000)} minutes. ${context}`);
+      } catch (error) {
+        observation.warned = false;
+        throw error;
+      }
+    }
+    if (!settings.idleAutoStop || idleMs < settings.idleStopMinutes * 60_000 || observation.attempted || !shouldContinue()) return;
+    // Re-read persisted ownership before cancelling; a report or replacement may have won the race.
+    const current = (await teams.readConfig(teamName)).members.find(candidate => candidate.name === member.name);
+    if (current?.lifecycleRunId !== runId || current.isActive === false) return;
+    const fence = await readLifecycleTombstone(teamName, member.name);
+    if (fence.status !== "absent") return;
+    if (!state) {
+      const latest = await runtime.readRuntimeStatus(teamName, member.name);
+      if (latest?.lifecycleRunId !== runId || latest.lastActivityAt !== activityAt) return;
+      status = latest;
+    }
+    const stillIdle = () => shouldContinue() && !isProtected() && (state
+      ? options.runningReadAgents.get(key) === state && state.lastActivityAt === activityAt
+      : !options.runningReadAgents.has(key));
+    if (!stillIdle()) return;
+    observation.attempted = true;
+    const describeStop = (result: ReadAgentTeardownResult) => result.status === "settled" && result.finalized
+      ? `Agent ${reference} automatically stopped after ${Math.floor(idleMs / 60_000)} idle minutes.`
+      : `Agent ${reference} idle stop is not complete (${result.status}); cancellation/cleanup remains pending or failed. ${result.error ?? ""}`;
+    try {
+      const result = await shutdownTeammate(teamName, current, { shouldStop: stillIdle });
+      if (shouldContinue()) await notifyIdleAgent(teamName, describeStop(result));
+      if (!result.finalized && state?.teardownFinalizationPromise) {
+        void state.teardownFinalizationPromise.then(async final => {
+          if (shouldContinue()) await notifyIdleAgent(teamName, describeStop(final));
+        }).catch(() => {});
+      }
+    } catch (error) {
+      if (shouldContinue()) await notifyIdleAgent(teamName, `Agent ${reference} idle stop or notification failed: ${errorText(error)}`);
+    }
+  }
+
   async function runWatchdogOnce(targetTeamName: string, shouldContinue: () => boolean = () => true): Promise<void> {
     const settings = loadSettings({ projectDir: options.getSessionCwd() || process.cwd() });
     const staleMs = runtime.HEARTBEAT_STALE_MS + settings.watchdog.bufferSeconds * 1000;
     const now = Date.now();
     const config = await teams.readConfig(targetTeamName);
     const members = config.members.filter((member) => member.name !== "team-lead");
+    const identities = new Set(members.map(member => `${targetTeamName}:${member.name}:${member.lifecycleRunId}`));
+    for (const identity of idleObservations.keys()) {
+      if (identity.startsWith(`${targetTeamName}:`) && !identities.has(identity)) idleObservations.delete(identity);
+    }
     const runtimeStatusByMember = await readRuntimeStatusByMember(targetTeamName, members);
     const reaped: ReapedTeammate[] = [];
 
@@ -482,6 +582,11 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
         const key = options.readAgentKey(targetTeamName, member.name);
         const inProcessAlive = options.runningReadAgents.has(key);
 
+        if (inProcessAlive || runtimeStatus?.activeToolName || runtimeStatus?.activeWorkCount) {
+          await checkIdleAgent(targetTeamName, member, members, runtimeStatus, settings.watchdog, shouldContinue);
+          continue;
+        }
+
         if (runtimeStale && !inProcessAlive) {
           const result = await shutdownTeammate(targetTeamName, member, { drainQueue: false });
           if (result.status === "settled" && result.finalized) {
@@ -496,7 +601,9 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
           if (result.status === "settled" && result.finalized) {
             reaped.push({ member, reason: "legacy tmux screen is gone" });
           }
+          continue;
         }
+        await checkIdleAgent(targetTeamName, member, members, runtimeStatus, settings.watchdog, shouldContinue);
       }
     } finally {
       await flushReapedTeammates(targetTeamName, reaped);
@@ -510,6 +617,7 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
     if (leadWatchdogTimer) clearInterval(leadWatchdogTimer);
     leadWatchdogTimer = null;
     leadWatchdogStarted = false;
+    idleObservations.clear();
   }
 
   function startLeadWatchdog() {
@@ -517,13 +625,16 @@ export function createLifecycleRuntime(options: LifecycleRuntimeOptions) {
     leadWatchdogStarted = true;
     const generation = ++leadWatchdogGeneration;
     leadWatchdogTimer = setInterval(async () => {
-      if (generation !== leadWatchdogGeneration) return;
+      if (generation !== leadWatchdogGeneration || watchdogInFlight) return;
       const teamName = options.getTeamName();
       if (!teamName) return;
+      watchdogInFlight = true;
       try {
         await runWatchdogOnce(teamName, () => generation === leadWatchdogGeneration);
       } catch {
-        // Keep watchdog quiet; health is visible in the live agent view and inbox messages on actual reaps.
+        // Retry observations on the next tick; stop attempts are not repeated blindly.
+      } finally {
+        watchdogInFlight = false;
       }
     }, 30000);
   }

package/extensions/ui/agent-follow-view.ts

@@ -8,9 +8,6 @@ import { createActivityColors } from "./activity-colors";
 
 const REFRESH_INTERVAL_MS = 250;
 const MAX_NAVIGATION_AGENTS = 6;
-const COLLAPSED_TOOL_RESULT_LINE_LIMIT = 14;
-const COLLAPSED_TOOL_RESULT_HEAD_LINES = 8;
-const COLLAPSED_TOOL_RESULT_TAIL_LINES = 3;
 
 export interface AgentFollowViewOptions {
   getAgents(): RunningReadAgent[];
@@ -227,7 +224,7 @@ function renderToolBlock(theme: ExtendedTeamsTheme, block: Extract<TranscriptBlo
   if (compactBlock) return compactBlock;
 
   const header = renderToolHeader(theme, block);
-  if (!expandLargeToolResults && (block.name === "read" || block.name === "bash" || block.name === "ls")) {
+  if (!expandLargeToolResults) {
     const state = block.result === undefined
       ? pendingText(theme, "working")
       : block.isError ? failureText(theme, "✗") : successText(theme, "✓");
@@ -241,22 +238,12 @@ function renderToolBlock(theme: ExtendedTeamsTheme, block: Extract<TranscriptBlo
 
   const result = block.result || "(no output)";
   const resultLines = result.split("\n");
-  const isCollapsed = !expandLargeToolResults && resultLines.length > COLLAPSED_TOOL_RESULT_LINE_LIMIT;
-  const visibleLines = isCollapsed
-    ? [
-        ...resultLines.slice(0, COLLAPSED_TOOL_RESULT_HEAD_LINES),
-        `… ${resultLines.length - COLLAPSED_TOOL_RESULT_HEAD_LINES - COLLAPSED_TOOL_RESULT_TAIL_LINES} lines hidden · press l to expand logs`,
-        ...resultLines.slice(-COLLAPSED_TOOL_RESULT_TAIL_LINES),
-      ]
-    : resultLines;
   const resultLineWidth = width === undefined ? undefined : Math.max(1, width - visibleWidth("│ "));
-  const boundedLines = visibleLines.map((line) => resultLineWidth === undefined
+  const boundedLines = resultLines.map((line) => resultLineWidth === undefined
     ? line
     : truncateToWidth(line, resultLineWidth, "…"));
-  const body = boundedLines.map((line, index) => isCollapsed && index === COLLAPSED_TOOL_RESULT_HEAD_LINES
-    ? `${structuralText(theme, "│")} ${mutedText(theme, line)}`
-    : `${structuralText(theme, "│")} ${line}`);
-  const summary = `${resultLines.length} line${resultLines.length === 1 ? "" : "s"} · ${formatResultSize(result)}${isCollapsed ? " · collapsed" : ""}`;
+  const body = boundedLines.map((line) => `${structuralText(theme, "│")} ${line}`);
+  const summary = `${resultLines.length} line${resultLines.length === 1 ? "" : "s"} · ${formatResultSize(result)}`;
   const renderedSummary = block.isError ? failureText(theme, summary) : successText(theme, summary);
   return [header, ...body, `${structuralText(theme, "╰─")} ${renderedSummary}`, ""];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-extended-teams",
-  "version": "2.4.2",
+  "version": "2.5.0",
   "description": "Control-first, session-connected subagents for Pi with live navigation and intent-tier routing",
   "repository": {
     "type": "git",

package/src/utils/runtime.ts

@@ -38,6 +38,8 @@ export interface AgentRuntimeStatus {
   pid?: number;
   startedAt?: number;
   lastHeartbeatAt?: number;
+  lastActivityAt?: number;
+  activeWorkCount?: number;
   lastInboxReadAt?: number;
   ready?: boolean;
   currentAction?: "starting" | "thinking" | "working" | "finishing" | "done";
@@ -234,7 +236,7 @@ export async function cleanupStaleRuntimeFiles(
         try {
           const status = JSON.parse(fs.readFileSync(p, "utf-8")) as AgentRuntimeStatus;
           const lastActivity = status.lastHeartbeatAt || status.startedAt || 0;
-          shouldDelete = (now - lastActivity) > RUNTIME_STALE_MS;
+          shouldDelete = !status.activeToolName && !status.activeWorkCount && (now - lastActivity) > RUNTIME_STALE_MS;
         } catch {
           shouldDelete = true;
         }

package/src/utils/settings.ts

@@ -76,6 +76,9 @@ export interface CategoryConfig {
 export interface WatchdogConfig {
   /** Grace buffer (seconds) added on top of the heartbeat interval. */
   bufferSeconds: number;
+  idleWarningMinutes: number;
+  idleStopMinutes: number;
+  idleAutoStop: boolean;
 }
 
 export interface WriteAgentsConfig {
@@ -151,7 +154,7 @@ export const DEFAULT_READ_HELPER_MAX_CONCURRENT = 10;
 
 export const DEFAULT_SETTINGS: PiExtendedTeamsSettings = {
   activityColors: DEFAULT_ACTIVITY_COLORS,
-  watchdog: { bufferSeconds: 30 },
+  watchdog: { bufferSeconds: 30, idleWarningMinutes: 5, idleStopMinutes: 10, idleAutoStop: true },
   writeAgents: { maxConcurrent: DEFAULT_WRITE_AGENT_MAX_CONCURRENT, queueOverflow: true },
   readAgents: { maxConcurrent: DEFAULT_READ_AGENT_MAX_CONCURRENT, queueOverflow: true },
   readHelpers: { maxConcurrent: DEFAULT_READ_HELPER_MAX_CONCURRENT, queueOverflow: true },
@@ -296,6 +299,11 @@ function applyLayer(acc: PiExtendedTeamsSettings, raw: any, options: { favoriteM
   if (raw.watchdog && typeof raw.watchdog === "object") {
     const b = Number(raw.watchdog.bufferSeconds);
     if (Number.isFinite(b) && b >= 0) acc.watchdog.bufferSeconds = b;
+    for (const key of ["idleWarningMinutes", "idleStopMinutes"] as const) {
+      const value = raw.watchdog[key];
+      if (typeof value === "number" && Number.isFinite(value) && value > 0) acc.watchdog[key] = value;
+    }
+    if (typeof raw.watchdog.idleAutoStop === "boolean") acc.watchdog.idleAutoStop = raw.watchdog.idleAutoStop;
   }
 
   if (raw.writeAgents && typeof raw.writeAgents === "object") {