opencode-swarm 6.80.2 → 6.81.0

package/README.md

@@ -91,6 +91,60 @@ All project state lives in `.swarm/`:
 
 Swarm is resumable by design. If `.swarm/` already exists, the architect goes straight into **RESUME** → **EXECUTE** instead of repeating discovery.
 
+## Process Remediation Model (PRM)
+
+Swarm includes a lightweight Process Remediation Model that monitors agent trajectories and injects course-correction guidance before loops form. Based on research from SWE-PRM (arXiv 2509.02360), taxonomy-guided PRMs improve task resolution by detecting failure patterns early.
+
+### Detected Patterns
+
+The PRM detects five trajectory patterns:
+
+1. **Repetition Loop** — Same agent performs the same action on the same target file repeatedly
+2. **Ping-Pong** — Agent A hands off to B, B hands back to A, and A hands to B again
+3. **Expansion Drift** — Successive plans grow in scope beyond the original task
+4. **Stuck-on-Test** — Coder edits → tests fail → coder edits same file → tests fail, repeating
+5. **Context Thrashing** — Agent requests increasingly large file sets without narrowing scope
+
+### Escalation Protocol
+
+When a pattern is detected, the PRM tracks escalation levels:
+
+- **Level 1 (1st detection):** Course-correction guidance is added to `pendingAdvisoryMessages` and injected via the `[ADVISORIES]` block. Sets `escalationLevel = 1`.
+- **Level 2 (2nd detection):** Additional guidance added to `pendingAdvisoryMessages`, `architectAlertPending = true` is set, and `telemetry.prmEscalationTriggered()` is emitted. Sets `escalationLevel = 2`.
+- **Level 3 (3rd+ detection):** Guidance added to `pendingAdvisoryMessages`, plus a hard stop directive is injected separately via `[HARD STOP]` block. Sets `escalationLevel = 3` and `hardStopPending = true`. Emits `telemetry.prmHardStop()`.
+
+### Configuration
+
+PRM behavior is controlled via the `prm` section in your configuration:
+
+```json
+{
+  "prm": {
+    "enabled": true,
+    "pattern_thresholds": {
+      "repetition_loop": 2,
+      "ping_pong": 4,
+      "expansion_drift": 3,
+      "stuck_on_test": 3,
+      "context_thrash": 5
+    },
+    "max_trajectory_lines": 100,
+    "escalation_enabled": true,
+    "detection_timeout_ms": 5000
+  }
+}
+```
+
+> **Note:** `max_trajectory_lines`, `escalation_enabled`, and `detection_timeout_ms` are defined in the schema but not yet enforced at runtime. The default trajectory limit is 1000 lines.
+
+### Replay Recording
+
+PRM records all pattern detections, course corrections, escalations, and hard stops to `.swarm/replays/{sessionId}-{timestamp}.jsonl` for post-mortem analysis. Use the replay artifacts to understand why loops formed and how they were resolved.
+
+### Performance
+
+Pattern detection runs in less than 100ms per step using rule-based analysis — no LLM calls required for detection.
+
 ---
 
 ## Quick Start

package/dist/cli/index.js

@@ -19424,6 +19424,25 @@ var CompactionConfigSchema = exports_external.object({
   emergencyThreshold: exports_external.number().min(1).max(99).default(80),
   preserveLastNTurns: exports_external.number().int().min(1).default(5)
 });
