opencode-swarm 6.80.2 → 6.81.1

package/dist/prm/__tests__/course-correction.test.d.ts

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

package/dist/prm/__tests__/escalation-queue-drain.test.d.ts

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

package/dist/prm/__tests__/escalation.test.d.ts

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

package/dist/prm/__tests__/index.test.d.ts

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

package/dist/prm/__tests__/integration.test.d.ts

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

package/dist/prm/__tests__/pattern-detector.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * PRM Pattern Detector Tests
+ * Comprehensive tests for all 5 pattern detectors and orchestration function
+ */
+export {};

package/dist/prm/__tests__/replay.test.d.ts

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

package/dist/prm/__tests__/trajectory-store.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * TRAJECTORY STORE TESTS
+ *
+ * Unit tests for the session-level trajectory storage module.
+ * Uses real file operations in a temp directory to verify behavior.
+ */
+export {};

package/dist/prm/course-correction.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Course Correction Module
+ * Generates structured guidance messages from pattern detection results
+ */
+import type { CourseCorrection, PatternMatch, TrajectoryEntry } from './types';
+/**
+ * Generates a structured CourseCorrection guidance message from a PatternMatch and trajectory context
+ *
+ * @param match - The pattern match result from pattern detection
+ * @param trajectory - The trajectory entries providing context for the correction
+ * @returns A structured CourseCorrection object with alert, category, guidance, action, pattern, and stepRange
+ */
+export declare function generateCourseCorrection(match: PatternMatch, trajectory: TrajectoryEntry[]): CourseCorrection;
+/**
+ * Formats a CourseCorrection for injection into agent messages
+ *
+ * @param correction - The course correction to format
+ * @returns A formatted string suitable for injection into messages
+ */
+export declare function formatCourseCorrectionForInjection(correction: CourseCorrection): string;

package/dist/prm/escalation.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Escalation Tracker Module
+ * Implements a 3-strike protocol for pattern detection escalation
+ */
+import type { CourseCorrection, EscalationState, PatternMatch } from './types';
+/**
+ * Creates a default EscalationState with all counters reset and flags cleared.
+ * Exported for testing purposes.
+ *
+ * @returns A fresh EscalationState with default values
+ */
+export declare function createDefaultEscalationState(): EscalationState;
+/**
+ * EscalationTracker
+ *
+ * Tracks pattern detection counts per session and implements a 3-strike escalation protocol:
+ * - Level 1 (1st detection): Guidance via pendingAdvisoryMessages
+ * - Level 2 (2nd detection): Stronger guidance + architect alert via telemetry
+ * - Level 3 (3rd+ detection): Hard stop flag that is read by messagesTransform
+ *
+ * All methods are safe and never throw errors.
+ */
+export declare class EscalationTracker {
+    private readonly _sessionId;
+    private _state;
+    /**
+     * Creates a new EscalationTracker for the given session.
+     *
+     * @param sessionId - The session identifier
+     * @param initialState - Optional initial state to restore (for session resumption)
+     */
+    constructor(sessionId: string, initialState?: EscalationState);
+    /**
+     * Records a pattern detection and determines the escalation level.
+     * Updates internal state based on the 3-strike protocol.
+     *
+     * @param match - The pattern match to record
+     * @returns An object containing the escalation level, correction (if any), and hard stop flag
+     */
+    recordDetection(match: PatternMatch): {
+        level: number;
+        correction: CourseCorrection | null;
+        hardStop: boolean;
+    };
+    /**
+     * Returns the current escalation state.
+     *
+     * @returns The current EscalationState (reference, not a copy)
+     */
+    getState(): EscalationState;
+    /**
+     * Resets all escalation counts and flags to their default values.
+     * Clears pattern counts, corrections pending, and all flags.
+     */
+    reset(): void;
+    /**
+     * Returns all pending course corrections.
+     *
+     * @returns Array of pending CourseCorrection objects
+     */
+    getPendingCorrections(): CourseCorrection[];
+    /**
+     * Clears all pending course corrections.
+     */
+    clearPendingCorrections(): void;
+    /**
+     * Returns whether a hard stop is pending.
+     * This flag is read by messagesTransform to halt agent execution.
+     *
+     * @returns true if hard stop is pending, false otherwise
+     */
+    isHardStopPending(): boolean;
+}

