opencode-swarm-plugin 0.12.4 → 0.12.7

package/src/beads.ts

@@ -55,6 +55,10 @@ export class BeadValidationError extends Error {
 
 /**
  * Build a bd create command from args
+ *
+ * Note: Bun's `$` template literal properly escapes arguments when passed as array.
+ * Each array element is treated as a separate argument, preventing shell injection.
+ * Example: ["bd", "create", "; rm -rf /"] becomes: bd create "; rm -rf /"
  */
 function buildCreateCommand(args: BeadCreateArgs): string[] {
   const parts = ["bd", "create", args.title];
@@ -250,25 +254,40 @@ export const beads_create_epic = tool({
 
       return JSON.stringify(result, null, 2);
     } catch (error) {
-      // Partial failure - return what was created with rollback hint
-      const rollbackHint = created
-        .map((b) => `bd close ${b.id} --reason "Rollback partial epic"`)
-        .join("\n");
+      // Partial failure - execute rollback automatically
+      const rollbackCommands: string[] = [];
+
+      for (const bead of created) {
+        try {
+          const closeCmd = [
+            "bd",
+            "close",
+            bead.id,
+            "--reason",
+            "Rollback partial epic",
+            "--json",
+          ];
+          await Bun.$`${closeCmd}`.quiet().nothrow();
+          rollbackCommands.push(
+            `bd close ${bead.id} --reason "Rollback partial epic"`,
+          );
+        } catch (rollbackError) {
+          // Log rollback failure but continue
+          console.error(`Failed to rollback bead ${bead.id}:`, rollbackError);
+        }
+      }
 
-      const result: EpicCreateResult = {
-        success: false,
-        epic: created[0] || ({} as Bead),
-        subtasks: created.slice(1),
-        rollback_hint: rollbackHint,
-      };
+      // Throw error with rollback info
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      const rollbackInfo =
+        rollbackCommands.length > 0
+          ? `\n\nRolled back ${rollbackCommands.length} bead(s):\n${rollbackCommands.join("\n")}`
+          : "\n\nNo beads to rollback.";
 
-      return JSON.stringify(
-        {
-          ...result,
-          error: error instanceof Error ? error.message : String(error),
-        },
-        null,
-        2,
+      throw new BeadError(
+        `Epic creation failed: ${errorMsg}${rollbackInfo}`,
+        "beads_create_epic",
+        1,
       );
     }
   },
@@ -487,10 +506,38 @@ export const beads_sync = tool({
   },
   async execute(args, ctx) {
     const autoPull = args.auto_pull ?? true;
+    const TIMEOUT_MS = 30000; // 30 seconds
+
+    /**
+     * Helper to run a command with timeout
+     */
+    const withTimeout = async <T>(
+      promise: Promise<T>,
+      timeoutMs: number,
+      operation: string,
+    ): Promise<T> => {
+      const timeoutPromise = new Promise<never>((_, reject) =>
+        setTimeout(
+          () =>
+            reject(
+              new BeadError(
+                `Operation timed out after ${timeoutMs}ms`,
+                operation,
+              ),
+            ),
+          timeoutMs,
+        ),
+      );
+      return Promise.race([promise, timeoutPromise]);
+    };
 
     // 1. Pull if requested
     if (autoPull) {
-      const pullResult = await Bun.$`git pull --rebase`.quiet().nothrow();
+      const pullResult = await withTimeout(
+        Bun.$`git pull --rebase`.quiet().nothrow(),
+        TIMEOUT_MS,
+        "git pull --rebase",
+      );
       if (pullResult.exitCode !== 0) {
         throw new BeadError(
           `Failed to pull: ${pullResult.stderr.toString()}`,
@@ -501,7 +548,11 @@ export const beads_sync = tool({
     }
 
     // 2. Sync beads
-    const syncResult = await Bun.$`bd sync`.quiet().nothrow();
+    const syncResult = await withTimeout(
+      Bun.$`bd sync`.quiet().nothrow(),
+      TIMEOUT_MS,
+      "bd sync",
+    );
     if (syncResult.exitCode !== 0) {
       throw new BeadError(
         `Failed to sync beads: ${syncResult.stderr.toString()}`,
@@ -511,7 +562,11 @@ export const beads_sync = tool({
     }
 
     // 3. Push
-    const pushResult = await Bun.$`git push`.quiet().nothrow();
+    const pushResult = await withTimeout(
+      Bun.$`git push`.quiet().nothrow(),
+      TIMEOUT_MS,
+      "git push",
+    );
     if (pushResult.exitCode !== 0) {
       throw new BeadError(
         `Failed to push: ${pushResult.stderr.toString()}`,

package/src/learning.ts

@@ -64,6 +64,46 @@ export const CriterionWeightSchema = z.object({
 });
 export type CriterionWeight = z.infer<typeof CriterionWeightSchema>;
 
+/**
+ * Error types that can occur during subtask execution
+ */
+export const ErrorTypeSchema = z.enum([
+  "validation",
+  "timeout",
+  "conflict",
+  "tool_failure",
+  "unknown",
+]);
+export type ErrorType = z.infer<typeof ErrorTypeSchema>;
+
+/**
+ * An error entry in the error accumulator
+ *
+ * Errors are accumulated during subtask execution and can be fed
+ * into retry prompts to help agents learn from past failures.
+ */
+export const ErrorEntrySchema = z.object({
+  /** Unique ID for this error entry */
+  id: z.string(),
+  /** The bead ID this error relates to */
+  bead_id: z.string(),
+  /** Type of error encountered */
+  error_type: ErrorTypeSchema,
+  /** Human-readable error message */
+  message: z.string(),
+  /** Optional stack trace for debugging */
+  stack_trace: z.string().optional(),
+  /** Tool that failed, if applicable */
+  tool_name: z.string().optional(),
+  /** When this error occurred */
+  timestamp: z.string(), // ISO-8601
+  /** Whether this error was resolved */
+  resolved: z.boolean().default(false),
+  /** Context about what was happening when error occurred */
+  context: z.string().optional(),
+});
+export type ErrorEntry = z.infer<typeof ErrorEntrySchema>;
+
 /**
  * Decomposition strategies for tracking which approach was used
  */
@@ -437,6 +477,241 @@ export class InMemoryFeedbackStorage implements FeedbackStorage {
   }
 }
 
+// ============================================================================
+// Error Accumulator
+// ============================================================================
+
+/**
+ * Storage interface for error entries
+ *
+ * Similar to FeedbackStorage but for tracking errors during execution.
+ */
+export interface ErrorStorage {
+  /** Store an error entry */
+  store(entry: ErrorEntry): Promise<void>;
+  /** Get all errors for a bead */
+  getByBead(beadId: string): Promise<ErrorEntry[]>;
+  /** Get unresolved errors for a bead */
+  getUnresolvedByBead(beadId: string): Promise<ErrorEntry[]>;
+  /** Mark an error as resolved */
+  markResolved(id: string): Promise<void>;
+  /** Get all errors */
+  getAll(): Promise<ErrorEntry[]>;
+}
+
+/**
+ * In-memory error storage
+ *
+ * Accumulates errors during subtask execution for feeding into retry prompts.
+ */
+export class InMemoryErrorStorage implements ErrorStorage {
+  private errors: ErrorEntry[] = [];
+
+  async store(entry: ErrorEntry): Promise<void> {
+    this.errors.push(entry);
+  }
+
+  async getByBead(beadId: string): Promise<ErrorEntry[]> {
+    return this.errors.filter((e) => e.bead_id === beadId);
+  }
+
+  async getUnresolvedByBead(beadId: string): Promise<ErrorEntry[]> {
+    return this.errors.filter((e) => e.bead_id === beadId && !e.resolved);
+  }
+
+  async markResolved(id: string): Promise<void> {
+    const error = this.errors.find((e) => e.id === id);
+    if (error) {
+      error.resolved = true;
+    }
+  }
+
+  async getAll(): Promise<ErrorEntry[]> {
+    return [...this.errors];
+  }
+}
+
+/**
+ * Error accumulator for tracking errors during subtask execution
+ *
+ * Implements patterns from "Patterns for Building AI Agents" p.40:
+ * - Examines and corrects errors when something goes wrong
+ * - Feeds error context into retry prompts
+ * - Tracks error patterns for learning
+ */
+export class ErrorAccumulator {
+  private storage: ErrorStorage;
+
+  constructor(storage?: ErrorStorage) {
+    this.storage = storage ?? new InMemoryErrorStorage();
+  }
+
+  /**
+   * Record an error during subtask execution
+   *
+   * @param beadId - Bead ID where error occurred
+   * @param errorType - Category of error
+   * @param message - Human-readable error message
+   * @param options - Additional context (stack trace, tool name, etc.)
+   * @returns The created error entry
+   */
+  async recordError(
+    beadId: string,
+    errorType: ErrorType,
+    message: string,
+    options?: {
+      stack_trace?: string;
+      tool_name?: string;
+      context?: string;
+    },
+  ): Promise<ErrorEntry> {
+    const entry: ErrorEntry = {
+      id: `${beadId}-${errorType}-${Date.now()}`,
+      bead_id: beadId,
+      error_type: errorType,
+      message,
+      stack_trace: options?.stack_trace,
+      tool_name: options?.tool_name,
+      timestamp: new Date().toISOString(),
+      resolved: false,
+      context: options?.context,
+    };
+
+    const validated = ErrorEntrySchema.parse(entry);
+    await this.storage.store(validated);
+
+    return validated;
+  }
+
+  /**
+   * Get all errors for a bead (resolved and unresolved)
+   */
+  async getErrors(beadId: string): Promise<ErrorEntry[]> {
+    return this.storage.getByBead(beadId);
+  }
+
+  /**
+   * Get only unresolved errors for a bead
+   */
+  async getUnresolvedErrors(beadId: string): Promise<ErrorEntry[]> {
+    return this.storage.getUnresolvedByBead(beadId);
+  }
+
+  /**
+   * Mark an error as resolved
+   */
+  async resolveError(errorId: string): Promise<void> {
+    await this.storage.markResolved(errorId);
+  }
+
+  /**
+   * Format errors as context for retry prompts
+   *
+   * Groups errors by type and provides structured feedback
+   * for the agent to learn from.
+   *
+   * @param beadId - Bead to get error context for
+   * @param includeResolved - Include resolved errors (default: false)
+   * @returns Formatted error context string
+   */
+  async getErrorContext(
+    beadId: string,
+    includeResolved = false,
+  ): Promise<string> {
+    const errors = includeResolved
+      ? await this.getErrors(beadId)
+      : await this.getUnresolvedErrors(beadId);
+
+    if (errors.length === 0) {
+      return "";
+    }
+
+    // Group errors by type
+    const byType = errors.reduce(
+      (acc, err) => {
+        const type = err.error_type;
+        if (!acc[type]) {
+          acc[type] = [];
+        }
+        acc[type].push(err);
+        return acc;
+      },
+      {} as Record<ErrorType, ErrorEntry[]>,
+    );
+
+    // Format as structured feedback
+    const lines = [
+      "## Previous Errors",
+      "",
+      "The following errors were encountered during execution:",
+      "",
+    ];
+
+    for (const [type, typeErrors] of Object.entries(byType)) {
+      lines.push(
+        `### ${type} (${typeErrors.length} error${typeErrors.length > 1 ? "s" : ""})`,
+      );
+      lines.push("");
+
+      for (const err of typeErrors) {
+        lines.push(`- **${err.message}**`);
+        if (err.context) {
+          lines.push(`  - Context: ${err.context}`);
+        }
+        if (err.tool_name) {
+          lines.push(`  - Tool: ${err.tool_name}`);
+        }
+        if (err.stack_trace) {
+          lines.push(`  - Stack: \`${err.stack_trace.slice(0, 100)}...\``);
+        }
+        lines.push(
+          `  - Time: ${new Date(err.timestamp).toLocaleString()}${err.resolved ? " (resolved)" : ""}`,
+        );
+        lines.push("");
+      }
+    }
+
+    lines.push(
+      "**Action Required**: Address these errors before proceeding. Consider:",
+    );
+    lines.push("- What caused each error?");
+    lines.push("- How can you prevent similar errors?");
+    lines.push("- Are there patterns across error types?");
+    lines.push("");
+
+    return lines.join("\n");
+  }
+
+  /**
+   * Get error statistics for outcome tracking
+   *
+   * @param beadId - Bead to get stats for
+   * @returns Error counts and patterns
+   */
+  async getErrorStats(beadId: string): Promise<{
+    total: number;
+    unresolved: number;
+    by_type: Record<ErrorType, number>;
+  }> {
+    const allErrors = await this.getErrors(beadId);
+    const unresolved = await this.getUnresolvedErrors(beadId);
+
+    const byType = allErrors.reduce(
+      (acc, err) => {
+        acc[err.error_type] = (acc[err.error_type] || 0) + 1;
+        return acc;
+      },
+      {} as Record<ErrorType, number>,
+    );
+
+    return {
+      total: allErrors.length,
+      unresolved: unresolved.length,
+      by_type: byType,
+    };
+  }
+}
+
 // ============================================================================
 // Exports
 // ============================================================================
@@ -448,4 +723,6 @@ export const learningSchemas = {
   OutcomeSignalsSchema,
   ScoredOutcomeSchema,
   DecompositionStrategySchema,
+  ErrorTypeSchema,
+  ErrorEntrySchema,
 };

package/src/rate-limiter.ts

@@ -122,9 +122,15 @@ export function getLimitsForEndpoint(endpoint: string): EndpointLimits {
   const perHourEnv =
     process.env[`OPENCODE_RATE_LIMIT_${upperEndpoint}_PER_HOUR`];
 
+  // Parse and validate env vars, fall back to defaults on NaN
+  const parsedPerMinute = perMinuteEnv ? parseInt(perMinuteEnv, 10) : NaN;
+  const parsedPerHour = perHourEnv ? parseInt(perHourEnv, 10) : NaN;
+
   return {
-    perMinute: perMinuteEnv ? parseInt(perMinuteEnv, 10) : defaults.perMinute,
-    perHour: perHourEnv ? parseInt(perHourEnv, 10) : defaults.perHour,
+    perMinute: Number.isNaN(parsedPerMinute)
+      ? defaults.perMinute
+      : parsedPerMinute,
+    perHour: Number.isNaN(parsedPerHour) ? defaults.perHour : parsedPerHour,
   };
 }
 
@@ -211,10 +217,11 @@ export class RedisRateLimiter implements RateLimiter {
     const windowDuration = this.getWindowDuration(window);
     const windowStart = now - windowDuration;
 
-    // Remove expired entries and count current ones in a pipeline
+    // Remove expired entries, count current ones, and fetch oldest in a single pipeline
     const pipeline = this.redis.pipeline();
     pipeline.zremrangebyscore(key, 0, windowStart);
     pipeline.zcard(key);
+    pipeline.zrange(key, 0, 0, "WITHSCORES"); // Fetch oldest entry atomically
 
     const results = await pipeline.exec();
     if (!results) {
@@ -225,11 +232,10 @@ export class RedisRateLimiter implements RateLimiter {
     const remaining = Math.max(0, limit - count);
     const allowed = count < limit;
 
-    // Calculate reset time based on oldest entry in window
+    // Calculate reset time based on oldest entry in window (fetched atomically)
     let resetAt = now + windowDuration;
     if (!allowed) {
-      // Get the oldest entry's timestamp to calculate precise reset
-      const oldest = await this.redis.zrange(key, 0, 0, "WITHSCORES");
+      const oldest = (results[2]?.[1] as string[]) || [];
       if (oldest.length >= 2) {
         const oldestTimestamp = parseInt(oldest[1], 10);
         resetAt = oldestTimestamp + windowDuration;

package/src/schemas/bead.ts

@@ -42,15 +42,15 @@ export type BeadDependency = z.infer<typeof BeadDependencySchema>;
 export const BeadSchema = z.object({
   id: z
     .string()
-    .regex(/^[a-z0-9-]+-[a-z0-9]+(\.\d+)?$/, "Invalid bead ID format"),
+    .regex(/^[a-z0-9]+(-[a-z0-9]+)+(\.\d+)?$/, "Invalid bead ID format"),
   title: z.string().min(1, "Title required"),
   description: z.string().optional().default(""),
   status: BeadStatusSchema.default("open"),
   priority: z.number().int().min(0).max(3).default(2),
   issue_type: BeadTypeSchema.default("task"),
-  created_at: z.string(), // ISO-8601
-  updated_at: z.string().optional(),
-  closed_at: z.string().optional(),
+  created_at: z.string().datetime({ offset: true }), // ISO-8601 with timezone offset
+  updated_at: z.string().datetime({ offset: true }).optional(),
+  closed_at: z.string().datetime({ offset: true }).optional(),
   parent_id: z.string().optional(),
   dependencies: z.array(BeadDependencySchema).optional().default([]),
   metadata: z.record(z.string(), z.unknown()).optional(),

package/src/schemas/evaluation.ts

@@ -53,7 +53,7 @@ export const EvaluationSchema = z.object({
   criteria: z.record(z.string(), CriterionEvaluationSchema),
   overall_feedback: z.string(),
   retry_suggestion: z.string().nullable(),
-  timestamp: z.string().optional(), // ISO-8601
+  timestamp: z.string().datetime({ offset: true }).optional(), // ISO-8601 with timezone
 });
 export type Evaluation = z.infer<typeof EvaluationSchema>;
 
@@ -91,7 +91,7 @@ export const WeightedEvaluationSchema = z.object({
   criteria: z.record(z.string(), WeightedCriterionEvaluationSchema),
   overall_feedback: z.string(),
   retry_suggestion: z.string().nullable(),
-  timestamp: z.string().optional(), // ISO-8601
+  timestamp: z.string().datetime({ offset: true }).optional(), // ISO-8601 with timezone
   /** Average weight across all criteria (indicates overall confidence) */
   average_weight: z.number().min(0).max(1).optional(),
   /** Raw score before weighting */

package/src/schemas/task.ts

@@ -94,7 +94,7 @@ export const SwarmSpawnResultSchema = z.object({
   coordinator_name: z.string(), // Agent Mail name of coordinator
   thread_id: z.string(), // Agent Mail thread for this swarm
   agents: z.array(SpawnedAgentSchema),
-  started_at: z.string(), // ISO-8601
+  started_at: z.string().datetime({ offset: true }), // ISO-8601 with timezone
 });
 export type SwarmSpawnResult = z.infer<typeof SwarmSpawnResultSchema>;
 
@@ -109,7 +109,7 @@ export const AgentProgressSchema = z.object({
   message: z.string().optional(),
   files_touched: z.array(z.string()).optional(),
   blockers: z.array(z.string()).optional(),
-  timestamp: z.string(), // ISO-8601
+  timestamp: z.string().datetime({ offset: true }), // ISO-8601 with timezone
 });
 export type AgentProgress = z.infer<typeof AgentProgressSchema>;
 
@@ -124,6 +124,6 @@ export const SwarmStatusSchema = z.object({
   failed: z.number().int().min(0),
   blocked: z.number().int().min(0),
   agents: z.array(SpawnedAgentSchema),
-  last_update: z.string(), // ISO-8601
+  last_update: z.string().datetime({ offset: true }), // ISO-8601 with timezone
 });
 export type SwarmStatus = z.infer<typeof SwarmStatusSchema>;

package/src/storage.ts

@@ -73,20 +73,35 @@ async function resolveSemanticMemoryCommand(): Promise<string[]> {
 async function execSemanticMemory(
   args: string[],
 ): Promise<{ exitCode: number; stdout: Buffer; stderr: Buffer }> {
-  const cmd = await resolveSemanticMemoryCommand();
-  const fullCmd = [...cmd, ...args];
-
-  // Use Bun.spawn for dynamic command arrays
-  const proc = Bun.spawn(fullCmd, {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
+  try {
+    const cmd = await resolveSemanticMemoryCommand();
+    const fullCmd = [...cmd, ...args];
 
-  const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
-  const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
-  const exitCode = await proc.exited;
+    // Use Bun.spawn for dynamic command arrays
+    const proc = Bun.spawn(fullCmd, {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
 
-  return { exitCode, stdout, stderr };
+    try {
+      const stdout = Buffer.from(await new Response(proc.stdout).arrayBuffer());
+      const stderr = Buffer.from(await new Response(proc.stderr).arrayBuffer());
+      const exitCode = await proc.exited;
+
+      return { exitCode, stdout, stderr };
+    } finally {
+      // Ensure process cleanup
+      proc.kill();
+    }
+  } catch (error) {
+    // Return structured error result on exceptions
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    return {
+      exitCode: 1,
+      stdout: Buffer.from(""),
+      stderr: Buffer.from(`Error executing semantic-memory: ${errorMessage}`),
+    };
+  }
 }
 
 /**
@@ -646,17 +661,22 @@ export async function createStorageWithFallback(
 // ============================================================================
 
 let globalStorage: LearningStorage | null = null;
+let globalStoragePromise: Promise<LearningStorage> | null = null;
 
 /**
  * Get or create the global storage instance
  *
  * Uses semantic-memory by default, with automatic fallback to in-memory.
+ * Prevents race conditions by storing the initialization promise.
  */
 export async function getStorage(): Promise<LearningStorage> {
-  if (!globalStorage) {
-    globalStorage = await createStorageWithFallback();
+  if (!globalStoragePromise) {
+    globalStoragePromise = createStorageWithFallback().then((storage) => {
+      globalStorage = storage;
+      return storage;
+    });
   }
-  return globalStorage;
+  return globalStoragePromise;
 }
 
 /**
@@ -666,6 +686,7 @@ export async function getStorage(): Promise<LearningStorage> {
  */
 export function setStorage(storage: LearningStorage): void {
   globalStorage = storage;
+  globalStoragePromise = Promise.resolve(storage);
 }
 
 /**
@@ -676,4 +697,5 @@ export async function resetStorage(): Promise<void> {
     await globalStorage.close();
     globalStorage = null;
   }
+  globalStoragePromise = null;
 }