+var PrmConfigSchema = exports_external.object({
+  enabled: exports_external.boolean().default(true),
+  pattern_thresholds: exports_external.object({
+    repetition_loop: exports_external.number().min(1).default(2),
+    ping_pong: exports_external.number().min(1).default(2),
+    expansion_drift: exports_external.number().min(1).default(3),
+    stuck_on_test: exports_external.number().min(1).default(3),
+    context_thrash: exports_external.number().min(1).default(3)
+  }).default(() => ({
+    repetition_loop: 2,
+    ping_pong: 2,
+    expansion_drift: 3,
+    stuck_on_test: 3,
+    context_thrash: 3
+  })),
+  max_trajectory_lines: exports_external.number().min(10).default(1000),
+  escalation_enabled: exports_external.boolean().default(true),
+  detection_timeout_ms: exports_external.number().min(10).default(100)
+});
 var AgentAuthorityRuleSchema = exports_external.object({
   readOnly: exports_external.boolean().optional(),
   blockedExact: exports_external.array(exports_external.string()).optional(),
@@ -19504,6 +19523,7 @@ var PluginConfigSchema = exports_external.object({
   }).optional(),
   incremental_verify: IncrementalVerifyConfigSchema.optional(),
   compaction_service: CompactionConfigSchema.optional(),
+  prm: PrmConfigSchema.optional(),
   council: CouncilConfigSchema.optional(),
   parallelization: ParallelizationConfigSchema.optional(),
   turbo_mode: exports_external.boolean().default(false).optional(),

package/dist/config/schema.d.ts

@@ -477,6 +477,20 @@ export declare const CompactionConfigSchema: z.ZodObject<{
     preserveLastNTurns: z.ZodDefault<z.ZodNumber>;
 }, z.core.$strip>;
 export type CompactionConfig = z.infer<typeof CompactionConfigSchema>;
+export declare const PrmConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    pattern_thresholds: z.ZodDefault<z.ZodObject<{
+        repetition_loop: z.ZodDefault<z.ZodNumber>;
+        ping_pong: z.ZodDefault<z.ZodNumber>;
+        expansion_drift: z.ZodDefault<z.ZodNumber>;
+        stuck_on_test: z.ZodDefault<z.ZodNumber>;
+        context_thrash: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    max_trajectory_lines: z.ZodDefault<z.ZodNumber>;
+    escalation_enabled: z.ZodDefault<z.ZodBoolean>;
+    detection_timeout_ms: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type PrmConfig = z.infer<typeof PrmConfigSchema>;
 export declare const AgentAuthorityRuleSchema: z.ZodObject<{
     readOnly: z.ZodOptional<z.ZodBoolean>;
     blockedExact: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -886,6 +900,19 @@ export declare const PluginConfigSchema: z.ZodObject<{
         emergencyThreshold: z.ZodDefault<z.ZodNumber>;
         preserveLastNTurns: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strip>>;
+    prm: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        pattern_thresholds: z.ZodDefault<z.ZodObject<{
+            repetition_loop: z.ZodDefault<z.ZodNumber>;
+            ping_pong: z.ZodDefault<z.ZodNumber>;
+            expansion_drift: z.ZodDefault<z.ZodNumber>;
+            stuck_on_test: z.ZodDefault<z.ZodNumber>;
+            context_thrash: z.ZodDefault<z.ZodNumber>;
+        }, z.core.$strip>>;
+        max_trajectory_lines: z.ZodDefault<z.ZodNumber>;
+        escalation_enabled: z.ZodDefault<z.ZodBoolean>;
+        detection_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
     council: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodBoolean>;
         maxRounds: z.ZodDefault<z.ZodNumber>;

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

@@ -12,11 +12,16 @@ export interface TrajectoryConfig {
     max_lines: number;
 }
 export interface TrajectoryEntry {
+    step: number;
+    agent: string;
+    action: string;
+    target: string;
+    intent: string;
+    timestamp: string;
+    result: 'success' | 'failure' | 'pending';
     tool: string;
     args_summary: string;
     verdict: string;
-    timestamp: string;
-    agent: string;
     elapsed_ms: number;
 }
 /**
@@ -46,6 +51,13 @@ export declare function createTrajectoryLoggerHook(config: Partial<TrajectoryCon
         metadata: unknown;
     }) => Promise<void>;
 };
+/**
+ * Resets the step counter for a session. Called when a new session starts
+ * or when trajectory tracking should restart from step 1.
+ *
+ * @param sessionId - Session identifier
+ */
+export declare function resetTrajectoryStep(sessionId: string): void;
 /**
  * Records the start time for a tool call (called from toolBefore).
  * Stored in a module-level Map for correlation with toolAfter.