opencode-swarm 7.0.0-beta.1 → 7.0.0

package/dist/parallel/file-locks.d.ts

@@ -0,0 +1,40 @@
+export interface FileLock {
+    filePath: string;
+    agent: string;
+    taskId: string;
+    timestamp: string;
+    expiresAt: number;
+    _release?: () => Promise<void>;
+}
+/**
+ * Try to acquire a lock on a file using proper-lockfile
+ */
+export declare function tryAcquireLock(directory: string, filePath: string, agent: string, taskId: string): Promise<{
+    acquired: true;
+    lock: FileLock;
+} | {
+    acquired: false;
+    existing?: FileLock;
+}>;
+/**
+ * Release a lock on a file.
+ *
+ * The preferred release path is `lockResult.lock._release()` at the call site.
+ * This function is kept for API compatibility but is a no-op: callers that
+ * stored a proper-lockfile release function on `lock._release` should call
+ * that directly.  Callers that do not have the release function (e.g. tests
+ * that write lock sentinel files by hand) can ignore the return value.
+ */
+export declare function releaseLock(_directory: string, _filePath: string, _taskId: string): Promise<boolean>;
+/**
+ * Check if a file is locked
+ */
+export declare function isLocked(directory: string, filePath: string): FileLock | null;
+/**
+ * Clean up expired locks
+ */
+export declare function cleanupExpiredLocks(directory: string): number;
+/**
+ * List all active locks
+ */
+export declare function listActiveLocks(directory: string): FileLock[];

package/dist/parallel/index.d.ts

@@ -0,0 +1,5 @@
+export { EvidenceLockTimeoutError, withEvidenceLock, } from '../evidence/lock.js';
+export { type DependencyGraph, getDependencyChain, getExecutionOrder, getRunnableTasks, isTaskBlocked, parseDependencyGraph, type TaskNode, } from './dependency-graph.js';
+export { cleanupExpiredLocks, type FileLock, isLocked, listActiveLocks, releaseLock, tryAcquireLock, } from './file-locks.js';
+export { extractMetaSummaries, getLatestTaskSummary, indexMetaSummaries, type MetaSummaryEntry, querySummaries, } from './meta-indexer.js';
+export { type ComplexityMetrics, computeComplexity, type ReviewDepth, type ReviewRouting, routeReview, routeReviewForChanges, shouldParallelizeReview, } from './review-router.js';

package/dist/parallel/meta-indexer.d.ts

@@ -0,0 +1,32 @@
+export interface MetaSummaryEntry {
+    timestamp: string;
+    phase?: number;
+    taskId?: string;
+    agent?: string;
+    summary: string;
+    source?: string;
+}
+/**
+ * Extract meta.summary from event JSONL files
+ */
+export declare function extractMetaSummaries(eventsPath: string): MetaSummaryEntry[];
+/**
+ * Index meta summaries to external knowledge store
+ */
+export declare function indexMetaSummaries(directory: string, externalKnowledgeDir?: string): Promise<{
+    indexed: number;
+    path: string;
+}>;
+/**
+ * Query indexed summaries
+ */
+export declare function querySummaries(directory: string, options?: {
+    phase?: number;
+    taskId?: string;
+    agent?: string;
+    since?: string;
+}): MetaSummaryEntry[];
+/**
+ * Get latest summary for a task
+ */
+export declare function getLatestTaskSummary(directory: string, taskId: string): MetaSummaryEntry | undefined;

package/dist/parallel/review-router.d.ts

@@ -0,0 +1,29 @@
+export type ReviewDepth = 'single' | 'double';
+export interface ReviewRouting {
+    reviewerCount: number;
+    testEngineerCount: number;
+    depth: ReviewDepth;
+    reason: string;
+}
+export interface ComplexityMetrics {
+    fileCount: number;
+    functionCount: number;
+    astChangeCount: number;
+    maxFileComplexity: number;
+}
+/**
+ * Compute complexity metrics for a set of files
+ */
+export declare function computeComplexity(directory: string, changedFiles: string[]): Promise<ComplexityMetrics>;
+/**
+ * Determine review routing based on complexity
+ */
+export declare function routeReview(metrics: ComplexityMetrics): ReviewRouting;
+/**
+ * Route review with full analysis
+ */
+export declare function routeReviewForChanges(directory: string, changedFiles: string[]): Promise<ReviewRouting>;
+/**
+ * Check if review should be parallelized
+ */
+export declare function shouldParallelizeReview(routing: ReviewRouting): boolean;

