pi-messenger-swarm 0.20.2 → 0.20.3

package/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+### [0.20.3](https://github.com/monotykamary/pi-messenger-swarm/compare/v0.20.2...v0.20.3) (2026-04-04)
+
+
+### Features
+
+* **swarm:** filter running agents by default, add spawn.history and messaging warnings ([0fb1a9e](https://github.com/monotykamary/pi-messenger-swarm/commit/0fb1a9e90a0472456677dbc349c5ebabe70a191c))
+
+
+### Bug Fixes
+
+* **swarm:** use listSpawnedHistory in session shutdown to unclaim all spawned agent tasks ([212cd05](https://github.com/monotykamary/pi-messenger-swarm/commit/212cd052e2f558f9f1f0b39c9d04b35c204e2c3c))
+
 ### [0.20.2](https://github.com/monotykamary/pi-messenger-swarm/compare/v0.20.1...v0.20.2) (2026-04-04)
 
 ### [0.20.1](https://github.com/monotykamary/pi-messenger-swarm/compare/v0.20.0...v0.20.1) (2026-04-04)

package/handlers/coordination.ts

@@ -21,6 +21,8 @@ import {
 import { displayChannelLabel, normalizeChannelId } from '../channel.js';
 import * as store from '../store.js';
 import * as taskStore from '../swarm/task-store.js';
+import { findSpawnedAgentByName } from '../swarm/spawn.js';
+import { getContextSessionId } from '../store/shared.js';
 import {
   formatFeedLine,
   isSwarmEvent,
@@ -620,6 +622,23 @@ export function executeSend(
   const isChannelTarget = typeof to === 'string' && to.startsWith('#');
   const targetChannel = isChannelTarget ? normalizeChannelId(to) : channel || state.currentChannel;
 
+  // Check if targeting a completed/failed/stopped spawned agent
+  let spawnWarning = '';
+  if (typeof to === 'string' && !isChannelTarget) {
+    const sessionId = getContextSessionId({ cwd } as ExtensionContext);
+    const spawnedAgent = findSpawnedAgentByName(cwd, sessionId, to);
+    if (spawnedAgent && spawnedAgent.status !== 'running') {
+      const statusEmoji =
+        spawnedAgent.status === 'completed' ? '✅' : spawnedAgent.status === 'failed' ? '❌' : '🛑';
+      spawnWarning = `\n\n⚠️ Warning: ${to} is a spawned agent that has already ${spawnedAgent.status} ${statusEmoji}. The message will be logged to the feed, but the agent process is no longer active.`;
+      if (spawnedAgent.status === 'completed') {
+        spawnWarning += `\n   If you need to continue the work, consider spawning a new agent.`;
+      } else if (spawnedAgent.status === 'failed') {
+        spawnWarning += `\n   The agent failed with errors. Review the task and consider respawning.`;
+      }
+    }
+  }
+
   // All messaging is now feed-based
   logFeedEvent(
     cwd,
@@ -633,12 +652,17 @@ export function executeSend(
   const targetLabel = typeof to === 'string' ? to : 'multiple recipients';
   const channelLabel = displayChannelLabel(targetChannel);
   // If the target is already a channel reference, just say "posted to #channel"
-  const text = isChannelTarget
+  let text = isChannelTarget
     ? `Message posted to ${targetLabel}.`
     : `Message posted to ${targetLabel} on ${channelLabel}.`;
+
+  // Append warning if targeting a completed/failed/stopped agent
+  text += spawnWarning;
+
   return result(text, {
     mode: 'send',
     channel: targetChannel,
     to: typeof to === 'string' ? to : undefined,
+    warning: spawnWarning ? 'target_agent_completed' : undefined,
   });
 }

package/index.ts

@@ -580,8 +580,8 @@ Usage (swarm-first API):
     overlayTui = null;
     if (state.registered) {
       const sessionId = state.contextSessionId ?? '';
-      const { listSpawned } = await import('./swarm/spawn.js');
-      const spawnedAgents = listSpawned(cwd, sessionId);
+      const { listSpawnedHistory } = await import('./swarm/spawn.js');
+      const spawnedAgents = listSpawnedHistory(cwd, sessionId);
       const spawnedNames = new Set(spawnedAgents.map((s) => s.name));
 
       // Get all tasks for this session

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-messenger-swarm",
-  "version": "0.20.2",
+  "version": "0.20.3",
   "description": "Swarm-first multi-agent messaging and task orchestration extension for Pi",
   "type": "module",
   "author": "Tom X Nguyen",

package/skills/pi-messenger-swarm/SKILL.md

@@ -112,7 +112,8 @@ The body after `---` becomes the system prompt.
 Manage spawned agents:
 
 ```typescript
-pi_messenger({ action: 'spawn.list' });
+pi_messenger({ action: 'spawn.list' }); // Only shows running agents
+pi_messenger({ action: 'spawn.history' }); // Shows all agents including completed/failed/stopped
 pi_messenger({ action: 'spawn.stop', id: '<spawn-id>' });
 ```
 
@@ -127,6 +128,8 @@ pi_messenger({
 });
 ```
 
+⚠️ **Warning when messaging completed agents**: If you try to send a message to a spawned subagent that has already completed, failed, or stopped, you'll receive a warning. The message is still logged to the feed, but the agent process is no longer active. Use `pi_messenger({ action: "spawn.history" })` to see which agents are still running.
+
 ## Swarm Philosophy
 
 The swarm is self-organizing. Your role is participant, not manager.

package/swarm/handlers.ts

@@ -4,7 +4,13 @@ import { displayChannelLabel, normalizeChannelId } from '../channel.js';
 import { result } from './result.js';
 import { logFeedEvent } from '../feed.js';
 import * as taskStore from './task-store.js';
-import { cleanupExitedSpawned, listSpawned, spawnSubagent, stopSpawn } from './spawn.js';
+import {
+  cleanupExitedSpawned,
+  listSpawned,
+  listSpawnedHistory,
+  spawnSubagent,
+  stopSpawn,
+} from './spawn.js';
 import type { SpawnRequest, SwarmTaskEvidence } from './types.js';
 import { formatRoleLabel } from './labels.js';
 import { executeTaskAction } from './task-actions.js';
@@ -18,20 +24,28 @@ export function executeSwarmStatus(cwd: string, channelId: string, sessionId: st
   cleanupExitedSpawned(cwd, sessionId);
   const tasks = taskStore.getTasks(cwd, sessionId);
   const summary = taskStore.getSummary(cwd, sessionId);
-  const spawned = listSpawned(cwd, sessionId);
+  const runningAgents = listSpawned(cwd, sessionId, false); // Only running
+  const allAgents = listSpawned(cwd, sessionId, true); // All including completed
+  const completedCount = allAgents.filter((a) => a.status === 'completed').length;
+  const failedCount = allAgents.filter((a) => a.status === 'failed').length;
   const channelLabel = displayChannelLabel(channelId);
 
-  if (tasks.length === 0) {
-    return result(
-      `# Agent Swarm ${channelLabel}\n\nNo tasks yet.\n\nCreate one:\n  pi_messenger({ action: "task.create", title: "...", content: "..." })\n\nSpawn a subagent:\n  pi_messenger({ action: "spawn", role: "Researcher", message: "Investigate ..." })`,
-      {
-        mode: 'swarm',
-        channel: normalizeChannelId(channelId),
-        summary,
-        tasks: [],
-        spawned,
-      }
-    );
+  if (tasks.length === 0 && runningAgents.length === 0) {
+    let text = `# Agent Swarm ${channelLabel}\n\nNo tasks yet.`;
+    if (completedCount > 0 || failedCount > 0) {
+      text += `\n\n${completedCount} completed, ${failedCount} failed agents in history.`;
+    }
+    text += `\n\nCreate one:\n  pi_messenger({ action: "task.create", title: "...", content: "..." })\n\nSpawn a subagent:\n  pi_messenger({ action: "spawn", role: "Researcher", message: "Investigate ..." })`;
+    if (completedCount > 0 || failedCount > 0) {
+      text += `\n\nView history:\n  pi_messenger({ action: "spawn.history" })`;
+    }
+    return result(text, {
+      mode: 'swarm',
+      channel: normalizeChannelId(channelId),
+      summary,
+      tasks: [],
+      spawned: runningAgents,
+    });
   }
 
   const lines: string[] = [
@@ -41,9 +55,9 @@ export function executeSwarmStatus(cwd: string, channelId: string, sessionId: st
     '',
   ];
 
-  if (spawned.length > 0) {
-    lines.push('## Spawned Agents');
-    for (const agent of spawned.slice(0, 8)) {
+  if (runningAgents.length > 0) {
+    lines.push('## Running Agents');
+    for (const agent of runningAgents.slice(0, 8)) {
       const suffix = agent.taskId ? ` → ${agent.taskId}` : '';
       lines.push(
         `- ${agent.id} · ${agent.name} (${formatRoleLabel(agent.role)}) · ${agent.status}${suffix}`
@@ -52,6 +66,13 @@ export function executeSwarmStatus(cwd: string, channelId: string, sessionId: st
     lines.push('');
   }
 
+  if (completedCount > 0 || failedCount > 0) {
+    lines.push(`## Agent History`);
+    lines.push(`- ${completedCount} completed · ${failedCount} failed`);
+    lines.push(`- View: pi_messenger({ action: "spawn.history" })`);
+    lines.push('');
+  }
+
   lines.push('## Tasks');
   for (const task of tasks) {
     const icon =
@@ -72,7 +93,7 @@ export function executeSwarmStatus(cwd: string, channelId: string, sessionId: st
     channel: normalizeChannelId(channelId),
     summary,
     tasks,
-    spawned,
+    spawned: runningAgents,
   });
 }
 
@@ -642,18 +663,23 @@ export function executeSpawn(
   }
 
   if (op === 'list') {
-    const items = listSpawned(cwd, sessionId);
+    const items = listSpawned(cwd, sessionId, false); // Only running agents
     if (items.length === 0) {
-      return result('No spawned agents for this project.', { mode: 'spawn.list', agents: [] });
+      return result('No running spawned agents for this project.', {
+        mode: 'spawn.list',
+        agents: [],
+      });
     }
 
     const lines = [
-      '# Spawned Agents',
+      '# Running Spawned Agents',
       '',
       ...items.map((agent) => {
         const tail = agent.taskId ? ` → ${agent.taskId}` : '';
         return `- ${agent.id}: ${agent.name} (${formatRoleLabel(agent.role)}) · ${agent.status}${tail}`;
       }),
+      '',
+      `Use pi_messenger({ action: "spawn.history" }) to see all agents including completed.`,
     ];
 
     return result(lines.join('\n'), {
@@ -662,6 +688,79 @@ export function executeSpawn(
     });
   }
 
+  if (op === 'history') {
+    const items = listSpawnedHistory(cwd, sessionId); // All agents including completed
+    const running = items.filter((a) => a.status === 'running');
+    const completed = items.filter((a) => a.status === 'completed');
+    const failed = items.filter((a) => a.status === 'failed');
+    const stopped = items.filter((a) => a.status === 'stopped');
+
+    if (items.length === 0) {
+      return result('No spawned agents for this project.', { mode: 'spawn.history', agents: [] });
+    }
+
+    const lines: string[] = ['# Spawned Agent History', ''];
+
+    if (running.length > 0) {
+      lines.push('## Running');
+      for (const agent of running.slice(0, 8)) {
+        const tail = agent.taskId ? ` → ${agent.taskId}` : '';
+        lines.push(`- ${agent.id}: ${agent.name} (${formatRoleLabel(agent.role)})${tail}`);
+      }
+      lines.push('');
+    }
+
+    if (completed.length > 0) {
+      lines.push(`## Completed (${completed.length})`);
+      for (const agent of completed.slice(0, 10)) {
+        const ended = agent.endedAt
+          ? ` · ended ${new Date(agent.endedAt).toLocaleTimeString()}`
+          : '';
+        const tail = agent.taskId ? ` → ${agent.taskId}` : '';
+        lines.push(`- ${agent.id}: ${agent.name} (${formatRoleLabel(agent.role)})${tail}${ended}`);
+      }
+      if (completed.length > 10) {
+        lines.push(`... and ${completed.length - 10} more`);
+      }
+      lines.push('');
+    }
+
+    if (failed.length > 0) {
+      lines.push(`## Failed (${failed.length})`);
+      for (const agent of failed.slice(0, 5)) {
+        const ended = agent.endedAt
+          ? ` · ended ${new Date(agent.endedAt).toLocaleTimeString()}`
+          : '';
+        const tail = agent.taskId ? ` → ${agent.taskId}` : '';
+        lines.push(`- ${agent.id}: ${agent.name} (${formatRoleLabel(agent.role)})${tail}${ended}`);
+      }
+      lines.push('');
+    }
+
+    if (stopped.length > 0) {
+      lines.push(`## Stopped (${stopped.length})`);
+      for (const agent of stopped.slice(0, 5)) {
+        const ended = agent.endedAt
+          ? ` · ended ${new Date(agent.endedAt).toLocaleTimeString()}`
+          : '';
+        const tail = agent.taskId ? ` → ${agent.taskId}` : '';
+        lines.push(`- ${agent.id}: ${agent.name} (${formatRoleLabel(agent.role)})${tail}${ended}`);
+      }
+      lines.push('');
+    }
+
+    return result(lines.join('\n'), {
+      mode: 'spawn.history',
+      agents: items,
+      counts: {
+        running: running.length,
+        completed: completed.length,
+        failed: failed.length,
+        stopped: stopped.length,
+      },
+    });
+  }
+
   if (op === 'stop') {
     const id = params.id;
     if (!id) {

package/swarm/spawn.ts

@@ -491,7 +491,11 @@ export function spawnSubagent(
   return record;
 }
 
-export function listSpawned(cwd: string, sessionId: string): SpawnedAgent[] {
+export function listSpawned(
+  cwd: string,
+  sessionId: string,
+  includeAll: boolean = false
+): SpawnedAgent[] {
   // First, get persisted agents for this session from event log
   const persisted = loadSpawnedAgents(cwd, sessionId);
   const persistedById = new Map(persisted.map((a) => [a.id, a]));
@@ -503,9 +507,33 @@ export function listSpawned(cwd: string, sessionId: string): SpawnedAgent[] {
     persistedById.set(id, runtime.record);
   }
 
-  return Array.from(persistedById.values()).sort(
-    (a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt)
-  );
+  let agents = Array.from(persistedById.values());
+
+  // Filter to only running agents by default
+  if (!includeAll) {
+    agents = agents.filter((a) => a.status === 'running');
+  }
+
+  return agents.sort((a, b) => Date.parse(b.startedAt) - Date.parse(a.startedAt));
+}
+
+/**
+ * Get all spawned agents including completed/failed/stopped (history view).
+ */
+export function listSpawnedHistory(cwd: string, sessionId: string): SpawnedAgent[] {
+  return listSpawned(cwd, sessionId, true);
+}
+
+/**
+ * Find a spawned agent by name (including non-running agents).
+ */
+export function findSpawnedAgentByName(
+  cwd: string,
+  sessionId: string,
+  name: string
+): SpawnedAgent | null {
+  const allAgents = listSpawnedHistory(cwd, sessionId);
+  return allAgents.find((a) => a.name === name) ?? null;
 }
 
 export function stopSpawn(cwd: string, id: string): boolean {