opencode-swarm 6.32.4 → 6.33.1

package/README.md

@@ -142,6 +142,30 @@ You only need to specify the agents you want to override. The `architect` inheri
 
 See the [full configuration reference](#configuration-reference) and the [free-tier model setup](#free-tier-opencode-zen-models) for more options.
 
+### Step 7 — Performance modes (optional)
+
+Swarm runs optional quality hooks (slop detection, incremental verification, compaction) on every tool call. For faster iteration, you can skip these:
+
+**Via slash command** (session-wide):
+```
+/swarm turbo
+```
+
+**Via config** (persistent):
+```json
+{
+  "execution_mode": "fast"
+}
+```
+
+| Mode | Behavior |
+|------|----------|
+| `strict` | Runs all quality hooks (slop detector, incremental verify, compaction). Maximum safety, highest overhead. |
+| `balanced` (default) | Skips optional quality hooks. Recommended for most workflows. |
+| `fast` | Same as balanced. Reserved for future more aggressive optimizations. |
+
+Use `strict` mode for critical security-sensitive changes. Switch to `balanced` for routine development.
+
 ---
 
 ## Common First-Run Questions

package/dist/agents/architect.dark-matter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli/index.js

@@ -17497,7 +17497,7 @@ var init_evidence_summary_service = __esm(() => {
 });
 
 // src/cli/index.ts
-import * as fs11 from "fs";
+import * as fs12 from "fs";
 import * as os5 from "os";
 import * as path23 from "path";
 
@@ -18063,6 +18063,7 @@ var GuardrailsConfigSchema = exports_external.object({
   max_consecutive_errors: exports_external.number().min(2).max(20).default(5),
   warning_threshold: exports_external.number().min(0.1).max(0.9).default(0.75),
   idle_timeout_minutes: exports_external.number().min(5).max(240).default(60),
+  no_op_warning_threshold: exports_external.number().min(1).max(100).default(15),
   qa_gates: exports_external.object({
     required_tools: exports_external.array(exports_external.string().min(1)).default([
       "diff",
@@ -18178,6 +18179,7 @@ var PluginConfigSchema = exports_external.object({
   pipeline: PipelineConfigSchema.optional(),
   phase_complete: PhaseCompleteConfigSchema.optional(),
   qa_retry_limit: exports_external.number().min(1).max(10).default(3),
+  execution_mode: exports_external.enum(["strict", "balanced", "fast"]).default("balanced"),
   inject_phase_reminders: exports_external.boolean().default(true),
   hooks: HooksConfigSchema.optional(),
   gates: GateConfigSchema.optional(),
@@ -33931,6 +33933,8 @@ function formatHandoffMarkdown(data) {
 init_utils2();
 import { mkdirSync as mkdirSync4, renameSync as renameSync4 } from "fs";
 import * as path14 from "path";
+var pendingWrite = null;
+var lastWritePromise = Promise.resolve();
 function serializeAgentSession(s) {
   const gateLog = {};
   const rawGateLog = s.gateLog ?? new Map;
@@ -34015,7 +34019,18 @@ async function writeSnapshot(directory, state) {
     const tempPath = `${resolvedPath}.tmp.${Date.now()}.${Math.random().toString(36).slice(2)}`;
     await Bun.write(tempPath, content);
     renameSync4(tempPath, resolvedPath);
-  } catch {}
+  } catch (error93) {
+    console.warn("[snapshot-writer] write failed:", error93 instanceof Error ? error93.message : String(error93));
+  }
+}
+async function flushPendingSnapshot(directory) {
+  if (pendingWrite) {
+    clearTimeout(pendingWrite);
+    pendingWrite = null;
+    await writeSnapshot(directory, swarmState).catch(() => {});
+  } else {
+    await lastWritePromise;
+  }
 }
 
 // src/commands/handoff.ts
@@ -34027,6 +34042,7 @@ async function handleHandoffCommand(directory, _args) {
   await Bun.write(tempPath, markdown);
   renameSync5(tempPath, resolvedPath);
   await writeSnapshot(directory, swarmState);
+  await flushPendingSnapshot(directory);
   return `## Handoff Brief Written
 
 Brief written to \`.swarm/handoff.md\`.
@@ -39322,6 +39338,37 @@ async function handleResetCommand(directory, args) {
 `);
 }
 
+// src/commands/reset-session.ts
+init_utils2();
+import * as fs10 from "fs";
+async function handleResetSessionCommand(directory, _args) {
+  const results = [];
+  try {
+    const statePath = validateSwarmPath(directory, "session/state.json");
+    if (fs10.existsSync(statePath)) {
+      fs10.unlinkSync(statePath);
+      results.push("\u2705 Deleted .swarm/session/state.json");
+    } else {
+      results.push("\u23ED\uFE0F state.json not found (already clean)");
+    }
+  } catch {
+    results.push("\u274C Failed to delete state.json");
+  }
+  const sessionCount = swarmState.agentSessions.size;
+  swarmState.agentSessions.clear();
+  results.push(`\u2705 Cleared ${sessionCount} in-memory agent session(s)`);
+  return [
+    "## Session State Reset",
+    "",
+    ...results,
+    "",
+    "Session state cleared. Plan, evidence, and knowledge preserved.",
+    "",
+    "**Next step:** Start a new OpenCode session. The plugin will initialize fresh session state on startup."
+  ].join(`
+`);
+}
+
 // src/summaries/manager.ts
 init_utils2();
 init_utils();
@@ -39402,18 +39449,18 @@ ${error93 instanceof Error ? error93.message : String(error93)}`;
 
 // src/commands/rollback.ts
 init_utils2();
-import * as fs10 from "fs";
+import * as fs11 from "fs";
 import * as path22 from "path";
 async function handleRollbackCommand(directory, args) {
   const phaseArg = args[0];
   if (!phaseArg) {
     const manifestPath2 = validateSwarmPath(directory, "checkpoints/manifest.json");
-    if (!fs10.existsSync(manifestPath2)) {
+    if (!fs11.existsSync(manifestPath2)) {
       return "No checkpoints found. Use `/swarm checkpoint` to create checkpoints.";
     }
     let manifest2;
     try {
-      manifest2 = JSON.parse(fs10.readFileSync(manifestPath2, "utf-8"));
+      manifest2 = JSON.parse(fs11.readFileSync(manifestPath2, "utf-8"));
     } catch {
       return "Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.";
     }
@@ -39435,12 +39482,12 @@ async function handleRollbackCommand(directory, args) {
     return "Error: Phase number must be a positive integer.";
   }
   const manifestPath = validateSwarmPath(directory, "checkpoints/manifest.json");
-  if (!fs10.existsSync(manifestPath)) {
+  if (!fs11.existsSync(manifestPath)) {
     return `Error: No checkpoints found. Cannot rollback to phase ${targetPhase}.`;
   }
   let manifest;
   try {
-    manifest = JSON.parse(fs10.readFileSync(manifestPath, "utf-8"));
+    manifest = JSON.parse(fs11.readFileSync(manifestPath, "utf-8"));
   } catch {
     return `Error: Checkpoint manifest is corrupted. Delete .swarm/checkpoints/manifest.json and re-checkpoint.`;
   }
@@ -39450,10 +39497,10 @@ async function handleRollbackCommand(directory, args) {
     return `Error: Checkpoint for phase ${targetPhase} not found. Available phases: ${available}`;
   }
   const checkpointDir = validateSwarmPath(directory, `checkpoints/phase-${targetPhase}`);
-  if (!fs10.existsSync(checkpointDir)) {
+  if (!fs11.existsSync(checkpointDir)) {
     return `Error: Checkpoint directory for phase ${targetPhase} does not exist.`;
   }
-  const checkpointFiles = fs10.readdirSync(checkpointDir);
+  const checkpointFiles = fs11.readdirSync(checkpointDir);
   if (checkpointFiles.length === 0) {
     return `Error: Checkpoint for phase ${targetPhase} is empty. Cannot rollback.`;
   }
@@ -39464,7 +39511,7 @@ async function handleRollbackCommand(directory, args) {
     const src = path22.join(checkpointDir, file3);
     const dest = path22.join(swarmDir, file3);
     try {
-      fs10.cpSync(src, dest, { recursive: true, force: true });
+      fs11.cpSync(src, dest, { recursive: true, force: true });
       successes.push(file3);
     } catch (error93) {
       failures.push({ file: file3, error: error93.message });
@@ -39481,7 +39528,7 @@ async function handleRollbackCommand(directory, args) {
     timestamp: new Date().toISOString()
   };
   try {
-    fs10.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
+    fs11.appendFileSync(eventsPath, `${JSON.stringify(rollbackEvent)}
 `);
   } catch (error93) {
     console.error("Failed to write rollback event:", error93);
@@ -39524,11 +39571,11 @@ async function handleSimulateCommand(directory, args) {
   ];
   const report = reportLines.filter(Boolean).join(`
 `);
-  const fs11 = await import("fs/promises");
+  const fs12 = await import("fs/promises");
   const path23 = await import("path");
   const reportPath = path23.join(directory, ".swarm", "simulate-report.md");
-  await fs11.mkdir(path23.dirname(reportPath), { recursive: true });
-  await fs11.writeFile(reportPath, report, "utf-8");
+  await fs12.mkdir(path23.dirname(reportPath), { recursive: true });
+  await fs12.writeFile(reportPath, report, "utf-8");
   return `${darkMatterPairs.length} hidden coupling pairs detected`;
 }
 
@@ -39929,6 +39976,47 @@ async function executeWriteRetro(args, directory) {
       message: "Invalid summary: must be a non-empty string"
     }, null, 2);
   }
+  if (args.task_id !== undefined) {
+    const tid = args.task_id;
+    if (!tid || tid.length === 0 || tid.length > 200) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: must match pattern"
+      }, null, 2);
+    }
+    if (/\0/.test(tid)) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: contains null bytes"
+      }, null, 2);
+    }
+    for (let i = 0;i < tid.length; i++) {
+      if (tid.charCodeAt(i) < 32) {
+        return JSON.stringify({
+          success: false,
+          phase,
+          message: "Invalid task ID: contains control characters"
+        }, null, 2);
+      }
+    }
+    if (tid.includes("..") || tid.includes("/") || tid.includes("\\")) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: path traversal detected"
+      }, null, 2);
+    }
+    const VALID_TASK_ID = /^(retro-\d+|\d+\.\d+(\.\d+)*)$/;
+    if (!VALID_TASK_ID.test(tid)) {
+      return JSON.stringify({
+        success: false,
+        phase,
+        message: "Invalid task ID: must match pattern"
+      }, null, 2);
+    }
+  }
   const taskId = args.task_id ?? `retro-${phase}`;
   const retroEntry = {
     task_id: taskId,
@@ -40168,6 +40256,10 @@ var COMMAND_REGISTRY = {
     handler: (ctx) => handleResetCommand(ctx.directory, ctx.args),
     description: "Clear swarm state files [--confirm]"
   },
+  "reset-session": {
+    handler: (ctx) => handleResetSessionCommand(ctx.directory, ctx.args),
+    description: "Clear session state while preserving plan, evidence, and knowledge"
+  },
   rollback: {
     handler: (ctx) => handleRollbackCommand(ctx.directory, ctx.args),
     description: "Restore swarm state to a checkpoint <phase>"
@@ -40241,13 +40333,13 @@ var OPENCODE_CONFIG_PATH = path23.join(CONFIG_DIR, "opencode.json");
 var PLUGIN_CONFIG_PATH = path23.join(CONFIG_DIR, "opencode-swarm.json");
 var PROMPTS_DIR = path23.join(CONFIG_DIR, "opencode-swarm");
 function ensureDir(dir) {
-  if (!fs11.existsSync(dir)) {
-    fs11.mkdirSync(dir, { recursive: true });
+  if (!fs12.existsSync(dir)) {
+    fs12.mkdirSync(dir, { recursive: true });
   }
 }
 function loadJson(filepath) {
   try {
-    const content = fs11.readFileSync(filepath, "utf-8");
+    const content = fs12.readFileSync(filepath, "utf-8");
     const stripped = content.replace(/\\"|"(?:\\"|[^"])*"|(\/\/.*|\/\*[\s\S]*?\*\/)/g, (match, comment) => comment ? "" : match).replace(/,(\s*[}\]])/g, "$1");
     return JSON.parse(stripped);
   } catch {
@@ -40255,7 +40347,7 @@ function loadJson(filepath) {
   }
 }
 function saveJson(filepath, data) {
-  fs11.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
+  fs12.writeFileSync(filepath, `${JSON.stringify(data, null, 2)}
 `, "utf-8");
 }
 async function install() {
@@ -40288,7 +40380,7 @@ async function install() {
   saveJson(OPENCODE_CONFIG_PATH, opencodeConfig);
   console.log("\u2713 Added opencode-swarm to OpenCode plugins");
   console.log("\u2713 Disabled default OpenCode agents (explore, general)");
-  if (!fs11.existsSync(PLUGIN_CONFIG_PATH)) {
+  if (!fs12.existsSync(PLUGIN_CONFIG_PATH)) {
     const defaultConfig = {
       agents: {
         coder: { model: "opencode/minimax-m2.5-free" },
@@ -40331,7 +40423,7 @@ async function uninstall() {
 `);
     const opencodeConfig = loadJson(OPENCODE_CONFIG_PATH);
     if (!opencodeConfig) {
-      if (fs11.existsSync(OPENCODE_CONFIG_PATH)) {
+      if (fs12.existsSync(OPENCODE_CONFIG_PATH)) {
         console.log(`\u2717 Could not parse opencode config at: ${OPENCODE_CONFIG_PATH}`);
         return 1;
       } else {
@@ -40363,13 +40455,13 @@ async function uninstall() {
     console.log("\u2713 Re-enabled default OpenCode agents (explore, general)");
     if (process.argv.includes("--clean")) {
       let cleaned = false;
-      if (fs11.existsSync(PLUGIN_CONFIG_PATH)) {
-        fs11.unlinkSync(PLUGIN_CONFIG_PATH);
+      if (fs12.existsSync(PLUGIN_CONFIG_PATH)) {
+        fs12.unlinkSync(PLUGIN_CONFIG_PATH);
         console.log(`\u2713 Removed plugin config: ${PLUGIN_CONFIG_PATH}`);
         cleaned = true;
       }
-      if (fs11.existsSync(PROMPTS_DIR)) {
-        fs11.rmSync(PROMPTS_DIR, { recursive: true });
+      if (fs12.existsSync(PROMPTS_DIR)) {
+        fs12.rmSync(PROMPTS_DIR, { recursive: true });
         console.log(`\u2713 Removed custom prompts: ${PROMPTS_DIR}`);
         cleaned = true;
       }

package/dist/commands/index.d.ts

@@ -21,6 +21,7 @@ export { handlePromoteCommand } from './promote';
 export type { CommandContext, CommandEntry, RegisteredCommand, } from './registry.js';
 export { COMMAND_REGISTRY, resolveCommand, VALID_COMMANDS, } from './registry.js';
 export { handleResetCommand } from './reset';
+export { handleResetSessionCommand } from './reset-session';
 export { handleRetrieveCommand } from './retrieve';
 export { handleRollbackCommand } from './rollback';
 export { handleSimulateCommand } from './simulate';

package/dist/commands/registry.d.ts

@@ -104,6 +104,10 @@ export declare const COMMAND_REGISTRY: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Clear swarm state files [--confirm]";
     };
+    readonly 'reset-session': {
+        readonly handler: (ctx: CommandContext) => Promise<string>;
+        readonly description: "Clear session state while preserving plan, evidence, and knowledge";
+    };
     readonly rollback: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Restore swarm state to a checkpoint <phase>";

package/dist/commands/reset-session.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Handles the /swarm reset-session command.
+ * Deletes only the session state file (.swarm/session/state.json)
+ * and clears in-memory agent sessions. Preserves plan, evidence,
+ * and knowledge for continuity across sessions.
+ */
+export declare function handleResetSessionCommand(directory: string, _args: string[]): Promise<string>;

package/dist/config/schema.d.ts

@@ -313,6 +313,7 @@ export declare const GuardrailsConfigSchema: z.ZodObject<{
     max_consecutive_errors: z.ZodDefault<z.ZodNumber>;
     warning_threshold: z.ZodDefault<z.ZodNumber>;
     idle_timeout_minutes: z.ZodDefault<z.ZodNumber>;
+    no_op_warning_threshold: z.ZodDefault<z.ZodNumber>;
     qa_gates: z.ZodOptional<z.ZodObject<{
         required_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
         require_reviewer_test_engineer: z.ZodDefault<z.ZodBoolean>;
@@ -497,6 +498,11 @@ export declare const PluginConfigSchema: z.ZodObject<{
         }, z.core.$strip>>;
     }, z.core.$strip>>;
     qa_retry_limit: z.ZodDefault<z.ZodNumber>;
+    execution_mode: z.ZodDefault<z.ZodEnum<{
+        strict: "strict";
+        balanced: "balanced";
+        fast: "fast";
+    }>>;
     inject_phase_reminders: z.ZodDefault<z.ZodBoolean>;
     hooks: z.ZodOptional<z.ZodObject<{
         system_enhancer: z.ZodDefault<z.ZodBoolean>;
@@ -585,6 +591,7 @@ export declare const PluginConfigSchema: z.ZodObject<{
         max_consecutive_errors: z.ZodDefault<z.ZodNumber>;
         warning_threshold: z.ZodDefault<z.ZodNumber>;
         idle_timeout_minutes: z.ZodDefault<z.ZodNumber>;
+        no_op_warning_threshold: z.ZodDefault<z.ZodNumber>;
         qa_gates: z.ZodOptional<z.ZodObject<{
             required_tools: z.ZodDefault<z.ZodArray<z.ZodString>>;
             require_reviewer_test_engineer: z.ZodDefault<z.ZodBoolean>;

package/dist/hooks/delegation-gate.d.ts

@@ -6,6 +6,13 @@
  */
 import type { PluginConfig } from '../config';
 import type { DelegationEnvelope, EnvelopeValidationResult } from '../types/delegation.js';
+/**
+ * v6.33.1 CRIT-1: Fallback map for declared coder scope by taskId.
+ * When messagesTransform sets declaredCoderScope on the architect session,
+ * the coder session may not exist yet. This map allows scope-guard to look up
+ * the scope by taskId when the session's declaredCoderScope is null.
+ */
+export declare const pendingCoderScopeByTaskId: Map<string, string[]>;
 /**
  * Parses a string to extract a DelegationEnvelope.
  * Returns null if no valid envelope is found.

package/dist/hooks/delegation-gate.verify.test.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Verification tests for callID→evidenceTaskId map in delegation-gate.ts
+ *
+ * Tests verify the map behavior indirectly through evidence recording outcomes:
+ * 1. Map stores callID→evidenceTaskId after determining the taskId
+ * 2. Map is checked first before getEvidenceTaskId fallback
+ * 3. Map entry is cleaned up after successful evidence recording
+ * 4. Map entry is cleaned up even when evidence recording errors
+ * 5. Fallback works when storedTaskId is not in map
+ */
+export {};

package/dist/hooks/scope-guard.d.ts

@@ -23,7 +23,7 @@ export interface ScopeGuardConfig {
  * @param _directory - The workspace directory (reserved for future use)
  * @param injectAdvisory - Optional callback to push advisory to architect session
  */
-export declare function createScopeGuardHook(config: Partial<ScopeGuardConfig>, _directory: string, injectAdvisory?: (sessionId: string, message: string) => void): {
+export declare function createScopeGuardHook(config: Partial<ScopeGuardConfig>, directory: string, injectAdvisory?: (sessionId: string, message: string) => void): {
     toolBefore: (input: {
         tool: string;
         sessionID: string;
@@ -40,4 +40,4 @@ export declare function createScopeGuardHook(config: Partial<ScopeGuardConfig>,
  * @param scopeEntries - Array of declared scope entries (files or directories)
  * @returns true if the file is within scope, false otherwise
  */
-export declare function isFileInScope(filePath: string, scopeEntries: string[]): boolean;
+export declare function isFileInScope(filePath: string, scopeEntries: string[], directory?: string): boolean;

package/dist/hooks/trajectory-logger.d.ts

@@ -0,0 +1,57 @@
+/**
+ * TRAJECTORY LOGGER (v6.31 Task 3.2)
+ *
+ * tool.execute.after hook that appends per-task tool call trajectories to a
+ * .swarm/evidence/{taskId}/trajectory.jsonl file. Only logs INSIDE delegation
+ * scope (when delegationActive is true on the session).
+ *
+ * Trajectories are used for post-hoc analysis, audit trails, and replay.
+ */
+export interface TrajectoryConfig {
+    enabled: boolean;
+    max_lines: number;
+}
+export interface TrajectoryEntry {
+    tool: string;
+    args_summary: string;
+    verdict: string;
+    timestamp: string;
+    agent: string;
+    elapsed_ms: number;
+}
+/**
+ * Truncates a trajectory file to the newest half when maxLines is exceeded.
+ * Reads all lines, keeps the newest half, rewrites the file.
+ *
+ * @param filePath - Absolute path to the trajectory.jsonl file
+ * @param maxLines - Maximum number of lines to retain
+ */
+export declare function truncateTrajectoryFile(filePath: string, maxLines: number): Promise<void>;
+/**
+ * Creates the trajectory logger hook pair.
+ *
+ * @param config - TrajectoryConfig { enabled: boolean (default true), max_lines: number (default 500) }
+ * @param _directory - Reserved for future use (evidence path derived from session taskId)
+ * @returns Object with toolAfter handler
+ */
+export declare function createTrajectoryLoggerHook(config: Partial<TrajectoryConfig>, _directory: string): {
+    toolAfter: (input: {
+        tool: string;
+        sessionID: string;
+        callID: string;
+        args?: Record<string, unknown>;
+    }, output: {
+        title: string;
+        output: string;
+        metadata: unknown;
+    }) => Promise<void>;
+};
+/**
+ * Records the start time for a tool call (called from toolBefore).
+ * Stored in a module-level Map for correlation with toolAfter.
+ *
+ * @param sessionId - Session identifier
+ * @param callID - Tool call identifier
+ * @param startTime - Start timestamp in milliseconds
+ */
+export declare function recordToolCallStart(sessionId: string, callID: string, startTime: number): void;