package/dist/plan/checkpoint.d.ts

@@ -0,0 +1,25 @@
+import { type Plan } from '../config/plan-schema';
+/**
+ * Write SWARM_PLAN.json and SWARM_PLAN.md to the project root directory.
+ * Non-blocking: logs a warning on failure but never throws.
+ * @param directory - The working directory (project root)
+ */
+export declare function writeCheckpoint(directory: string): Promise<void>;
+/**
+ * Result of an importCheckpoint operation.
+ */
+export interface ImportCheckpointResult {
+    success: boolean;
+    plan?: Plan;
+    error?: string;
+}
+/**
+ * Import a checkpoint from SWARM_PLAN.json at the project root.
+ * Validates the checkpoint against PlanSchema, persists it as the live plan
+ * via savePlan, and appends a 'plan_rebuilt' ledger event.
+ *
+ * @param directory - The working directory (project root)
+ * @param source - Optional source identifier for the ledger event (defaults to 'external_reseed')
+ * @returns ImportCheckpointResult indicating success or failure with error message
+ */
+export declare function importCheckpoint(directory: string, source?: string): Promise<ImportCheckpointResult>;

package/dist/plan/checkpoint.test.d.ts

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

package/dist/plan/index.d.ts

@@ -0,0 +1 @@
+export { derivePlanMarkdown, loadPlan, migrateLegacyPlan, savePlan, updateTaskStatus, } from './manager';

package/dist/plan/ledger-integrity.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tests for ledger integrity functions: readLedgerEventsWithIntegrity,
+ * quarantineLedgerSuffix, and replayWithIntegrity
+ */
+export {};

package/dist/plan/ledger-snapshot-adversarial.test.d.ts

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

package/dist/plan/ledger.d.ts

