opencode-swarm 7.0.0-beta.1 → 7.0.1

package/dist/services/tool-doctor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Tool Doctor Service
+ *
+ * Validates that every tool name in TOOL_NAMES has a corresponding
+ * registration in the plugin's tool: {} block in src/index.ts.
+ *
+ * Also validates:
+ * - AGENT_TOOL_MAP alignment: tools assigned to agents are registered in the plugin
+ * - Class 3 tool binary readiness: external binaries needed by lint tools are available
+ */
+import type { ConfigDoctorResult } from './config-doctor';
+/** Result of tool registration coherence check */
+export type ToolDoctorResult = ConfigDoctorResult;
+/**
+ * Run tool registration coherence check
+ *
+ * Verifies that every entry in TOOL_NAMES has a corresponding key
+ * in the plugin's tool: {} block in src/index.ts.
+ */
+/**
+ * Returns a structured advisory string for any missing Class 3 binaries.
+ * Intended for injection into the architect's first system prompt.
+ * Returns null if all binaries are available.
+ */
+export declare function getBinaryReadinessAdvisory(): string | null;
+export declare function runToolDoctor(_directory: string, pluginRoot?: string): ToolDoctorResult;

package/dist/services/tool-doctor.test.d.ts

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

package/dist/services/version-check.d.ts

@@ -0,0 +1,28 @@
+interface VersionCheckCache {
+    checkedAt: number;
+    npmLatest: string | null;
+}
+export declare function readVersionCache(): VersionCheckCache | null;
+/**
+ * Compare two semver-ish version strings. Returns 1 if `a > b`, -1 if `a < b`,
+ * 0 if equal. Treats prerelease tags as lower than the release. Pure function.
+ */
+export declare function compareVersions(a: string, b: string): number;
+/**
+ * Schedule a one-shot, fully detached version check. Returns immediately.
+ * Emits a deferred warning via `emitWarning` when a newer version is found.
+ *
+ * @param runningVersion The version of the currently-loaded plugin.
+ * @param emitWarning Callback used to surface the staleness notice.
+ * @param now Time source — overridable for tests.
+ * @param fetchImpl Fetcher — overridable for tests.
+ */
+export declare function scheduleVersionCheck(runningVersion: string, emitWarning: (msg: string) => void, options?: {
+    now?: () => number;
+    fetchImpl?: (signal: AbortSignal) => Promise<string | null>;
+}): void;
+/**
+ * Test-only: reset the in-process latch so a subsequent schedule call runs.
+ */
+export declare function _resetVersionCheckLatchForTests(): void;
+export {};

package/dist/services/warning-buffer.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bounded buffer for deferred non-critical init warnings.
+ * Populated during plugin startup when quiet:true; replayed in /swarm diagnose.
+ * Extracted from index.ts so agents/index.ts and diagnose-service.ts can
+ * share the buffer without creating a circular dependency.
+ * Max 50 entries to prevent memory growth.
+ */
+export declare const deferredWarnings: string[];
+export declare function addDeferredWarning(warning: string): void;

package/dist/session/snapshot-reader.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Session snapshot reader for OpenCode Swarm plugin.
+ * Reads .swarm/session/state.json and rehydrates swarmState on plugin init.
+ */
+import type { AgentSessionState } from '../state';
+import type { SerializedAgentSession, SnapshotData } from './snapshot-writer';
+/**
+ * Transient session fields that must be reset on rehydration.
+ * Centralised here to keep the reset logic DRY and auditable.
+ */
+export declare const TRANSIENT_SESSION_FIELDS: ReadonlyArray<{
+    name: string;
+    resetValue: unknown;
+}>;
+/**
+ * Deserialize a SerializedAgentSession back to AgentSessionState.
+ * Handles Map/Set conversion and migration safety defaults.
+ */
+export declare function deserializeAgentSession(s: SerializedAgentSession): AgentSessionState;
+/**
+ * Read the snapshot file from .swarm/session/state.json.
+ * Returns null if file doesn't exist, parse fails, or version is wrong.
+ * NEVER throws - always returns null on any error.
+ */
+export declare function readSnapshot(directory: string): Promise<SnapshotData | null>;
+/**
+ * Rehydrate swarmState from a SnapshotData object.
+ * Clears existing maps first, then populates from snapshot.
+ * Does NOT touch activeToolCalls or pendingEvents (remain at defaults).
+ */
+export declare function rehydrateState(snapshot: SnapshotData): Promise<void>;
+/**
+ * Load snapshot from disk and rehydrate swarmState.
+ * Called on plugin init to restore state from previous session.
+ * NEVER throws - swallows any errors silently.
+ */
+export declare function loadSnapshot(directory: string): Promise<void>;

