opencode-swarm 7.79.6 → 7.80.0

package/dist/memory/schema.d.ts

@@ -3,18 +3,18 @@ import type { CuratorMemoryDecision, MemoryKind, MemoryPatch, MemoryProposal, Me
 export declare const MemoryScopeTypeSchema: z.ZodEnum<{
     agent: "agent";
     project: "project";
+    workspace: "workspace";
     run: "run";
     global_user: "global_user";
-    workspace: "workspace";
     repository: "repository";
 }>;
 export declare const MemoryScopeRefSchema: z.ZodObject<{
     type: z.ZodEnum<{
         agent: "agent";
         project: "project";
+        workspace: "workspace";
         run: "run";
         global_user: "global_user";
-        workspace: "workspace";
         repository: "repository";
     }>;
     userId: z.ZodOptional<z.ZodString>;
@@ -63,9 +63,9 @@ export declare const MemoryRecordSchema: z.ZodObject<{
         type: z.ZodEnum<{
             agent: "agent";
             project: "project";
+            workspace: "workspace";
             run: "run";
             global_user: "global_user";
-            workspace: "workspace";
             repository: "repository";
         }>;
         userId: z.ZodOptional<z.ZodString>;
@@ -141,9 +141,9 @@ export declare const MemoryProposalSchema: z.ZodObject<{
             type: z.ZodEnum<{
                 agent: "agent";
                 project: "project";
+                workspace: "workspace";
                 run: "run";
                 global_user: "global_user";
-                workspace: "workspace";
                 repository: "repository";
             }>;
             userId: z.ZodOptional<z.ZodString>;

package/dist/tools/dispatch-lanes.d.ts

@@ -15,9 +15,31 @@ declare const DispatchLanesArgsSchema: z.ZodObject<{
     max_concurrent: z.ZodOptional<z.ZodNumber>;
     timeout_ms: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strip>;
+declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
+    lanes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        agent: z.ZodString;
+        prompt: z.ZodString;
+    }, z.core.$strip>>;
+    max_concurrent: z.ZodOptional<z.ZodNumber>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    batch_id: z.ZodOptional<z.ZodString>;
+    mode: z.ZodOptional<z.ZodString>;
+    pr_head_sha: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const CollectLaneResultsArgsSchema: z.ZodObject<{
+    batch_id: z.ZodString;
+    wait: z.ZodOptional<z.ZodBoolean>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+    include_pending: z.ZodOptional<z.ZodBoolean>;
+    cancel_pending: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
 export type DispatchLaneSpec = z.infer<typeof LaneSchema>;
 export type DispatchLanesArgs = z.infer<typeof DispatchLanesArgsSchema>;
-export type DispatchLaneStatus = 'completed' | 'failed' | 'rejected';
+export type DispatchLanesAsyncArgs = z.infer<typeof DispatchLanesAsyncArgsSchema>;
+export type CollectLaneResultsArgs = z.infer<typeof CollectLaneResultsArgsSchema>;
+export type DispatchLaneStatus = 'pending' | 'completed' | 'failed' | 'rejected' | 'cancelled' | 'stale' | 'consumed';
 export interface DispatchLaneResult {
     id: string;
     agent: string;
@@ -46,6 +68,36 @@ export interface DispatchLanesResult {
     lane_results: DispatchLaneResult[];
     errors?: string[];
 }
+export interface DispatchLanesAsyncResult {
+    success: boolean;
+    failure_class?: 'invalid_args' | 'no_client';
+    message?: string;
+    batch_id: string | null;
+    dispatched: number;
+    pending: number;
+    failed: number;
+    rejected: number;
+    max_concurrent: number;
+    timeout_ms: number;
+    lane_results: DispatchLaneResult[];
+    errors?: string[];
+}
+export interface CollectLaneResultsResult {
+    success: boolean;
+    failure_class?: 'invalid_args' | 'not_found' | 'no_client';
+    message?: string;
+    batch_id: string;
+    total: number;
+    completed: number;
+    failed: number;
+    cancelled: number;
+    stale: number;
+    pending: number;
+    consumed: number;
+    all_settled: boolean;
+    lane_results: DispatchLaneResult[];
+    errors?: string[];
+}
 export interface SessionOps {
     create(args: {
         query: {
@@ -79,6 +131,51 @@ export interface SessionOps {
         } | null;
         error?: unknown;
     }>;
+    promptAsync?: (args: {
+        path: {
+            id: string;
+        };
+        query?: {
+            directory?: string;
+        };
+        body: {
+            agent: string;
+            tools: ReadOnlyToolPermissions;
+            parts: Array<{
+                type: 'text';
+                text: string;
+            }>;
+        };
+        signal?: AbortSignal;
+    }) => Promise<{
+        data?: unknown;
+        error?: unknown;
+    }>;
+    messages?: (args: {
+        path: {
+            id: string;
+        };
+        query?: {
+            directory?: string;
+            limit?: number;
+        };
+    }) => Promise<{
+        data?: Array<{
+            info?: {
+                role?: string;
+            };
+            parts?: Array<{
+                type: string;
+                text?: string;
+            }>;
+        }> | null;
+        error?: unknown;
+    }>;
+    abort?: (args: {
+        path: {
+            id: string;
+        };
+    }) => Promise<unknown>;
     delete(args: {
         path: {
             id: string;
@@ -90,9 +187,13 @@ export declare const _internals: {
     getGeneratedAgentNames: () => readonly string[];
     createParallelDispatcher: typeof createParallelDispatcher;
     now: () => number;
+    sleep: (ms: number) => Promise<void>;
 };
 export declare const _test_exports: {
+    extractLastAssistantText: typeof extractLastAssistantText;
     formatError: typeof formatError;
+    nextCollectPollInterval: typeof nextCollectPollInterval;
+    promptHash: typeof promptHash;
 };
 type ReadOnlyToolPermissions = Record<string, false> & {
     write: false;
@@ -101,8 +202,24 @@ type ReadOnlyToolPermissions = Record<string, false> & {
 };
 interface DispatchLanesExecutionContext {
     callerAgent?: string;
+    sessionID?: string;
 }
 export declare function executeDispatchLanes(args: unknown, directory: string, context?: DispatchLanesExecutionContext): Promise<DispatchLanesResult>;
+export declare function executeDispatchLanesAsync(args: unknown, directory: string, context?: DispatchLanesExecutionContext): Promise<DispatchLanesAsyncResult>;
+export declare function executeCollectLaneResults(args: unknown, directory: string, context?: Pick<DispatchLanesExecutionContext, 'sessionID'>): Promise<CollectLaneResultsResult>;
+declare function extractLastAssistantText(messages: Array<{
+    info?: {
+        role?: string;
+    };
+    parts?: Array<{
+        type: string;
+        text?: string;
+    }>;
+}>): string;
+declare function nextCollectPollInterval(currentMs: number): number;
 declare function formatError(error: unknown): string;
+declare function promptHash(lane: DispatchLaneSpec, directory: string, batchId: string): string;
 export declare const dispatch_lanes: ReturnType<typeof createSwarmTool>;
+export declare const dispatch_lanes_async: ReturnType<typeof createSwarmTool>;
+export declare const collect_lane_results: ReturnType<typeof createSwarmTool>;
 export {};

package/dist/tools/index.d.ts

@@ -15,7 +15,7 @@ export { declare_council_criteria } from './declare-council-criteria';
 export { declare_scope } from './declare-scope';
 export { type DiffErrorResult, type DiffResult, diff } from './diff';
 export { diff_summary } from './diff-summary';
-export { dispatch_lanes } from './dispatch-lanes';
+export { collect_lane_results, dispatch_lanes, dispatch_lanes_async, } from './dispatch-lanes';
 export { doc_extract, doc_scan } from './doc-scan';
 export { detect_domains } from './domain-detector';
 export { evidence_check } from './evidence-check';

package/dist/tools/manifest.d.ts

@@ -100,6 +100,8 @@ export declare const TOOL_MANIFEST: {
     swarm_memory_propose: () => ToolDefinition;
     swarm_command: () => ToolDefinition;
     dispatch_lanes: () => ToolDefinition;
+    dispatch_lanes_async: () => ToolDefinition;
+    collect_lane_results: () => ToolDefinition;
     summarize_work: () => ToolDefinition;
     write_architecture_supervisor_evidence: () => ToolDefinition;
     lean_turbo_plan_lanes: () => ToolDefinition;

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

@@ -331,6 +331,14 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    dispatch_lanes_async: {
+        description: string;
+        agents: "architect"[];
+    };
+    collect_lane_results: {
+        description: string;
+        agents: "architect"[];
+    };
     summarize_work: {
         description: string;
         agents: ("test_engineer" | "coder" | "docs" | "designer" | "explorer" | "sme" | "architect" | "researcher" | "docs_design")[];

package/package.json

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