package/dist/prm/index.d.ts

@@ -0,0 +1,58 @@
+/**
+ * PRM (Process Remediation Manager) Facade
+ *
+ * Integration layer that wires together all PRM components:
+ * - Trajectory logging via trajectory-store
+ * - Pattern detection via pattern-detector
+ * - Course correction via course-correction
+ * - Escalation tracking via escalation
+ *
+ * This module provides the createPrmHook factory that returns the toolAfter
+ * handler used by the swarm hook system. PRM replaces loop-detector.ts for
+ * repetition_loop detection, but loop-detector.ts is kept as a fast circuit
+ * breaker for backward compatibility.
+ */
+export { formatCourseCorrectionForInjection, generateCourseCorrection, } from './course-correction';
+export { createDefaultEscalationState, EscalationTracker } from './escalation';
+export { detectContextThrash, detectExpansionDrift, detectPatterns, detectPingPong, detectRepetitionLoop, detectStuckOnTest, } from './pattern-detector';
+export type { CourseCorrection, EscalationState, PatternDetectionResult, PatternMatch, PatternSeverity, PatternType, PrmConfig, TaxonomyCategory, TrajectoryEntry, } from './types';
+import type { PrmConfig } from './types';
+/**
+ * Context passed to toolAfter handler
+ */
+interface ToolAfterContext {
+    sessionID: string;
+    tool?: string;
+    args_summary?: string;
+    result?: 'success' | 'failure' | 'pending';
+}
+/**
+ * PRM hook interface returned by createPrmHook
+ */
+interface PrmHook {
+    toolAfter: (context: ToolAfterContext) => Promise<void>;
+}
+/**
+ * Creates a PRM hook for the given configuration.
+ *
+ * The returned toolAfter handler:
+ * - Runs after each tool execution when PRM is enabled
+ * - Reads the session trajectory
+ * - Runs pattern detection
+ * - Generates course corrections for detected patterns
+ * - Updates session state with corrections and escalation level
+ * - Emits telemetry events
+ *
+ * This function is non-blocking: errors are caught and logged, never thrown.
+ *
+ * @param config - PRM configuration (enabled, thresholds, etc.)
+ * @param directory - Project directory for trajectory storage
+ * @returns PrmHook with toolAfter handler
+ *
+ * @example
+ * ```typescript
+ * const prmHook = createPrmHook(prmConfig, directory);
+ * // Wire prmHook.toolAfter into your tool.execute.after hook
+ * ```
+ */
+export declare function createPrmHook(config: PrmConfig, directory: string): PrmHook;

package/dist/prm/pattern-detector.d.ts