package/dist/session/snapshot-writer.d.ts

@@ -0,0 +1,115 @@
+/**
+ * Session snapshot writer for OpenCode Swarm plugin.
+ * Serializes swarmState to .swarm/session/state.json using atomic write (temp-file + rename).
+ */
+import type { AgentSessionState, DelegationEntry, ToolAggregate } from '../state';
+import { swarmState } from '../state';
+/**
+ * Serialized form of AgentSessionState with Map/Set fields converted to plain arrays/objects
+ */
+export interface SerializedAgentSession {
+    agentName: string;
+    lastToolCallTime: number;
+    lastAgentEventTime: number;
+    delegationActive: boolean;
+    activeInvocationId: number;
+    lastInvocationIdByAgent: Record<string, number>;
+    windows: Record<string, SerializedInvocationWindow>;
+    lastCompactionHint: number;
+    architectWriteCount: number;
+    lastCoderDelegationTaskId: string | null;
+    currentTaskId: string | null;
+    turboMode: boolean;
+    gateLog: Record<string, string[]>;
+    reviewerCallCount: Record<string, number>;
+    lastGateFailure: {
+        tool: string;
+        taskId: string;
+        timestamp: number;
+    } | null;
+    partialGateWarningsIssuedForTask: string[];
+    selfFixAttempted: boolean;
+    selfCodingWarnedAtCount: number;
+    catastrophicPhaseWarnings: number[];
+    lastPhaseCompleteTimestamp: number;
+    lastPhaseCompletePhase: number;
+    phaseAgentsDispatched: string[];
+    lastCompletedPhaseAgentsDispatched: string[];
+    qaSkipCount: number;
+    qaSkipTaskIds: string[];
+    pendingAdvisoryMessages: string[];
+    taskWorkflowStates?: Record<string, string>;
+    /** Flag for one-shot scope violation warning injection (omitted when undefined for additive-only schema) */
+    scopeViolationDetected?: boolean;
+    /** Current index into the fallback_models array (v6.33) */
+    model_fallback_index: number;
+    /** Flag set when all fallback models have been exhausted (v6.33) */
+    modelFallbackExhausted: boolean;
+    /** Number of coder revisions in the current task (v6.33) */
+    coderRevisions: number;
+    /** Flag set when coder revisions hit the configured ceiling (v6.33) */
+    revisionLimitHit: boolean;
+    /** Session-scoped Full Auto flag for autonomous multi-agent oversight (Phase 2) */
+    fullAutoMode?: boolean;
+    /** Count of full-auto interactions this phase (Phase 2) */
+    fullAutoInteractionCount?: number;
+    /** Count of detected deadlocks in full-auto mode (Phase 2) */
+    fullAutoDeadlockCount?: number;
+    /** Hash of last question asked in full-auto mode (Phase 2) */
+    fullAutoLastQuestionHash?: string | null;
+    /** Timestamp when session was rehydrated from snapshot (0 if never rehydrated) */
+    sessionRehydratedAt?: number;
+}
+/**
+ * Minimal interface for serialized InvocationWindow
+ */
+export interface SerializedInvocationWindow {
+    id: number;
+    agentName: string;
+    startedAtMs: number;
+    toolCalls: number;
+    consecutiveErrors: number;
+    hardLimitHit: boolean;
+    lastSuccessTimeMs: number;
+    recentToolCalls: Array<{
+        tool: string;
+        argsHash: number;
+        timestamp: number;
+    }>;
+    warningIssued: boolean;
+    warningReason: string;
+    transientRetryCount: number;
+}
+/**
+ * Snapshot data structure written to disk
+ */
+export interface SnapshotData {
+    version: 1 | 2;
+    writtenAt: number;
+    toolAggregates: Record<string, ToolAggregate>;
+    activeAgent: Record<string, string>;
+    delegationChains: Record<string, DelegationEntry[]>;
+    agentSessions: Record<string, SerializedAgentSession>;
+}
+/**
+ * Convert a live AgentSessionState to its serialized form.
+ * Handles missing/undefined Map/Set fields gracefully (migration safety).
+ */
+export declare function serializeAgentSession(s: AgentSessionState): SerializedAgentSession;
+/**
+ * Write a snapshot of swarmState to .swarm/session/state.json atomically.
+ * Silently swallows errors (non-fatal — never crash the plugin).
+ */
+export declare function writeSnapshot(directory: string, state: typeof swarmState): Promise<void>;
+/**
+ * Create a snapshot writer hook suitable for use in tool.execute.after.
+ * Writes state immediately on every call.  Concurrent calls are serialised so
+ * the last writer wins without producing a corrupt interleaved file.
+ */
+export declare function createSnapshotWriterHook(directory: string): (input: unknown, output: unknown) => Promise<void>;
+/**
+ * v6.35.4: Flush any in-flight snapshot write.
+ * Called by phase-complete and handoff to ensure critical state transitions
+ * are persisted before returning.
+ */
+export declare function flushPendingSnapshot(directory: string): Promise<void>;

