opencode-swarm 6.5.0 → 6.8.0

package/dist/background/queue.d.ts

@@ -0,0 +1,116 @@
+/**
+ * Lightweight In-Process Queue with Priorities and Retry Metadata
+ *
+ * Provides a simple but powerful queue abstraction for background automation.
+ * Supports priorities, retry logic, and in-memory persistence only.
+ */
+/** Queue priority levels */
+export type QueuePriority = 'critical' | 'high' | 'normal' | 'low';
+/** Retry metadata for failed items */
+export interface RetryMetadata {
+    attempts: number;
+    maxAttempts: number;
+    lastAttempt?: number;
+    nextAttemptAt?: number;
+    backoffMs: number;
+    maxBackoffMs: number;
+}
+/** Queue item structure */
+export interface QueueItem<T = unknown> {
+    id: string;
+    priority: QueuePriority;
+    payload: T;
+    createdAt: number;
+    metadata?: Record<string, unknown>;
+    retry?: RetryMetadata;
+}
+/** Queue configuration */
+export interface QueueConfig {
+    priorityLevels?: QueuePriority[];
+    maxSize?: number;
+    defaultMaxRetries?: number;
+    defaultBackoffMs?: number;
+    maxBackoffMs?: number;
+}
+/**
+ * In-process queue with priority support and retry metadata
+ */
+export declare class AutomationQueue<T = unknown> {
+    private items;
+    private readonly maxSize;
+    private readonly defaultMaxRetries;
+    private readonly defaultBackoffMs;
+    private readonly maxBackoffMs;
+    private readonly eventBus;
+    private itemCounter;
+    constructor(config?: QueueConfig);
+    /**
+     * Generate unique item ID
+     */
+    private generateId;
+    /**
+     * Enqueue an item with priority
+     */
+    enqueue(payload: T, priority?: QueuePriority, metadata?: Record<string, unknown>): string;
+    /**
+     * Dequeue the highest priority item
+     */
+    dequeue(): QueueItem<T> | undefined;
+    /**
+     * Peek at the highest priority item without removing
+     */
+    peek(): QueueItem<T> | undefined;
+    /**
+     * Get item by ID
+     */
+    get(id: string): QueueItem<T> | undefined;
+    /**
+     * Remove specific item by ID
+     */
+    remove(id: string): boolean;
+    /**
+     * Mark item as completed and remove from queue
+     */
+    complete(id: string): boolean;
+    /**
+     * Mark item as failed and schedule retry if possible
+     */
+    retry(id: string, _error?: unknown): boolean;
+    /**
+     * Get items due for retry
+     */
+    getRetryableItems(): QueueItem<T>[];
+    /**
+     * Get current queue size
+     */
+    size(): number;
+    /**
+     * Check if queue is empty
+     */
+    isEmpty(): boolean;
+    /**
+     * Check if queue is full
+     */
+    isFull(): boolean;
+    /**
+     * Clear all items from queue
+     */
+    clear(): void;
+    /**
+     * Get all items (for debugging/inspection)
+     */
+    getAll(): QueueItem<T>[];
+    /**
+     * Get items by priority
+     */
+    getByPriority(priority: QueuePriority): QueueItem<T>[];
+    /**
+     * Get queue statistics
+     */
+    getStats(): {
+        size: number;
+        maxSize: number;
+        byPriority: Record<QueuePriority, number>;
+        retryable: number;
+    };
+}