@@ -0,0 +1,71 @@
+/**
+ * PRM Pattern Detector
+ * Rule-based pattern detection for trajectory analysis
+ */
+import type { PatternDetectionResult, PatternMatch, PrmConfig, TrajectoryEntry } from './types';
+/**
+ * Sanitize a string to prevent prompt injection attacks.
+ * Removes newlines, carriage returns, backticks, and common injection patterns.
+ * Limits length to prevent overflow.
+ *
+ * @param input - The string to sanitize
+ * @returns Sanitized string safe for embedding in prompts
+ */
+export declare function sanitizeString(input: string): string;
+/**
+ * Detect repetition_loop pattern
+ * Same agent targets same file with same action within N steps
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectRepetitionLoop(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect ping_pong pattern
+ * Agent A delegates to B, B completes, A delegates to B again
+ * Alternating agent patterns with same target
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectPingPong(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect expansion_drift pattern
+ * Successive plans grow in scope (unique targets increase >50%)
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectExpansionDrift(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect stuck_on_test pattern
+ * Edit -> test fail -> edit same file cycle
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectStuckOnTest(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Detect context_thrash pattern
+ * Agent requests increasingly large file sets (monotonic increase in unique targets)
+ * Context thrash is detected when the agent keeps introducing NEW targets without
+ * revisiting old ones - i.e., the unique target count increases for consecutive steps
+ * with NO plateaus in between.
+ *
+ * @param trajectory - Array of trajectory entries
+ * @param config - PRM configuration
+ * @returns Array of detected pattern matches
+ */
+export declare function detectContextThrash(trajectory: TrajectoryEntry[], config: PrmConfig): PatternMatch[];
+/**
+ * Run all pattern detectors on a trajectory
+ *
+ * @param trajectory - Array of trajectory entries to analyze
+ * @param config - PRM configuration with thresholds
+ * @returns PatternDetectionResult with all matches and timing info
+ */
+export declare function detectPatterns(trajectory: TrajectoryEntry[], config: PrmConfig, lastProcessedStep?: number): PatternDetectionResult;

package/dist/prm/replay.d.ts

@@ -0,0 +1,44 @@
+/**
+ * PRM Replay System
+ *
+ * Provides deterministic replay functionality for PRM (Process Remediation Manager).
+ * Records all LLM requests/responses and tool I/O during a run for replay.
+ *
+ * Replay artifacts are stored in `.swarm/replays/{sessionId}-{timestamp}.jsonl`
+ */
+/**
+ * Entry types for replay recording
+ */
+export type ReplayEntryType = 'llm_request' | 'llm_response' | 'tool_call' | 'tool_result' | 'pattern_detected' | 'course_correction' | 'escalation' | 'hard_stop';
+/**
+ * A single entry in the replay log
+ */
+export interface ReplayEntry {
+    /** ISO 8601 timestamp when entry was recorded */
+    timestamp: string;
+    /** Session identifier */
+    sessionID: string;
+    /** Type of replay entry */
+    type: ReplayEntryType;
+    /** Entry data payload */
+    data: Record<string, unknown>;
+}
+/**
+ * Initializes replay recording for a session.
+ * Creates the replay directory if it doesn't exist.
+ * Non-blocking: errors are caught and logged, returns null on failure.
+ *
+ * @param sessionID - Session identifier
+ * @param directory - Project directory
+ * @returns Path to the replay artifact file, or null on error
+ */
+export declare function startReplayRecording(sessionID: string, directory: string): Promise<string | null>;
+/**
+ * Appends a ReplayEntry to the replay artifact file.
+ * Non-blocking: errors are caught and logged, never thrown.
+ *
+ * @param artifactPath - Path to the replay artifact file
+ * @param sessionID - Session identifier
+ * @param entry - Entry to record (without timestamp/sessionID)
+ */
+export declare function recordReplayEntry(artifactPath: string, sessionID: string, entry: Omit<ReplayEntry, 'timestamp' | 'sessionID'>): Promise<void>;

package/dist/prm/trajectory-store.d.ts