@@ -0,0 +1,286 @@
+/**
+ * Append-only Plan Ledger
+ *
+ * Provides durable, immutable audit trail of plan evolution events.
+ * Each event is written as a JSON line to .swarm/plan-ledger.jsonl
+ */
+import { type Plan } from '../config/plan-schema';
+/**
+ * Ledger schema version
+ */
+export declare const LEDGER_SCHEMA_VERSION = "1.0.0";
+/**
+ * Valid ledger event types
+ */
+export declare const LEDGER_EVENT_TYPES: readonly ["plan_created", "task_added", "task_updated", "task_status_changed", "task_reordered", "phase_completed", "plan_rebuilt", "plan_exported", "plan_reset", "snapshot", "execution_profile_set", "execution_profile_locked"];
+export type LedgerEventType = (typeof LEDGER_EVENT_TYPES)[number];
+/**
+ * A ledger event representing a plan mutation.
+ * All fields are required unless marked optional.
+ */
+export interface LedgerEvent {
+    /** Monotonically increasing sequence number (starts at 1) */
+    seq: number;
+    /** ISO 8601 timestamp when event was recorded */
+    timestamp: string;
+    /** Unique identifier for the plan */
+    plan_id: string;
+    /** Type of event that occurred */
+    event_type: LedgerEventType;
+    /** Task ID when event relates to a specific task */
+    task_id?: string;
+    /** Phase ID when event relates to a specific phase */
+    phase_id?: number;
+    /** Previous status (for status change events) */
+    from_status?: string;
+    /** New status (for status change events) */
+    to_status?: string;
+    /** What triggered this event */
+    source: string;
+    /** SHA-256 hash of plan state before this event */
+    plan_hash_before: string;
+    /** SHA-256 hash of plan state after this event */
+    plan_hash_after: string;
+    /** Schema version for this ledger entry */
+    schema_version: string;
+    /** Optional payload for events that carry additional data */
+    payload?: Record<string, unknown>;
+}
+/**
+ * Input type for appendLedgerEvent (excludes auto-generated fields)
+ */
+export type LedgerEventInput = Omit<LedgerEvent, 'seq' | 'timestamp' | 'plan_hash_before' | 'plan_hash_after' | 'schema_version'>;
+/**
+ * Payload for snapshot ledger events.
+ * Embeds the full Plan payload for ledger-only rebuild.
+ */
+export interface SnapshotEventPayload {
+    plan: Plan;
+    payload_hash: string;
+}
+/**
+ * Error thrown when a writer attempts to append to the ledger with stale state.
+ * Indicates another writer has modified the ledger since the caller last read it.
+ */
+export declare class LedgerStaleWriterError extends Error {
+    constructor(message: string);
+}
+/**
+ * Compute a SHA-256 hash of the plan state.
+ * Uses deterministic JSON serialization for consistent hashing.
+ *
+ * @param plan - The plan to hash
+ * @returns Hex-encoded SHA-256 hash
+ */
+export declare function computePlanHash(plan: Plan): string;
+/**
+ * Read the current plan.json and compute its hash.
+ *
+ * @param directory - The working directory
+ * @returns Hash of current plan.json, or empty string if not found
+ */
+export declare function computeCurrentPlanHash(directory: string): string;
+/**
+ * Check if the ledger file exists.
+ *
+ * @param directory - The working directory
+ * @returns true if ledger file exists
+ */
+export declare function ledgerExists(directory: string): Promise<boolean>;
+/**
+ * Get the latest sequence number in the ledger.
+ *
+ * @param directory - The working directory
+ * @returns Highest seq value, or 0 if ledger is empty/doesn't exist
+ */
+export declare function getLatestLedgerSeq(directory: string): Promise<number>;
+/**
+ * Read all events from the ledger.
+ *
+ * @param directory - The working directory
+ * @returns Array of LedgerEvent sorted by seq
+ */
+export declare function readLedgerEvents(directory: string): Promise<LedgerEvent[]>;
+/**
+ * Initialize a new ledger with a plan_created event.
+ * Only call this if the ledger doesn't exist.
+ *
+ * @param directory - The working directory
+ * @param planId - Unique identifier for the plan
+ */
+export declare function initLedger(directory: string, planId: string, initialPlanHash?: string, initialPlan?: Plan): Promise<void>;
+/**
+ * Append a new event to the ledger.
+ * Uses atomic write: write to temp file then rename.
+ *
+ * @param directory - The working directory
+ * @param eventInput - Event data to append (without seq, timestamp, hashes)
+ * @param options - Optional concurrency control options
+ * @returns The full LedgerEvent that was written
+ */
+export declare function appendLedgerEvent(directory: string, eventInput: LedgerEventInput, options?: {
+    expectedSeq?: number;
+    expectedHash?: string;
+    planHashAfter?: string;
+}): Promise<LedgerEvent>;
+/**
+ * Append a ledger event with optimistic retry on stale-writer conflicts.
+ *
+ * When another writer advances the ledger between the caller's read and
+ * their append, `appendLedgerEvent` throws `LedgerStaleWriterError`. This
+ * helper wraps that call in a bounded retry loop, refreshing the
+ * `expectedHash` concurrency token against the current plan.json before
+ * each retry.
+ *
+ * IMPORTANT: refreshing the hash is only safe when the event input is
+ * *still semantically valid* after the intervening write. For audit
+ * events computed from an in-memory plan the caller is about to persist,
+ * it is always valid. For `task_status_changed` events, pass a
+ * `verifyValid` callback that returns false when the transition no
+ * longer applies (e.g. the task's on-disk status already matches the
+ * `to_status`, or has moved past it). When `verifyValid` returns false,
+ * the retry loop exits and the helper returns `null` to signal that the
+ * event was skipped — it is not an error.
+ *
+ * @param directory - Working directory containing `.swarm/plan-ledger.jsonl`
+ * @param eventInput - Event to append (required fields minus auto-generated)
+ * @param options - Concurrency and retry configuration:
+ *   - expectedHash: the hash of plan.json the caller observed (REQUIRED)
+ *   - planHashAfter: precomputed hash of the mutated plan
+ *   - maxRetries: max stale-writer retries (default: 3)
+ *   - backoffMs: base delay in milliseconds (default: 10; exponential)
+ *   - verifyValid: callback invoked before each retry to confirm the
+ *     event input is still meaningful. Returning false aborts and
+ *     resolves the helper to `null`.
+ * @returns The written LedgerEvent, or `null` if verifyValid aborted.
+ * @throws LedgerStaleWriterError if retries are exhausted.
+ */
+export declare function appendLedgerEventWithRetry(directory: string, eventInput: LedgerEventInput, options: {
+    expectedHash: string;
+    planHashAfter?: string;
+    maxRetries?: number;
+    backoffMs?: number;
+    verifyValid?: () => Promise<boolean> | boolean;
+}): Promise<LedgerEvent | null>;
+/**
+ * Take a snapshot event and append it to the ledger.
+ * The snapshot embeds the full Plan payload for ledger-only rebuild.
+ *
+ * @param directory - The working directory
+ * @param plan - The current plan state to snapshot
+ * @param options - Optional configuration:
+ *   - planHashAfter: precomputed hash of the mutated plan (bypasses the
+ *     on-disk plan.json read when available)
+ *   - source: attribution string stored on the ledger event. Defaults to
+ *     `'takeSnapshotEvent'`. Use `'critic_approved'` to mark a snapshot as
+ *     the immutable phase-approved checkpoint readable by
+ *     `loadLastApprovedPlan`.
+ *   - approvalMetadata: optional free-form metadata embedded into the
+ *     snapshot payload (e.g. phase number, verdict, summary) so that
+ *     downstream readers can filter without decoding prompts.
+ * @returns The LedgerEvent that was written
+ */
+export declare function takeSnapshotEvent(directory: string, plan: Plan, options?: {
+    planHashAfter?: string;
+    source?: string;
+    approvalMetadata?: Record<string, unknown>;
+}): Promise<LedgerEvent>;
+/**
+ * Options for replayFromLedger
+ */
+interface ReplayOptions {
+    /** If true, use the latest snapshot to speed up replay */
+    useSnapshot?: boolean;
+}
+/**
+ * Replay ledger events to reconstruct plan state.
+ * Loads plan.json as the base state and applies ledger events in sequence.
+ *
+ * NOTE: This function requires plan.json to exist as the base state.
+ * The ledger only stores task_status_changed events, not the full plan payload.
+ * If plan.json is missing, replay cannot proceed — this is a known limitation.
+ * The fix would be to store the initial plan payload in the ledger, but that
+ * is a larger architectural change beyond the current scope.
+ *
+ * @param directory - The working directory
+ * @param options - Optional replay options
+ * @returns Reconstructed Plan from ledger events, or null if plan.json doesn't exist or ledger is empty
+ */
+export declare function replayFromLedger(directory: string, _options?: ReplayOptions): Promise<Plan | null>;
+/**
+ * Result type for readLedgerEventsWithIntegrity
+ */
+export interface LedgerIntegrityResult {
+    /** Valid events up to (but not including) the first malformed line */
+    events: LedgerEvent[];
+    /** True if a bad line was found and replay was stopped early */
+    truncated: boolean;
+    /** Raw content from the first bad line to end of file, for quarantine */
+    badSuffix: string | null;
+}
+/**
+ * Read ledger events with integrity checking.
+ * Stops at the first malformed/unparseable line and returns the remainder for quarantine.
+ *
+ * @param directory - The working directory
+ * @returns LedgerIntegrityResult with events, truncated flag, and bad suffix
+ */
+export declare function readLedgerEventsWithIntegrity(directory: string): Promise<LedgerIntegrityResult>;
+/**
+ * Quarantine a corrupted ledger suffix to a separate file.
+ * Does NOT modify the ledger file itself.
+ *
+ * @param directory - The working directory
+ * @param badSuffix - The corrupted content to quarantine
+ */
+export declare function quarantineLedgerSuffix(directory: string, badSuffix: string): Promise<void>;
+/**
+ * Replay ledger events with integrity checking.
+ * If corruption is detected, quarantines the bad suffix and falls back to snapshot+prefix replay.
+ * Never throws — all errors return null.
+ *
+ * @param directory - The working directory
+ * @returns Reconstructed Plan from ledger events, or null if replay fails
+ */
+export declare function replayWithIntegrity(directory: string): Promise<Plan | null>;
+/**
+ * Metadata describing an approved snapshot recovered from the ledger.
+ */
+export interface ApprovedSnapshotInfo {
+    /** The immutable plan payload captured at critic approval time */
+    plan: Plan;
+    /** The ledger sequence number of the snapshot event */
+    seq: number;
+    /** ISO 8601 timestamp of the snapshot event */
+    timestamp: string;
+    /** Arbitrary metadata the caller attached (phase, verdict, summary, ...) */
+    approval?: Record<string, unknown>;
+    /** Hash of the plan payload at snapshot time */
+    payloadHash: string;
+}
+/**
+ * Find the most recent critic-approved immutable plan snapshot in the ledger.
+ *
+ * Snapshots are tagged at write time with a distinguishing `source` string
+ * (see `takeSnapshotEvent`). The `critic_approved` marker identifies snapshots
+ * persisted by the orchestrator after a phase Critic returns APPROVED. This
+ * function scans the ledger in reverse order and returns the first matching
+ * snapshot, including its embedded plan payload and approval metadata.
+ *
+ * Intended for use as a fallback when plan.json is lost, overwritten, or
+ * suspected of drift: the Architect can fall back to the last approved plan
+ * and the Critic can drift-check against it.
+ *
+ * SAFETY: when `expectedPlanId` is supplied, only snapshots whose event
+ * `plan_id` matches are considered. Callers MUST pass an expected identity
+ * whenever they have one (e.g. from the ledger's first `plan_created` anchor)
+ * to prevent cross-identity contamination: a stale `critic_approved` snapshot
+ * left in a reused directory could otherwise be resurrected as the active plan.
+ *
+ * @param directory - Working directory containing `.swarm/plan-ledger.jsonl`
+ * @param expectedPlanId - Optional plan identity filter. When provided, only
+ *   snapshots whose ledger event `plan_id` matches are considered.
+ * @returns The most recent approved snapshot info, or null if none exists
+ */
+export declare function loadLastApprovedPlan(directory: string, expectedPlanId?: string): Promise<ApprovedSnapshotInfo | null>;
+export {};