package/dist/background/status-artifact.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Passive Status Artifact Writer
+ *
+ * Writes automation status snapshots to .swarm/ for GUI visibility.
+ * Provides passive, read-only status information without affecting workflow.
+ */
+/** Automation status snapshot structure */
+export interface AutomationStatusSnapshot {
+    /** When this snapshot was generated */
+    timestamp: number;
+    /** Current automation mode */
+    mode: 'manual' | 'hybrid' | 'auto';
+    /** Whether automation is enabled */
+    enabled: boolean;
+    /** Current phase */
+    currentPhase: number;
+    /** Last trigger information */
+    lastTrigger: {
+        triggeredAt: number | null;
+        triggeredPhase: number | null;
+        source: string | null;
+        reason: string | null;
+    } | null;
+    /** Pending actions count */
+    pendingActions: number;
+    /** Last outcome state */
+    lastOutcome: {
+        state: 'success' | 'failure' | 'skipped' | 'none';
+        phase: number | null;
+        outcomeAt: number | null;
+        message: string | null;
+    } | null;
+    /** Feature flags status */
+    capabilities: {
+        plan_sync: boolean;
+        phase_preflight: boolean;
+        config_doctor_on_startup: boolean;
+        config_doctor_autofix: boolean;
+        evidence_auto_summaries: boolean;
+        decision_drift_detection: boolean;
+    };
+}
+/**
+ * Automation Status Artifact Manager
+ *
+ * Writes passive status snapshots to .swarm/automation-status.json
+ */
+export declare class AutomationStatusArtifact {
+    private readonly swarmDir;
+    private readonly filename;
+    private currentSnapshot;
+    constructor(swarmDir: string, filename?: string);
+    /**
+     * Get the full path to the status file
+     */
+    private getFilePath;
+    /**
+     * Load existing snapshot from disk
+     */
+    load(): AutomationStatusSnapshot | null;
+    /**
+     * Write snapshot to disk
+     */
+    private write;
+    /**
+     * Get current snapshot (in-memory)
+     */
+    getSnapshot(): AutomationStatusSnapshot;
+    /**
+     * Read snapshot from disk (forces reload)
+     */
+    read(): AutomationStatusSnapshot;
+    /**
+     * Update mode and capabilities
+     */
+    updateConfig(mode: 'manual' | 'hybrid' | 'auto', capabilities: AutomationStatusSnapshot['capabilities']): void;
+    /**
+     * Update current phase
+     */
+    updatePhase(phase: number): void;
+    /**
+     * Record a trigger event
+     */
+    recordTrigger(triggeredAt: number, triggeredPhase: number, source: string, reason: string): void;
+    /**
+     * Update pending actions count
+     */
+    updatePendingActions(count: number): void;
+    /**
+     * Record an outcome
+     */
+    recordOutcome(state: 'success' | 'failure' | 'skipped', phase: number, message?: string): void;
+    /**
+     * Clear the last outcome (reset to none)
+     */
+    clearOutcome(): void;
+    /**
+     * Check if automation is enabled (mode != manual)
+     */
+    isEnabled(): boolean;
+    /**
+     * Check if a specific capability is enabled
+     */
+    hasCapability(capability: keyof AutomationStatusSnapshot['capabilities']): boolean;
+    /**
+     * Get summary for GUI display
+     */
+    getGuiSummary(): {
+        status: string;
+        phase: number;
+        lastTrigger: string | null;
+        pending: number;
+        outcome: string | null;
+    };
+}