@@ -0,0 +1,66 @@
+/**
+ * TRAJECTORY STORE (Session-Level)
+ *
+ * Per-session trajectory storage for PRM pattern detection.
+ * Writes to .swarm/trajectories/{sessionId}.jsonl
+ *
+ * Coexists with task-level trajectory-logger.ts which writes to
+ * .swarm/evidence/{taskId}/trajectory.jsonl for audit/evidence.
+ */
+import type { TrajectoryEntry } from './types';
+/**
+ * Returns cached trajectory entries for a session (empty array if not cached).
+ */
+export declare function getInMemoryTrajectory(sessionId: string): TrajectoryEntry[];
+/**
+ * Clears trajectory cache (for test isolation or session cleanup).
+ */
+export declare function clearTrajectoryCache(sessionId?: string): void;
+/**
+ * Appends a single TrajectoryEntry to the session's trajectory file.
+ *
+ * @param sessionId - Session identifier
+ * @param entry - Trajectory entry to append
+ * @param directory - Base directory (workspace root)
+ * @param maxLines - Maximum lines before in-memory cache trimming (default 1000)
+ */
+export declare function appendTrajectoryEntry(sessionId: string, entry: TrajectoryEntry, directory: string, maxLines?: number): Promise<void>;
+/**
+ * Reads all TrajectoryEntry records from a session's trajectory file.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @returns Array of trajectory entries (empty array if file doesn't exist)
+ */
+export declare function readTrajectory(sessionId: string, directory: string): Promise<TrajectoryEntry[]>;
+/**
+ * Alias for readTrajectory - retrieves trajectory entries for a session.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @returns Array of trajectory entries
+ */
+export declare function getTrajectoryForSession(sessionId: string, directory: string): Promise<TrajectoryEntry[]>;
+/**
+ * Truncates the trajectory file to the newest half if lines exceed maxLines.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @param maxLines - Maximum number of lines to retain
+ */
+export declare function truncateTrajectoryIfNeeded(sessionId: string, directory: string, maxLines: number): Promise<void>;
+/**
+ * Returns the highest step number in the session's trajectory.
+ * Used to determine the next step number when appending.
+ *
+ * @param sessionId - Session identifier
+ * @param directory - Base directory (workspace root)
+ * @returns Highest step number, or 0 if no trajectory exists
+ */
+export declare function getCurrentStep(sessionId: string, directory: string): Promise<number>;
+/**
+ * Deletes trajectory and replay files older than maxAgeDays.
+ * Runs against .swarm/trajectories/ and .swarm/replays/ directories.
+ * Non-blocking: errors logged, not thrown.
+ */
+export declare function cleanupOldTrajectoryFiles(directory: string, maxAgeDays?: number): Promise<void>;

package/dist/prm/types.d.ts

