opencode-swarm 5.1.5 → 5.1.7

package/dist/config/schema.d.ts

@@ -170,7 +170,12 @@ export type GuardrailsConfig = z.infer<typeof GuardrailsConfigSchema>;
  * Works with any swarm name by checking if the name (or suffix after removing
  * a prefix) matches a known agent name from ALL_AGENT_NAMES.
  *
+ * Normalization handles:
+ * - Case-insensitive matching (e.g., "PAID_ARCHITECT" → "architect")
+ * - Multiple separators: underscore, hyphen, space (e.g., "paid-architect", "paid architect")
+ *
  * Examples: 'local_architect' → 'architect', 'enterprise_coder' → 'coder',
+ *           'paid-architect' → 'architect', 'PAID_ARCHITECT' → 'architect',
  *           'architect' → 'architect', 'unknown_thing' → 'unknown_thing'
  *
  * @param name - The agent name (possibly prefixed)

package/dist/index.js

@@ -13687,14 +13687,20 @@ var GuardrailsConfigSchema = exports_external.object({
   idle_timeout_minutes: exports_external.number().min(5).max(240).default(60),
   profiles: exports_external.record(exports_external.string(), GuardrailsProfileSchema).optional()
 });
+function normalizeAgentName(name) {
+  return name.toLowerCase().replace(/[-\s]+/g, "_");
+}
 function stripKnownSwarmPrefix(name) {
   if (!name)
     return name;
   if (ALL_AGENT_NAMES.includes(name))
     return name;
+  const normalized = normalizeAgentName(name);
   for (const agentName of ALL_AGENT_NAMES) {
-    const suffix = `_${agentName}`;
-    if (name.endsWith(suffix)) {
+    const normalizedAgent = normalizeAgentName(agentName);
+    if (normalized === normalizedAgent)
+      return agentName;
+    if (normalized.endsWith("_" + normalizedAgent)) {
       return agentName;
     }
   }
@@ -13706,9 +13712,8 @@ function resolveGuardrailsConfig(base, agentName) {
   }
   const baseName = stripKnownSwarmPrefix(agentName);
   const builtInLookup = DEFAULT_AGENT_PROFILES[baseName];
-  const effectiveName = builtInLookup ? baseName : ORCHESTRATOR_NAME;
-  const builtIn = DEFAULT_AGENT_PROFILES[effectiveName];
-  const userProfile = base.profiles?.[effectiveName] ?? base.profiles?.[baseName] ?? base.profiles?.[agentName];
+  const builtIn = builtInLookup;
+  const userProfile = base.profiles?.[baseName] ?? base.profiles?.[agentName];
   if (!builtIn && !userProfile) {
     return base;
   }
@@ -15046,6 +15051,7 @@ function startAgentSession(sessionId, agentName, staleDurationMs = 7200000) {
     agentName,
     startTime: now,
     lastToolCallTime: now,
+    lastAgentEventTime: now,
     toolCallCount: 0,
     consecutiveErrors: 0,
     recentToolCalls: [],
@@ -15075,6 +15081,7 @@ function ensureAgentSession(sessionId, agentName) {
       session.hardLimitHit = false;
       session.lastSuccessTime = now;
       session.delegationActive = false;
+      session.lastAgentEventTime = now;
     }
     session.lastToolCallTime = now;
     return session;
@@ -15086,6 +15093,12 @@ function ensureAgentSession(sessionId, agentName) {
   }
   return session;
 }
+function updateAgentEventTime(sessionId) {
+  const session = swarmState.agentSessions.get(sessionId);
+  if (session) {
+    session.lastAgentEventTime = Date.now();
+  }
+}
 
 // src/commands/benchmark.ts
 var CI = {
@@ -16733,6 +16746,7 @@ ${originalText}`;
 // src/hooks/delegation-tracker.ts
 function createDelegationTrackerHook(config2) {
   return async (input, _output) => {
+    const now = Date.now();
     if (!input.agent || input.agent === "") {
       const session2 = swarmState.agentSessions.get(input.sessionID);
       if (session2) {
@@ -16740,18 +16754,21 @@ function createDelegationTrackerHook(config2) {
       }
       swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
       ensureAgentSession(input.sessionID, ORCHESTRATOR_NAME);
+      updateAgentEventTime(input.sessionID);
       return;
     }
     const agentName = input.agent;
     const previousAgent = swarmState.activeAgent.get(input.sessionID);
     swarmState.activeAgent.set(input.sessionID, agentName);
+    const strippedAgent = stripKnownSwarmPrefix(agentName);
+    const isArchitect = strippedAgent === ORCHESTRATOR_NAME;
     const session = ensureAgentSession(input.sessionID, agentName);
-    session.delegationActive = true;
+    session.delegationActive = !isArchitect;
     if (config2.hooks?.delegation_tracker === true && previousAgent && previousAgent !== agentName) {
       const entry = {
         from: previousAgent,
         to: agentName,
-        timestamp: Date.now()
+        timestamp: now
       };
       if (!swarmState.delegationChains.has(input.sessionID)) {
         swarmState.delegationChains.set(input.sessionID, []);
@@ -16792,6 +16809,9 @@ function createGuardrailsHooks(config2) {
         return;
       }
       const agentConfig = resolveGuardrailsConfig(config2, session.agentName);
+      if (agentConfig.max_duration_minutes === 0 && agentConfig.max_tool_calls === 0) {
+        return;
+      }
       if (session.hardLimitHit) {
         throw new Error("\uD83D\uDED1 CIRCUIT BREAKER: Agent blocked. Hard limit was previously triggered. Stop making tool calls and return your progress summary.");
       }
@@ -30165,7 +30185,7 @@ var OpenCodeSwarm = async (ctx) => {
       if (session && activeAgent && activeAgent !== ORCHESTRATOR_NAME) {
         const stripActive = stripKnownSwarmPrefix(activeAgent);
         if (stripActive !== ORCHESTRATOR_NAME) {
-          const staleDelegation = !session.delegationActive || Date.now() - session.lastToolCallTime > 1e4;
+          const staleDelegation = !session.delegationActive || Date.now() - session.lastAgentEventTime > 1e4;
           if (staleDelegation) {
             swarmState.activeAgent.set(input.sessionID, ORCHESTRATOR_NAME);
             ensureAgentSession(input.sessionID, ORCHESTRATOR_NAME);
@@ -30175,7 +30195,21 @@ var OpenCodeSwarm = async (ctx) => {
       await guardrailsHooks.toolBefore(input, output);
       await safeHook(activityHooks.toolBefore)(input, output);
     },
-    "tool.execute.after": composeHandlers(activityHooks.toolAfter, guardrailsHooks.toolAfter, toolSummarizerHook),
+    "tool.execute.after": async (input, output) => {
+      await activityHooks.toolAfter(input, output);
+      await guardrailsHooks.toolAfter(input, output);
+      await toolSummarizerHook?.(input, output);
+      if (input.tool === "task") {
+        const sessionId = input.sessionID;
+        swarmState.activeAgent.set(sessionId, ORCHESTRATOR_NAME);
+        ensureAgentSession(sessionId, ORCHESTRATOR_NAME);
+        const session = swarmState.agentSessions.get(sessionId);
+        if (session) {
+          session.delegationActive = false;
+          session.lastAgentEventTime = Date.now();
+        }
+      }
+    },
     "chat.message": safeHook(delegationHandler)
   };
 };

package/dist/state.d.ts

@@ -43,6 +43,8 @@ export interface AgentSessionState {
     startTime: number;
     /** Timestamp of most recent tool call (for stale session eviction) */
     lastToolCallTime: number;
+    /** Timestamp of most recent agent identity event (chat.message sets/changes identity) */
+    lastAgentEventTime: number;
     /** Total tool calls in this session */
     toolCallCount: number;
     /** Consecutive errors (reset on success) */
@@ -114,3 +116,9 @@ export declare function getAgentSession(sessionId: string): AgentSessionState |
  * @returns The AgentSessionState
  */
 export declare function ensureAgentSession(sessionId: string, agentName?: string): AgentSessionState;
+/**
+ * Update only the agent event timestamp (for stale detection).
+ * Does NOT change agent name or reset guardrail state.
+ * @param sessionId - The session identifier
+ */
+export declare function updateAgentEventTime(sessionId: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "5.1.5",
+	"version": "5.1.7",
 	"description": "Architect-centric agentic swarm plugin for OpenCode - hub-and-spoke orchestration with SME consultation, code generation, and QA review",
 	"main": "dist/index.js",
 	"types": "dist/index.d.ts",