package/dist/background/trigger.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Phase-Boundary Preflight Trigger
+ *
+ * Detects phase-boundary conditions and triggers preflight requests.
+ * This is the plumbing/scaffold for Task 5.5 - full preflight logic comes in Task 5.6.
+ */
+import type { AutomationConfig } from '../config/schema';
+import { type AutomationEventBus } from './event-bus';
+/** Event types for preflight triggers */
+export type PreflightTriggerEventType = 'preflight.requested' | 'preflight.triggered' | 'preflight.skipped' | 'phase.boundary.detected';
+/** Preflight trigger payload */
+export interface PreflightRequestPayload {
+    triggerSource: 'phase_boundary' | 'manual' | 'scheduled';
+    currentPhase: number;
+    reason: string;
+    metadata?: Record<string, unknown>;
+}
+/** Phase boundary detection result */
+export interface PhaseBoundaryResult {
+    detected: boolean;
+    previousPhase: number;
+    currentPhase: number;
+    reason: string;
+    completedTaskCount: number;
+    totalTaskCount: number;
+}
+/** Preflight trigger configuration */
+export interface PreflightTriggerConfig {
+    /** Minimum tasks that must be completed in a phase to trigger */
+    minCompletedTasksThreshold?: number;
+    /** Enable trigger even if no tasks (phase auto-complete mode) */
+    allowZeroTaskTrigger?: boolean;
+    /** Directory to run preflight checks in */
+    directory?: string;
+}
+/** Preflight handler type */
+export type PreflightHandler = (request: PreflightRequest) => Promise<void>;
+/** Preflight request queue item */
+export interface PreflightRequest {
+    id: string;
+    triggeredAt: number;
+    currentPhase: number;
+    source: 'phase_boundary' | 'manual' | 'scheduled';
+    reason: string;
+    metadata?: Record<string, unknown>;
+}
+/** Phase boundary detection result */
+export interface PhaseBoundaryResult {
+    detected: boolean;
+    previousPhase: number;
+    currentPhase: number;
+    reason: string;
+    completedTaskCount: number;
+    totalTaskCount: number;
+}
+/** Preflight trigger configuration */
+export interface PreflightTriggerConfig {
+    /** Minimum tasks that must be completed in a phase to trigger */
+    minCompletedTasksThreshold?: number;
+    /** Enable trigger even if no tasks (phase auto-complete mode) */
+    allowZeroTaskTrigger?: boolean;
+}
+/**
+ * Phase-Boundary Trigger Detector
+ *
+ * Monitors plan state to detect when a phase transition occurs.
+ */
+export declare class PhaseBoundaryTrigger {
+    private readonly eventBus;
+    private readonly config;
+    private lastKnownPhase;
+    private lastTriggeredPhase;
+    constructor(eventBus?: AutomationEventBus, config?: PreflightTriggerConfig);
+    /**
+     * Set the current phase from external source (plan)
+     */
+    setCurrentPhase(phase: number): void;
+    /**
+     * Get the last known phase
+     */
+    getCurrentPhase(): number;
+    /**
+     * Check if a phase boundary has been crossed
+     * Returns the result of the detection
+     */
+    detectBoundary(newPhase: number, completedTasks: number, totalTasks: number): PhaseBoundaryResult;
+    /**
+     * Check if preflight should be triggered based on phase boundary
+     * Must be called AFTER phase boundary is detected
+     */
+    shouldTriggerPreflight(boundaryResult: PhaseBoundaryResult): boolean;
+    /**
+     * Mark that preflight was triggered for a phase
+     */
+    markTriggered(phase: number): void;
+    /**
+     * Reset trigger state (for testing)
+     */
+    reset(): void;
+}
+/**
+ * Preflight Trigger Manager
+ *
+ * Orchestrates trigger detection, feature flag gating, and request publishing.
+ */
+export declare class PreflightTriggerManager {
+    private readonly automationConfig;
+    private readonly eventBus;
+    private readonly trigger;
+    private readonly requestQueue;
+    private requestCounter;
+    private preflightHandler;
+    private unsubscribe;
+    constructor(automationConfig: AutomationConfig, eventBus?: AutomationEventBus, triggerConfig?: PreflightTriggerConfig);
+    /**
+     * Check if preflight triggers are enabled via feature flags
+     * Returns false if config is missing/invalid (fail-safe)
+     */
+    isEnabled(): boolean;
+    /**
+     * Get the automation mode
+     * Returns 'unknown' for malformed config (fail-safe)
+     */
+    getMode(): string;
+    /**
+     * Update current phase from plan state
+     */
+    updatePhase(phase: number): void;
+    /**
+     * Check for phase boundary and potentially trigger preflight
+     * Returns true if preflight was triggered
+     */
+    checkAndTrigger(currentPhase: number, completedTasks: number, totalTasks: number): Promise<boolean>;
+    /**
+     * Trigger a preflight request
+     */
+    private triggerPreflight;
+    /**
+     * Get pending preflight requests
+     */
+    getPendingRequests(): PreflightRequest[];
+    /**
+     * Get queue size
+     */
+    getQueueSize(): number;
+    /**
+     * Get trigger stats
+     * All values are fail-safe for malformed config
+     */
+    getStats(): {
+        enabled: boolean;
+        mode: string;
+        currentPhase: number;
+        lastTriggeredPhase: number;
+        pendingRequests: number;
+    };
+    /**
+     * Reset state (for testing)
+     */
+    reset(): void;
+    /**
+     * Register a handler to be called when preflight is requested.
+     * The handler will be invoked with the preflight request details.
+     * Only one handler can be registered at a time.
+     */
+    registerHandler(handler: PreflightHandler): void;
+    /**
+     * Unregister the preflight handler
+     */
+    unregisterHandler(): void;
+    /**
+     * Check if a handler is registered
+     */
+    hasHandler(): boolean;
+}

package/dist/background/trigger.vulnerability.test.d.ts

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