@@ -0,0 +1,120 @@
+/**
+ * PRM (Prompt Response Monitoring) Type Definitions
+ * Core types for trajectory logging, pattern detection, and course correction
+ */
+/**
+ * All detectable pattern types in the SWE-PRM system
+ */
+export type PatternType = 'repetition_loop' | 'ping_pong' | 'expansion_drift' | 'stuck_on_test' | 'context_thrash';
+/**
+ * SWE-PRM taxonomy classification for categorizing pattern root causes
+ */
+export type TaxonomyCategory = 'specification_error' | 'reasoning_error' | 'coordination_error';
+/**
+ * Severity levels for pattern detection responses
+ */
+export type PatternSeverity = 'low' | 'medium' | 'high' | 'critical';
+/**
+ * A single trajectory log entry recording one agent action
+ */
+export interface TrajectoryEntry {
+    /** Sequential step number (1-indexed) */
+    step: number;
+    /** Agent name */
+    agent: string;
+    /** Action type (plan, edit, review, test, delegate, etc.) */
+    action: string;
+    /** File or task being targeted */
+    target: string;
+    /** Human-readable description of intended outcome */
+    intent: string;
+    /** ISO 8601 timestamp */
+    timestamp: string;
+    /** Outcome of the action */
+    result: 'success' | 'failure' | 'pending';
+    /** Optional: tool name (for compatibility with existing logger) */
+    tool?: string;
+    /** Optional: tool arguments summary */
+    args_summary?: string;
+    /** Optional: elapsed time in milliseconds */
+    elapsed_ms?: number;
+}
+/**
+ * Result of pattern detection indicating a detected problematic trajectory pattern
+ */
+export interface PatternMatch {
+    /** The type of pattern detected */
+    pattern: PatternType;
+    /** Severity level of the detected pattern */
+    severity: PatternSeverity;
+    /** Taxonomy category for the pattern */
+    category: TaxonomyCategory;
+    /** Start and end step numbers of the pattern occurrence */
+    stepRange: [number, number];
+    /** Human-readable description of the pattern */
+    description: string;
+    /** Agents involved in the pattern */
+    affectedAgents: string[];
+    /** Files/tasks involved in the pattern */
+    affectedTargets: string[];
+    /** How many times this pattern has been detected */
+    occurrenceCount: number;
+}
+/**
+ * Structured guidance message for steering agent behavior
+ */
+export interface CourseCorrection {
+    /** Alert header with pattern context */
+    alert: string;
+    /** Taxonomy category of the underlying issue */
+    category: TaxonomyCategory;
+    /** Concrete next-step instruction */
+    guidance: string;
+    /** Specific action to take */
+    action: string;
+    /** Pattern type being addressed */
+    pattern: PatternType;
+    /** Step range where the pattern was detected */
+    stepRange: [number, number];
+}
+/**
+ * Aggregate result from running all pattern detectors
+ */
+export interface PatternDetectionResult {
+    /** All pattern matches found in this detection pass */
+    matches: PatternMatch[];
+    /** Time taken to run detection in milliseconds */
+    detectionTimeMs: number;
+    /** Number of patterns checked in this pass */
+    patternsChecked: number;
+}
+/**
+ * Configuration for the PRM system
+ */
+export interface PrmConfig {
+    /** Whether PRM is enabled */
+    enabled: boolean;
+    /** Threshold per pattern type (number of occurrences before alert) */
+    pattern_thresholds: Record<PatternType, number>;
+    /** Max trajectory lines before truncation */
+    max_trajectory_lines: number;
+    /** Whether 3-strike escalation is active */
+    escalation_enabled: boolean;
+    /** Max time for detection in milliseconds */
+    detection_timeout_ms: number;
+}
+/**
+ * Per-session escalation tracking state
+ */
+export interface EscalationState {
+    /** Pattern type to detection count mapping */
+    patternCounts: Map<PatternType, number>;
+    /** Current escalation level (0=none, 1=guidance, 2=strong guidance, 3=hard stop) */
+    escalationLevel: number;
+    /** Last pattern detected (if any) */
+    lastPatternDetected: PatternMatch | null;
+    /** Whether a hard stop has been triggered */
+    hardStopPending: boolean;
+    /** Queue of correction messages to inject */
+    correctionsPending: CourseCorrection[];
+}

package/dist/state.d.ts

@@ -9,6 +9,8 @@
 import type { OpencodeClient } from '@opencode-ai/sdk';
 import { type QaGates } from './db/qa-gate-profile.js';
 import { type EnvironmentProfile } from './environment/profile.js';
+import type { EscalationTracker } from './prm/escalation.js';
+import type { PatternMatch } from './prm/types.js';
 import { AgentRunContext } from './state/agent-run-context.js';
 export { AgentRunContext } from './state/agent-run-context.js';
 /**
@@ -179,6 +181,18 @@ export interface AgentSessionState {
     pendingAdvisoryMessages?: string[];
     /** Timestamp when session was rehydrated from snapshot (0 if never rehydrated) */
     sessionRehydratedAt: number;