package/dist/plan/ledger.test.d.ts

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

package/dist/plan/manager.cas-backoff.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for retryCasWithBackoff — Phase 4 (CAS retry with exponential backoff).
+ *
+ * Verifies:
+ *   - Backoff schedule: 5ms start, doubles each attempt, cap 250ms, ±25% jitter
+ *   - plan_ledger_cas_retry telemetry is emitted on each retry (hash prefixes only)
+ *   - PlanConcurrentModificationError is thrown when retries are exhausted
+ *   - verifyValid returning false causes early exit without error
+ */
+export {};

package/dist/plan/manager.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Typed error for concurrent plan modification (#444 item 3).
+ * Thrown when savePlan exhausts CAS retries due to concurrent writers.
+ * Callers can catch this specifically to refresh and retry at the outer level.
+ */
+export declare class PlanConcurrentModificationError extends Error {
+    constructor(message: string);
+}
+import { type Plan, type RuntimePlan, type TaskStatus } from '../config/plan-schema';
+import { type LedgerEvent, type LedgerEventInput } from './ledger';
+/** Reset the startup ledger check flag. For testing only. */
+export declare function resetStartupLedgerCheck(): void;
+/**
+ * Append a ledger event with exponential-backoff retry on stale-writer conflicts.
+ *
+ * Replaces the raw `appendLedgerEventWithRetry` call in savePlan with a helper
+ * that uses the project-standard backoff schedule and emits observable telemetry
+ * on each retry. Hash values in telemetry are truncated to 8-char prefixes to
+ * avoid leaking full content hashes into event streams.
+ *
+ * Backoff schedule: start=5ms, doubles each attempt, cap=250ms, ±25% jitter.
+ */
+export declare function retryCasWithBackoff(directory: string, eventInput: LedgerEventInput, options: {
+    expectedHash: string;
+    planHashAfter?: string;
+    verifyValid?: () => Promise<boolean> | boolean;
+    maxRetries?: number;
+}): Promise<LedgerEvent | null>;
+/**
+ * Load plan.json ONLY without auto-migration from plan.md.
+ * Returns null if plan.json doesn't exist or is invalid.
+ * Use this when you want to check for structured plans without triggering migration.
+ */
+export declare function loadPlanJsonOnly(directory: string): Promise<Plan | null>;
+/**
+ * Regenerate plan.md from valid plan.json (auto-heal case 1).
+ */
+export declare function regeneratePlanMarkdown(directory: string, plan: Plan): Promise<void>;
+/**
+ * Load and validate plan from .swarm/plan.json with auto-heal sync.
+ *
+ * 4-step precedence with auto-heal:
+ * 1. .swarm/plan.json exists AND validates ->
+ *    a) If plan.md missing or stale -> regenerate plan.md from plan.json
+ *    b) Return parsed Plan
+ * 2. .swarm/plan.json exists but FAILS validation ->
+ *    a) If plan.md exists -> migrate from plan.md, save valid plan.json, then derive plan.md
+ *    b) Return migrated Plan
+ * 3. .swarm/plan.md exists only -> migrate from plan.md, save both files, return Plan
+ * 4. Neither exists -> return null
+ */
+export declare function loadPlan(directory: string): Promise<RuntimePlan | null>;
+/**
+ * Validate against PlanSchema (throw on invalid), write to .swarm/plan.json via atomic temp+rename pattern,
+ * then derive and write .swarm/plan.md
+ */
+export declare function savePlan(directory: string, plan: Plan, options?: {
+    preserveCompletedStatuses?: boolean;
+}): Promise<void>;
+/**
+ * Rebuild plan from ledger events.
+ * Replays the ledger to reconstruct plan state, then writes the result.
+ * Uses direct atomic writes to avoid circular ledger append (savePlan appends ledger events).
+ *
+ * @param directory - The working directory
+ * @returns Reconstructed Plan from ledger, or null if ledger is empty/missing
+ */
+export declare function rebuildPlan(directory: string, plan?: Plan): Promise<Plan | null>;
+/**
+ * Load plan → find task by ID → update status → save → return updated plan.
+ * Throw if plan not found or task not found.
+ *
+ * Uses loadPlan() (not loadPlanJsonOnly) so that legitimate same-identity ledger
+ * drift is detected and healed before the status update is applied. Without this,
+ * a stale plan.json would silently overwrite ledger-ahead task state with only the
+ * one targeted status change applied on top.
+ *
+ * The migration guard in loadPlan() (plan_id identity check) prevents destructive
+ * revert after a swarm rename — so this is safe even in post-migration scenarios.
+ */
+export declare function updateTaskStatus(directory: string, taskId: string, status: TaskStatus): Promise<Plan>;
+/**
+ * Generate deterministic markdown view from plan object.
+ * Ensures stable ordering: phases by ID (ascending), tasks by ID (natural numeric).
+ */
+export declare function derivePlanMarkdown(plan: Plan): string;
+/**
+ * Convert existing plan.md to plan.json. PURE function — no I/O.
+ */
+export declare function migrateLegacyPlan(planContent: string, swarmId?: string): Plan;

package/dist/plan/manager.ledger-aware.test.d.ts

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

package/dist/plan/manager.loadplan-validation-guard.test.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Tests for the migration-aware identity guard in loadPlan()'s validation-failure
+ * catch path (lines ~299-323 of manager.ts).
+ *
+ * When plan.json fails schema validation, the old code unconditionally called
+ * replayFromLedger(). This allowed a post-migration ledger (old identity) to
+ * overwrite a schema-invalid but correctly migrated plan.json.
+ *
+ * The fix: extract swarm+title from the raw JSON (even if schema validation
+ * fails), compare against the first ledger event's plan_id, and only replay
+ * when identities match.
+ */
+export {};

package/dist/plan/manager.update-task-status.test.d.ts

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

package/dist/plan/migration-revert.regression.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Regression tests for GitHub issues #383/#384:
+ * PlanSyncWorker Aggressively Reverts Plan Files
+ *
+ * These tests verify that the fixes introduced in the debug-issues-383-384 branch
+ * prevent the destructive revert behavior and related edge cases.
+ */
+export {};

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;