opencode-swarm 7.0.0-beta.1 → 7.0.0

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,179 @@
+/**
+ * Phase-Boundary Preflight Trigger
+ *
+ * Detects phase-boundary conditions and triggers preflight requests.
+ * Manages phase transitions and queues preflight checks via the automation event bus.
+ */
+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;
+    /**
+     * Get the last triggered phase (for external access)
+     */
+    get lastTriggeredPhaseValue(): 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/cli/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+/**
+ * Dispatch function for routing argv tokens to plugin command handlers.
+ * Used by the "run" subcommand entry point.
+ * Delegates to the unified COMMAND_REGISTRY via resolveCommand().
+ */
+export declare function run(args: string[]): Promise<number>;