package/dist/background/worker.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Worker Lifecycle Manager
+ *
+ * Manages worker threads for background automation.
+ * Handles registration, start/stop, and handler coordination.
+ */
+import type { AutomationQueue, QueueItem } from './queue';
+/** Worker handler function */
+export type WorkerHandler<T = unknown> = (item: QueueItem<T>) => Promise<{
+    success: boolean;
+    result?: unknown;
+    error?: unknown;
+}>;
+/** Worker registration options */
+export interface WorkerRegistration {
+    name: string;
+    handler: WorkerHandler;
+    queue: AutomationQueue;
+    concurrency?: number;
+    autoStart?: boolean;
+}
+/** Worker status */
+export type WorkerStatus = 'idle' | 'running' | 'stopping' | 'stopped' | 'error';
+/**
+ * Worker Lifecycle Manager
+ *
+ * Manages worker registration, lifecycle, and processing.
+ */
+export declare class WorkerManager {
+    private workers;
+    private readonly eventBus;
+    constructor();
+    /**
+     * Register a new worker
+     */
+    register(registration: WorkerRegistration): void;
+    /**
+     * Unregister a worker
+     */
+    unregister(name: string): boolean;
+    /**
+     * Start a worker
+     */
+    start(name: string): boolean;
+    /**
+     * Start processing loop for a worker
+     */
+    private startProcessingLoop;
+    /**
+     * Handle a single queue item
+     */
+    private handleItem;
+    /**
+     * Stop a worker
+     */
+    stop(name: string): boolean;
+    /**
+     * Start all workers
+     */
+    startAll(): void;
+    /**
+     * Stop all workers
+     */
+    stopAll(): void;
+    /**
+     * Get worker status
+     */
+    getStatus(name: string): WorkerStatus | undefined;
+    /**
+     * Get worker statistics
+     */
+    getStats(name: string): {
+        status: WorkerStatus;
+        activeCount: number;
+        processedCount: number;
+        errorCount: number;
+        lastError?: unknown;
+        queueSize: number;
+    } | undefined;
+    /**
+     * Get all worker names
+     */
+    getWorkerNames(): string[];
+    /**
+     * Check if any workers are running
+     */
+    isAnyRunning(): boolean;
+    /**
+     * Get total statistics across all workers
+     */
+    getTotalStats(): Record<string, ReturnType<WorkerManager['getStats']>>;
+}

package/dist/commands/command-adapters.security.test.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Adversarial Security Tests for Command Adapters (Task 5.10)
+ *
+ * ATTACK VECTORS COVERED:
+ * 1. Path Traversal - attempts to escape .swarm directory via command args
+ * 2. Null Byte Injection - injecting null bytes to truncate paths/strings
+ * 3. Control Character Injection - injecting control chars (0x00-0x1F)
+ * 4. Command Injection - shell metacharacters in args
+ * 5. Argument Pollution - malformed, oversized, special character args
+ * 6. Flag Injection - malicious flag values and combinations
+ * 7. Unicode Attacks - unicode normalization/replacement attacks
+ * 8. Edge Cases - empty, extremely long, boundary values
+ */
+export {};

package/dist/commands/commands.test.d.ts

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

package/dist/commands/diagnose.d.ts

@@ -1,5 +1 @@
-/**
- * Handles the /swarm diagnose command.
- * Performs health checks on swarm state files and configuration.
- */
-export declare function handleDiagnoseCommand(directory: string, _args: string[]): Promise<string>;
+export { handleDiagnoseCommand } from '../services/diagnose-service';

package/dist/commands/doctor.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Handle /swarm config doctor command.
+ * Maps to: config doctor service (runConfigDoctor)
+ */
+export declare function handleDoctorCommand(directory: string, args: string[]): Promise<string>;

package/dist/commands/evidence.d.ts

@@ -1,5 +1 @@
-/**
- * Handles the /swarm evidence command.
- * Lists all evidence bundles or shows details for a specific task.
- */
-export declare function handleEvidenceCommand(directory: string, args: string[]): Promise<string>;
+export { handleEvidenceCommand, handleEvidenceSummaryCommand, } from '../services/evidence-service';

package/dist/commands/export.d.ts

@@ -1,5 +1 @@
-/**
- * Handles the /swarm export command.
- * Exports plan.md and context.md as a portable JSON object.
- */
-export declare function handleExportCommand(directory: string, _args: string[]): Promise<string>;
+export { handleExportCommand } from '../services/export-service';

package/dist/commands/history.d.ts

@@ -1,5 +1 @@
-/**
- * Handles the /swarm history command.
- * Reads plan.md and displays a summary of all phases and their status.
- */
-export declare function handleHistoryCommand(directory: string, _args: string[]): Promise<string>;
+export { handleHistoryCommand } from '../services/history-service';

package/dist/commands/index.d.ts

