opencode-swarm 6.17.3 → 6.18.1

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

@@ -0,0 +1,29 @@
+/**
+ * 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';
+/**
+ * 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): 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,83 @@
+/**
+ * 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;
+    gateLog: Record<string, string[]>;
+    reviewerCallCount: Record<string, number>;
+    lastGateFailure: {
+        tool: string;
+        taskId: string;
+        timestamp: number;
+    } | null;
+    partialGateWarningsIssuedForTask: string[];
+    selfFixAttempted: boolean;
+    catastrophicPhaseWarnings: number[];
+    lastPhaseCompleteTimestamp: number;
+    lastPhaseCompletePhase: number;
+    phaseAgentsDispatched: string[];
+    qaSkipCount: number;
+    qaSkipTaskIds: string[];
+}
+/**
+ * Minimal interface for serialized InvocationWindow
+ */
+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;
+}
+/**
+ * Snapshot data structure written to disk
+ */
+export interface SnapshotData {
+    version: 1;
+    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.
+ * Returns a hook function that writes the current swarmState to disk.
+ */
+export declare function createSnapshotWriterHook(directory: string): (input: unknown, output: unknown) => Promise<void>;
+export {};

package/dist/tools/co-change-analyzer.d.ts

@@ -1,3 +1,4 @@
+import { tool } from '@opencode-ai/plugin';
 import type { SwarmKnowledgeEntry } from '../hooks/knowledge-types.js';
 export interface CoChangeEntry {
     fileA: string;
@@ -41,3 +42,4 @@ export declare function darkMatterToKnowledgeEntries(pairs: CoChangeEntry[], pro
  * Formats dark matter findings as markdown output.
  */
 export declare function formatDarkMatterOutput(pairs: CoChangeEntry[]): string;
+export declare const co_change_analyzer: ReturnType<typeof tool>;

package/dist/tools/create-tool.d.ts

@@ -0,0 +1,15 @@
+import { tool } from '@opencode-ai/plugin';
+/**
+ * Options for creating a swarm tool.
+ * The args type is inferred from what you pass to the tool() call.
+ */
+export interface SwarmToolOptions<Args extends Record<string, unknown>> {
+    description: string;
+    args: Args;
+    execute: (args: Args, directory: string) => Promise<string>;
+}
+/**
+ * Creates a swarm tool with automatic working directory injection.
+ * Wraps the @opencode-ai/plugin/tool factory to always inject `directory` into tool execute callbacks.
+ */
+export declare function createSwarmTool<Args extends Record<string, unknown>>(opts: SwarmToolOptions<Args>): ReturnType<typeof tool>;

package/dist/tools/index.d.ts

@@ -9,14 +9,14 @@ export { fetchGitingest, type GitingestArgs, gitingest } from './gitingest';
 export { imports } from './imports';
 export { lint } from './lint';
 export { phase_complete } from './phase-complete';
-export { save_plan } from './save-plan';
-export type { SavePlanArgs, SavePlanResult } from './save-plan';
 export { pkg_audit } from './pkg-audit';
 export { type PlaceholderFinding, type PlaceholderScanInput, type PlaceholderScanResult, placeholderScan, } from './placeholder-scan';
 export { type PreCheckBatchInput, type PreCheckBatchResult, pre_check_batch, runPreCheckBatch, type ToolResult, } from './pre-check-batch';
 export { type QualityBudgetInput, type QualityBudgetResult, qualityBudget, } from './quality-budget';
 export { retrieve_summary } from './retrieve-summary';
-export { type SastScanFinding, type SastScanInput, type SastScanResult, sastScan, } from './sast-scan';
+export { type SastScanFinding, type SastScanInput, type SastScanResult, sast_scan, sastScan, } from './sast-scan';
+export type { SavePlanArgs, SavePlanResult } from './save-plan';
+export { save_plan } from './save-plan';
 export { type SbomGenerateInput, type SbomGenerateResult, sbom_generate, } from './sbom-generate';
 export { schema_drift } from './schema-drift';
 export { type SecretFinding, type SecretscanResult, secretscan, } from './secretscan';
@@ -24,3 +24,4 @@ export { symbols } from './symbols';
 export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntaxCheck, } from './syntax-check';
 export { test_runner } from './test-runner';
 export { todo_extract } from './todo-extract';
+export { executeWriteRetro, write_retro } from './write-retro';

package/dist/tools/phase-complete.d.ts

@@ -2,7 +2,7 @@
  * Phase completion tool for tracking and validating phase completion.
  * Core implementation - gathers data, enforces policy, writes event, resets state.
  */
-import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 /**
  * Arguments for the phase_complete tool
  */

package/dist/tools/sast-scan.d.ts

@@ -2,6 +2,7 @@
  * SAST Scan Tool - Static Application Security Testing
  * Integrates Tier A rules (offline) and optional Semgrep (Tier B)
  */
+import type { ToolDefinition } from '@opencode-ai/plugin/tool';
 import type { PluginConfig } from '../config';
 import type { EvidenceVerdict } from '../config/evidence-schema';
 export interface SastScanInput {
@@ -50,3 +51,10 @@ export interface SastScanFinding {
  * - Tier B: Semgrep (optional, if available on PATH)
  */
 export declare function sastScan(input: SastScanInput, directory: string, config?: PluginConfig): Promise<SastScanResult>;
+/**
+ * SAST Scan tool - Static Application Security Testing
+ * Scans changed files for security vulnerabilities using:
+ * - Tier A: Built-in pattern-based rules (always runs)
+ * - Tier B: Semgrep (optional, if available on PATH)
+ */
+export declare const sast_scan: ToolDefinition;

package/dist/tools/save-plan.d.ts

@@ -47,7 +47,7 @@ export declare function detectPlaceholderContent(args: SavePlanArgs): string[];
  * @param args - The save plan arguments
  * @returns SavePlanResult with success status and details
  */
-export declare function executeSavePlan(args: SavePlanArgs): Promise<SavePlanResult>;
+export declare function executeSavePlan(args: SavePlanArgs, fallbackDir?: string): Promise<SavePlanResult>;
 /**
  * Tool definition for save_plan
  */

package/dist/tools/write-retro.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Write retro tool for persisting retrospective evidence bundles.
+ * Accepts flat retro fields from the Architect and wraps them correctly
+ * in a RetrospectiveEvidence entry before calling saveEvidence().
+ * This fixes the bug where Architect was writing flat JSON that failed EvidenceBundleSchema.parse().
+ */
+import { type ToolDefinition } from '@opencode-ai/plugin/tool';
+/**
+ * Arguments for the write_retro tool
+ * User-supplied fields (the Architect provides these)
+ */
+export interface WriteRetroArgs {
+    /** The phase number being completed (maps to phase_number in schema) */
+    phase: number;
+    /** Human-readable phase summary (maps to summary in BaseEvidenceSchema) */
+    summary: string;
+    /** Count of tasks completed */
+    task_count: number;
+    /** Task complexity level */
+    task_complexity: 'trivial' | 'simple' | 'moderate' | 'complex';
+    /** Total number of tool calls in the phase */
+    total_tool_calls: number;
+    /** Number of coder revisions made */
+    coder_revisions: number;
+    /** Number of reviewer rejections received */
+    reviewer_rejections: number;
+    /** Number of test failures encountered */
+    test_failures: number;
+    /** Number of security findings */
+    security_findings: number;
+    /** Number of integration issues */
+    integration_issues: number;
+    /** Optional lessons learned (max 5) */
+    lessons_learned?: string[];
+    /** Optional top rejection reasons */
+    top_rejection_reasons?: string[];
+    /** Optional task ID (defaults to retro-{phase}) */
+    task_id?: string;
+    /** Optional metadata */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Execute the write_retro tool.
+ * Validates input, builds a RetrospectiveEvidence entry, and saves to disk.
+ * @param args - The write retro arguments
+ * @param directory - Working directory
+ * @returns JSON string with success status and details
+ */
+export declare function executeWriteRetro(args: WriteRetroArgs, directory: string): Promise<string>;
+/**
+ * Tool definition for write_retro
+ */
+export declare const write_retro: ToolDefinition;

package/package.json

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