package/dist/skills/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Skill definition with versioning and per-agent overlays
+ */
+export interface AgentOverlay {
+    agent: string;
+    prompt?: string;
+    model?: string;
+}
+export interface SkillDefinition {
+    id: string;
+    name: string;
+    description: string;
+    SKILL_VERSION: number;
+    basePrompt?: string;
+    agents?: AgentOverlay[];
+}
+export declare const skills: SkillDefinition[];
+export declare const AGENT_OVERLAYS: Record<string, AgentOverlay[]>;
+/**
+ * Get skill by ID
+ */
+export declare function getSkill(id: string): SkillDefinition | undefined;
+/**
+ * Get agent overlay for a skill
+ */
+export declare function getAgentOverlay(skillId: string, agent: string): AgentOverlay | undefined;
+/**
+ * Resolve effective prompt for an agent on a skill
+ */
+export declare function resolveAgentPrompt(skillId: string, agent: string, defaultPrompt: string): string;

package/dist/state/agent-run-context.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AgentRunContext — typed per-run state container.
+ *
+ * Holds the subset of swarmState needed for future per-run isolation:
+ *   activeToolCalls, activeAgent, delegationChains, agentSessions,
+ *   environmentProfiles, and a shared reference to process-global toolAggregates.
+ *
+ * PR 1 (dark foundation): the class exists and is instantiated for the default
+ * single-run path only.  No runtime behavior is changed.
+ * PR 2 will wire distinct contexts to parallel dispatcher slots.
+ *
+ * Generic type parameters let state.ts bind concrete internal types without
+ * creating a circular import.
+ */
+export declare class AgentRunContext<TToolCall = unknown, TToolAgg = unknown, TDelegation = unknown, TSession = unknown, TEnvProfile = unknown> {
+    readonly runId: string;
+    readonly activeToolCalls: Map<string, TToolCall>;
+    readonly activeAgent: Map<string, string>;
+    readonly delegationChains: Map<string, TDelegation[]>;
+    readonly agentSessions: Map<string, TSession>;
+    readonly environmentProfiles: Map<string, TEnvProfile>;
+    readonly toolAggregates: Map<string, TToolAgg>;
+    constructor(runId: string, toolAggregates: Map<string, TToolAgg>);
+}

package/dist/state.agent-run-context.test.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Tests for AgentRunContext and getRunContext (Phase 3 — dark foundation).
+ *
+ * Verifies:
+ *   1. swarmState maps are the same objects as defaultRunContext maps (facade equivalence).
+ *   2. Distinct AgentRunContext instances do not share per-run maps.
+ *   3. toolAggregates is intentionally process-global (shared reference).
+ *   4. getRunContext with no arg / unknown runId returns defaultRunContext.
+ */
+export {};