+    /** Pattern type to detection count mapping */
+    prmPatternCounts: Map<string, number>;
+    /** Current escalation level (0=none, 1=guidance, 2=strong guidance, 3=hard stop) */
+    prmEscalationLevel: number;
+    /** Last pattern detected (if any) */
+    prmLastPatternDetected: PatternMatch | null;
+    /** Current trajectory step counter */
+    prmTrajectoryStep: number;
+    /** Whether a hard stop has been triggered */
+    prmHardStopPending: boolean;
+    /** Per-session escalation tracker instance (set lazily by PRM hook) */
+    prmEscalationTracker?: EscalationTracker;
 }
 /**
  * Represents a single agent invocation window with isolated guardrail budgets.

package/dist/telemetry.d.ts

@@ -1,4 +1,4 @@
-export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'phase_changed' | 'budget_updated' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry';
+export type TelemetryEvent = 'session_started' | 'session_ended' | 'agent_activated' | 'delegation_begin' | 'delegation_end' | 'task_state_changed' | 'gate_passed' | 'gate_failed' | 'phase_changed' | 'budget_updated' | 'model_fallback' | 'hard_limit_hit' | 'revision_limit_hit' | 'loop_detected' | 'scope_violation' | 'qa_skip_violation' | 'heartbeat' | 'turbo_mode_changed' | 'auto_oversight_escalation' | 'environment_detected' | 'evidence_lock_acquired' | 'evidence_lock_contended' | 'evidence_lock_stale_recovered' | 'plan_ledger_cas_retry' | 'prm_pattern_detected' | 'prm_course_correction_injected' | 'prm_escalation_triggered' | 'prm_hard_stop';
 export type TelemetryListener = (event: TelemetryEvent, data: Record<string, unknown>) => void;
 /** @internal - For testing only */
 export declare function resetTelemetryForTesting(): void;
@@ -52,4 +52,8 @@ export declare const telemetry: {
     turboModeChanged(sessionId: string, enabled: boolean, agentName: string): void;
     autoOversightEscalation(sessionId: string, reason: string, interactionCount: number, deadlockCount: number, phase?: number): void;
     environmentDetected(sessionId: string, hostOS: string, shellFamily: string, executionMode: string): void;
+    prmPatternDetected(sessionId: string, pattern: string, severity: string, category: string, stepRange: [number, number]): void;
+    prmCourseCorrectionInjected(sessionId: string, pattern: string, level: number): void;
+    prmEscalationTriggered(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
+    prmHardStop(sessionId: string, pattern: string, level: number, occurrenceCount: number): void;
 };

package/dist/types/events.d.ts

@@ -90,4 +90,36 @@ export interface SpecDriftAcknowledgedEvent {
     previousHash: string;
     newHash: string | null;
 }
-export type V619Event = SoundingBoardConsultedEvent | ArchitectLoopDetectedEvent | PrecedentManipulationDetectedEvent | CoderSelfAuditEvent | CoderRetryCircuitBreakerEvent | AgentConflictDetectedEvent | AuthorityHandoffResolvedEvent | SpecStaleDetectedEvent | SpecDriftAcknowledgedEvent;
+export interface PrmPatternDetectedEvent {
+    type: 'prm_pattern_detected';
+    timestamp: string;
+    sessionId: string;
+    pattern: string;
+    severity: string;
+    category: string;
+    stepRange: [number, number];
+}
+export interface PrmCourseCorrectionInjectedEvent {
+    type: 'prm_course_correction_injected';
+    timestamp: string;
+    sessionId: string;
+    pattern: string;
+    level: number;
+}
+export interface PrmEscalationTriggeredEvent {
+    type: 'prm_escalation_triggered';
+    timestamp: string;
+    sessionId: string;
+    pattern: string;
+    level: number;
+    occurrenceCount: number;
+}
+export interface PrmHardStopEvent {
+    type: 'prm_hard_stop';
+    timestamp: string;
+    sessionId: string;
+    pattern: string;
+    level: number;
+    occurrenceCount: number;
+}
+export type V619Event = SoundingBoardConsultedEvent | ArchitectLoopDetectedEvent | PrecedentManipulationDetectedEvent | CoderSelfAuditEvent | CoderRetryCircuitBreakerEvent | AgentConflictDetectedEvent | AuthorityHandoffResolvedEvent | SpecStaleDetectedEvent | SpecDriftAcknowledgedEvent | PrmPatternDetectedEvent | PrmCourseCorrectionInjectedEvent | PrmEscalationTriggeredEvent | PrmHardStopEvent;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "6.80.2",
+	"version": "6.81.1",
 	"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",