opencode-swarm 7.91.1 → 7.93.0

package/dist/services/session-reflection.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Session reflection service — two-phase end-of-session architect review.
+ *
+ * Phase 1 (deterministic): Aggregate session signals — tool failures, gate
+ * rejections, error taxonomy, agent dispatches, retro lessons. No LLM, no
+ * quota, fast. Produces a structured snapshot the architect can reason over.
+ *
+ * Phase 2 (LLM): Feed the snapshot to the skill_improver agent (which acts
+ * as the architect's reflection delegate) to produce an actionable report:
+ * what skills to create/change, what problems were encountered, what tools
+ * didn't work, and what the swarm should learn for next time. The report is
+ * surfaced directly in the finalize output — not buried in an artifact.
+ *
+ * When no LLM client is available, phase 2 falls back to a deterministic
+ * summary so finalize never blocks on missing infrastructure.
+ */
+import { type SkillImproverLLMDelegate } from '../hooks/skill-improver-llm-factory';
+import type { ToolAggregate } from '../state';
+export interface ToolProblem {
+    tool: string;
+    failureCount: number;
+    totalCalls: number;
+    failureRate: number;
+    avgDurationMs: number;
+}
+export interface AgentDispatchSummary {
+    agent: string;
+    delegationCount: number;
+    lastDelegationReason?: string;
+}
+export interface GateFailureSummary {
+    gate: string;
+    taskId: string;
+    count: number;
+}
+export interface SessionReflectionData {
+    timestamp: string;
+    totalToolCalls: number;
+    totalToolFailures: number;
+    toolProblems: ToolProblem[];
+    agentDispatches: AgentDispatchSummary[];
+    gateFailures: GateFailureSummary[];
+    lessonsFromRetros: string[];
+    errorTaxonomy: Record<string, number>;
+}
+export interface SessionReflectionResult {
+    data: SessionReflectionData;
+    architectReport: string;
+    source: 'llm' | 'deterministic';
+}
+declare function gatherToolProblems(toolAggregates: Map<string, ToolAggregate>): {
+    problems: ToolProblem[];
+    totalCalls: number;
+    totalFailures: number;
+};
+interface AgentSessionLike {
+    agentName: string;
+    lastDelegationReason?: string;
+}
+declare function gatherAgentDispatches(agentSessions: Map<string, AgentSessionLike>): AgentDispatchSummary[];
+declare function gatherRetroLessonsAndTaxonomy(directory: string): Promise<{
+    lessons: string[];
+    taxonomy: Record<string, number>;
+}>;
+declare function gatherGateFailures(directory: string): Promise<GateFailureSummary[]>;
+declare function buildReflectionDataSummary(data: SessionReflectionData): string;
+declare function buildDeterministicReport(data: SessionReflectionData): string;
+export interface SessionReflectionInput {
+    directory: string;
+    toolAggregates: Map<string, ToolAggregate>;
+    agentSessions: Map<string, AgentSessionLike>;
+    sessionId?: string;
+    signal?: AbortSignal;
+    delegate?: SkillImproverLLMDelegate;
+}
+export declare function runSessionReflection(input: SessionReflectionInput): Promise<SessionReflectionResult>;
+export declare function writeSessionReflection(directory: string, result: SessionReflectionResult): Promise<string>;
+export declare const _internals: {
+    gatherToolProblems: typeof gatherToolProblems;
+    gatherAgentDispatches: typeof gatherAgentDispatches;
+    gatherRetroLessonsAndTaxonomy: typeof gatherRetroLessonsAndTaxonomy;
+    gatherGateFailures: typeof gatherGateFailures;
+    buildReflectionDataSummary: typeof buildReflectionDataSummary;
+    buildDeterministicReport: typeof buildDeterministicReport;
+};
+export {};

package/dist/tools/apply-patch.d.ts

@@ -45,4 +45,10 @@ export interface ApplyPatchArgs {
     allowCreates?: boolean;
     allowDeletes?: boolean;
 }
-export declare const applyPatch: ToolDefinition;
+/**
+ * Swarm unified-diff patch tool (formerly registered as apply_patch).
+ * Renamed to swarm_apply_patch so it no longer shadows the native opencode
+ * apply_patch tool. The native tool handles *** Begin Patch / *** Update File
+ * style payloads; this tool handles standard unified diffs only.
+ */
+export declare const swarmApplyPatch: ToolDefinition;

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

@@ -201,6 +201,7 @@ export declare const _internals: {
 };
 export declare const _test_exports: {
     applyCommonPrompt: typeof applyCommonPrompt;
+    applyExplorerFormatSuffix: typeof applyExplorerFormatSuffix;
     extractAssistantTranscript: typeof extractAssistantTranscript;
     formatError: typeof formatError;
     nextCollectPollInterval: typeof nextCollectPollInterval;
@@ -274,6 +275,7 @@ type ApplyCommonPromptResult = {
  * prompts when it is. Callers may treat the returned array as their own.
  */
 declare function applyCommonPrompt(lanes: DispatchLaneSpec[], commonPrompt: string | undefined): ApplyCommonPromptResult;
+declare function applyExplorerFormatSuffix(lanes: DispatchLaneSpec[]): DispatchLaneSpec[];
 declare function formatError(error: unknown): string;
 declare function promptHash(lane: DispatchLaneSpec, directory: string, batchId: string): string;
 export declare const dispatch_lanes: ReturnType<typeof createSwarmTool>;

package/dist/tools/index.d.ts

@@ -1,6 +1,6 @@
-import { applyPatch } from './apply-patch';
-export { applyPatch };
-export declare const apply_patch: typeof applyPatch;
+import { swarmApplyPatch } from './apply-patch';
+export { swarmApplyPatch };
+export declare const swarm_apply_patch: typeof swarmApplyPatch;
 export { batch_symbols } from './batch-symbols';
 export { build_check } from './build-check';
 export { check_gate_status } from './check-gate-status';

package/dist/tools/manifest.d.ts

@@ -112,7 +112,7 @@ export declare const TOOL_MANIFEST: {
     lean_turbo_review: () => ToolDefinition;
     lean_turbo_run_phase: () => ToolDefinition;
     lean_turbo_status: () => ToolDefinition;
-    apply_patch: () => ToolDefinition;
+    swarm_apply_patch: () => ToolDefinition;
     external_skill_discover: () => ToolDefinition;
     external_skill_list: () => ToolDefinition;
     external_skill_inspect: () => ToolDefinition;

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

@@ -379,7 +379,7 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: never[];
     };
-    apply_patch: {
+    swarm_apply_patch: {
         description: string;
         agents: ("test_engineer" | "coder")[];
     };

package/package.json

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