@@ -4,13 +4,16 @@ export { handleArchiveCommand } from './archive';
 export { handleBenchmarkCommand } from './benchmark';
 export { handleConfigCommand } from './config';
 export { handleDiagnoseCommand } from './diagnose';
+export { handleDoctorCommand } from './doctor';
 export { handleEvidenceCommand } from './evidence';
 export { handleExportCommand } from './export';
 export { handleHistoryCommand } from './history';
 export { handlePlanCommand } from './plan';
+export { handlePreflightCommand } from './preflight';
 export { handleResetCommand } from './reset';
 export { handleRetrieveCommand } from './retrieve';
 export { handleStatusCommand } from './status';
+export { handleSyncPlanCommand } from './sync-plan';
 /**
  * Creates a command.execute.before handler for /swarm commands.
  * Uses factory pattern to close over directory and agents.

package/dist/commands/plan.d.ts

@@ -1 +1 @@
-export declare function handlePlanCommand(directory: string, args: string[]): Promise<string>;
+export { handlePlanCommand } from '../services/plan-service';

package/dist/commands/preflight.d.ts

@@ -0,0 +1 @@
+export { handlePreflightCommand } from '../services/preflight-service';

package/dist/commands/status.d.ts

@@ -1,2 +1 @@
-import type { AgentDefinition } from '../agents';
-export declare function handleStatusCommand(directory: string, agents: Record<string, AgentDefinition>): Promise<string>;
+export { handleStatusCommand } from '../services/status-service';

package/dist/commands/sync-plan.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Handle /swarm sync-plan command.
+ * Maps to: plan service (loadPlan which triggers auto-heal/sync)
+ *
+ * This command ensures plan.json and plan.md are in sync.
+ * The loadPlan function automatically regenerates plan.md from plan.json if needed.
+ */
+export declare function handleSyncPlanCommand(directory: string, _args: string[]): Promise<string>;

package/dist/config/index.d.ts

@@ -5,5 +5,5 @@ export { ApprovalEvidenceSchema, BaseEvidenceSchema, DiffEvidenceSchema, EVIDENC
 export { loadAgentPrompt, loadPluginConfig, loadPluginConfigWithMeta, } from './loader';
 export type { MigrationStatus, Phase, PhaseStatus, Plan, Task, TaskSize, TaskStatus, } from './plan-schema';
 export { MigrationStatusSchema, PhaseSchema, PhaseStatusSchema, PlanSchema, TaskSchema, TaskSizeSchema, TaskStatusSchema, } from './plan-schema';
-export type { AgentOverrideConfig, PluginConfig, SwarmConfig, } from './schema';
-export { AgentOverrideConfigSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';
+export type { AgentOverrideConfig, AutomationCapabilities, AutomationConfig, AutomationMode, PluginConfig, SwarmConfig, } from './schema';
+export { AgentOverrideConfigSchema, AutomationCapabilitiesSchema, AutomationConfigSchema, AutomationModeSchema, PluginConfigSchema, SwarmConfigSchema, } from './schema';

package/dist/config/plan-schema.d.ts

@@ -7,8 +7,8 @@ export declare const TaskStatusSchema: z.ZodEnum<{
 }>;
 export type TaskStatus = z.infer<typeof TaskStatusSchema>;
 export declare const TaskSizeSchema: z.ZodEnum<{
-    medium: "medium";
     small: "small";
+    medium: "medium";
     large: "large";
 }>;
 export type TaskSize = z.infer<typeof TaskSizeSchema>;
@@ -35,8 +35,8 @@ export declare const TaskSchema: z.ZodObject<{
         blocked: "blocked";
     }>>;
     size: z.ZodDefault<z.ZodEnum<{
-        medium: "medium";
         small: "small";
+        medium: "medium";
         large: "large";
     }>>;
     description: z.ZodString;
@@ -66,8 +66,8 @@ export declare const PhaseSchema: z.ZodObject<{
             blocked: "blocked";
         }>>;
         size: z.ZodDefault<z.ZodEnum<{
-            medium: "medium";
             small: "small";
+            medium: "medium";
             large: "large";
         }>>;
         description: z.ZodString;
@@ -103,8 +103,8 @@ export declare const PlanSchema: z.ZodObject<{
                 blocked: "blocked";
             }>>;
             size: z.ZodDefault<z.ZodEnum<{
-                medium: "medium";
                 small: "small";
+                medium: "medium";
                 large: "large";
             }>>;
             description: z.ZodString;