opencode-swarm 7.149.0 → 7.150.0

package/dist/lang/symbol-graph.d.ts

@@ -50,3 +50,18 @@ export interface FileSymbolFacts {
  * @returns FileSymbolFacts, or null on failure
  */
 export declare function extractFileSymbols(grammarId: string, source: string): Promise<FileSymbolFacts | null>;
+declare function parseDartImport(text: string): FileSymbolFacts['imports'][0] | FileSymbolFacts['imports'] | null;
+declare function parseRubyRequire(text: string): FileSymbolFacts['imports'][0] | null;
+declare function parsePhpUse(text: string): FileSymbolFacts['imports'][0] | null;
+/**
+ * DI seam for direct parser tests — the import parsers are module-private by
+ * design; tests exercise them through this seam instead of `mock.module`,
+ * which leaks across Bun's shared test-runner process (@see AGENTS.md
+ * invariant #7; PR #2361 review R10/PRR-017).
+ */
+export declare const _internals: {
+    parseDartImport: typeof parseDartImport;
+    parseRubyRequire: typeof parseRubyRequire;
+    parsePhpUse: typeof parsePhpUse;
+};
+export {};

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

@@ -24,6 +24,13 @@ export interface ToolProblem {
     totalCalls: number;
     failureRate: number;
     avgDurationMs: number;
+    /**
+     * Issue #2349 sweep: a bounded, deduplicated sample of WHY this tool failed.
+     * Reporting only that a tool failed N times is the same defect class the
+     * sweep set out to close — the reason has to reach a surface a human or
+     * agent actually reads, which is this one.
+     */
+    failureReasons?: string[];
 }
 export interface AgentDispatchSummary {
     agent: string;

package/dist/state.d.ts

@@ -33,6 +33,16 @@ export interface ToolAggregate {
     successCount: number;
     failureCount: number;
     totalDuration: number;
+    /**
+     * A small, bounded, deduplicated sample of WHY this tool failed (issue
+     * #2349 follow-up: agent-activity.ts previously collapsed `output.error`
+     * into a pure boolean and discarded the value). Capped at
+     * MAX_TOOL_FAILURE_REASONS distinct entries, each truncated to
+     * MAX_TOOL_FAILURE_REASON_LENGTH chars, so a tool that fails thousands of
+     * times with the same or varying reasons cannot grow this unboundedly.
+     * Omitted (absent, not an empty array) when no reason was ever recorded.
+     */
+    failureReasons?: string[];
 }
 /**
  * Represents a delegation from one agent to another

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

@@ -96,6 +96,7 @@ declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
         fanout: "fanout";
     }>>;
     pr_review_wave_attempt: z.ZodOptional<z.ZodNumber>;
+    pr_review_contract_retry: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 declare const CollectLaneResultsArgsSchema: z.ZodObject<{
     batch_id: z.ZodString;
@@ -132,6 +133,7 @@ export interface DispatchLaneResult {
     output_artifact_error?: string;
     transcript_incomplete?: boolean;
     message_count?: number;
+    workflow_lane_failure_class?: BackgroundDelegationResult['workflowLaneFailureClass'];
     salvaged_workflow_lanes?: string[];
     salvaged_workflow_lane_recoveries?: Array<{
         workflow_lane: string;
@@ -195,7 +197,7 @@ export interface CollectLaneResultsResult {
     all_settled: boolean;
     lane_results: DispatchLaneResult[];
     /**
-     * Alert-only host liveness advisory for still-pending pr-review lanes past
+     * Alert-only host liveness advisory for still-pending async lanes past
      * the pending-liveness threshold (issue #2280 Part B). Present only when at
      * least one such lane exists; never affects `success`, counts, settlement,
      * or any lane's state.
@@ -415,6 +417,7 @@ export declare const _test_exports: {
             fanout: "fanout";
         }>>;
         pr_review_wave_attempt: z.ZodOptional<z.ZodNumber>;
+        pr_review_contract_retry: z.ZodOptional<z.ZodBoolean>;
     }, z.core.$strip>;
     DEFAULT_TIMEOUT_MS: number;
     DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS: number;
@@ -449,6 +452,29 @@ export declare function executeDispatchLanesAsync(args: unknown, directory: stri
 export declare function executeCollectLaneResults(args: unknown, directory: string, context?: Pick<DispatchLanesExecutionContext, 'sessionID'>): Promise<CollectLaneResultsResult>;
 declare function isRetryableSessionCreateFailure(error: unknown): boolean;
 declare function consumePrReviewReceiptAppendFailureLog(loggedFailures: Set<string>, parentSessionId: string, correlationId: string): boolean;
+/**
+ * Issue #2349: a terminal error read off the last assistant message of a lane
+ * session, classified for settlement.
+ *
+ * `kind` derives from the SDK's discriminated `AssistantMessage.error` union and
+ * is AUTHORITATIVE for the settled lane status. `category`/`retryClass` come
+ * from the canonical {@link classifyProviderFailure} and are advisory
+ * classification for operator legibility. The two are NOT required to agree: an
+ * `APIError` whose message merely contains the word "aborted" settles as an
+ * error (the SDK says `APIError`) while carrying `provider.cancelled` from the
+ * text classifier. The reason string names both so the divergence is visible.
+ */
+interface LaneTerminalError {
+    kind: 'provider' | 'aborted' | 'output_length' | 'unknown';
+    /** SDK discriminator (`error.name`), bounded. */
+    name: string;
+    /** Sanitized + bounded provider message. */
+    message: string;
+    statusCode: number | undefined;
+    /** `ApiError.data.isRetryable` — host-stated, not inferred. */
+    hostRetryable: boolean | undefined;
+    category: string;
+}
 declare function extractAssistantTranscript(messages: Array<{
     info?: {
         role?: string;
@@ -467,6 +493,29 @@ declare function extractAssistantTranscript(messages: Array<{
     messageCount: number;
     transcriptIncomplete: boolean;
     terminalAssistantProof: boolean;
+    /**
+     * Issue #2349: `time.completed` of the last assistant message, surfaced so the
+     * collection loop can require positive turn-over evidence before settling a
+     * lane on an error. Previously computed here but discarded.
+     */
+    completedAt: number | undefined;
+    /**
+     * Issue #2349: the fetch-window truncation term ALONE, deliberately split out
+     * of {@link transcriptIncomplete}. `transcriptIncomplete` also folds in the
+     * TERMINAL `finish === 'length' | 'content-filter'` cases, so gating the
+     * error-settle on it would make the `output_length` classification
+     * unreachable. Only the "there may be unfetched earlier messages" signal is
+     * relevant to "did this lane really produce no output".
+     */
+    windowTruncated: boolean;
+    /**
+     * Issue #2349: the classified terminal error from the last assistant message,
+     * when present. The host records this on the persisted message; before this
+     * change the value was read only as an `=== undefined` existence test for
+     * {@link terminalAssistantProof} and then discarded, so no caller could ever
+     * learn WHY a lane died.
+     */
+    terminalError: LaneTerminalError | undefined;
 };
 declare function reserveCollectionLaneCallBudgets(deadline: number, remainingLaneCount: number, hasStatusCall: boolean, hasRevisionDigestCall?: boolean): {
     laneBudgetMs: number;

package/dist/tools/repo-graph/builder.d.ts

@@ -11,7 +11,7 @@
  * used by both the builder and the incremental updater.
  */
 import { extractFileSymbols } from '../../lang/symbol-graph';
-import { extractGoSymbols, extractPythonSymbols, extractRustSymbols, extractTSSymbols } from '../symbols';
+import { extractDartSymbols, extractGoSymbols, extractPhpSymbols, extractPythonSymbols, extractRubySymbols, extractRustSymbols, extractTSSymbols } from '../symbols';
 import { extractFileOntology } from './ontology';
 import { safeRealpathSync } from './safe-realpath';
 import type { BuildWorkspaceGraphOptions, GraphEdge, GraphExtractorInputWitness, GraphNode, RepoGraph, RepoGraphDiagnostics, SymbolEdge } from './types';
@@ -28,7 +28,13 @@ export declare const _internals: {
     extractPythonSymbols: typeof extractPythonSymbols;
     extractRustSymbols: typeof extractRustSymbols;
     extractGoSymbols: typeof extractGoSymbols;
+    extractDartSymbols: typeof extractDartSymbols;
+    extractRubySymbols: typeof extractRubySymbols;
+    extractPhpSymbols: typeof extractPhpSymbols;
     parseFileImports: typeof parseFileImports;
+    parseDartFileImports: typeof parseDartFileImports;
+    parseRubyFileImports: typeof parseRubyFileImports;
+    parsePhpFileImports: typeof parsePhpFileImports;
     extractFileOntology: typeof extractFileOntology;
     stripComments: typeof stripComments;
     computeUsedSymbols: typeof computeUsedSymbols;
@@ -132,6 +138,26 @@ interface ParsedImport {
  */
 declare function stripComments(content: string): string;
 declare function parseFileImports(rawContent: string, sourceFile?: string, workspaceRoot?: string): ParsedImport[];
+/**
+ * Regex import fallback for Dart (see {@link parseCSharpFileImports}).
+ * `hide` clauses are intentionally unhandled — the import is still recorded
+ * as a namespace import (all symbols minus hidden ones), which is correct
+ * for graph purposes.
+ */
+declare function parseDartFileImports(rawContent: string): ParsedImport[];
+/**
+ * Regex import fallback for Ruby require/require_relative. `require_relative`
+ * resolves against the requiring file's directory, so the specifier is
+ * normalized to './name' when no explicit relative prefix is present.
+ */
+declare function parseRubyFileImports(rawContent: string): ParsedImport[];
+/**
+ * Regex import fallback for PHP `use` declarations. Grouped `use A\B, C\D;`
+ * forms are a known limitation (the whole group is skipped); FQN specifiers
+ * are recorded as-is — mapping them to workspace files requires composer
+ * PSR-4 awareness, which is out of scope (#1531 "where practical").
+ */
+declare function parsePhpFileImports(rawContent: string): ParsedImport[];
 /**
  * Conservatively determine which imported bindings are actually referenced in
  * the importing file's body.

package/dist/tools/symbols.d.ts

@@ -19,5 +19,40 @@ export declare function extractTSSymbols(filePath: string, cwd: string): SymbolI
 export declare function extractPythonSymbols(filePath: string, cwd: string): SymbolInfo[];
 export declare function extractRustSymbols(filePath: string, cwd: string): SymbolInfo[];
 export declare function extractGoSymbols(filePath: string, cwd: string): SymbolInfo[];
+/**
+ * Dart symbols: classes/mixins/enums/extensions and functions. Visibility is
+ * the `_`-prefix convention. Functions declared INSIDE a type body are
+ * emitted as qualified `TypeName.member` method symbols (mirroring the Swift
+ * extractor's naming) instead of being mislabeled as top-level functions;
+ * the qualification also keeps same-named members of different classes from
+ * collapsing in the name:kind dedup.
+ */
+export declare function extractDartSymbols(filePath: string, cwd: string): SymbolInfo[];
+/**
+ * Ruby symbols: modules, classes, constants, and `def` methods with
+ * `private`/`protected` section tracking. A nested class/module saves and
+ * restores the outer section (approximate `end`-balance tracking); targeted
+ * `private :sym` marks the named method. Singleton methods keep their `self.`
+ * qualification in the name. Dynamic constructs (`define_method`, `send`,
+ * metaprogramming) are invisible to this scanner by design.
+ */
+export declare function extractRubySymbols(filePath: string, cwd: string): SymbolInfo[];
+/**
+ * PHP symbols: namespaces, traits/interfaces/classes, functions and methods
+ * with visibility modifiers. Dynamic constructs (variable functions/classes,
+ * variable variables, Blade directives in `.blade.php`) are best-effort
+ * only — see docs/php-laravel.md.
+ */
+export declare function extractPhpSymbols(filePath: string, cwd: string): SymbolInfo[];
 export declare const symbols: ToolDefinition;
+/**
+ * DI seam for testability — tests substitute via `_internals.fn` rather than
+ * `mock.module`, which leaks across Bun's shared test-runner process.
+ * @see AGENTS.md invariant #7
+ */
+export declare const _internals: {
+    extractDartSymbols: typeof extractDartSymbols;
+    extractRubySymbols: typeof extractRubySymbols;
+    extractPhpSymbols: typeof extractPhpSymbols;
+};
 export {};

package/dist/tools/write-pr-review-artifact.d.ts

@@ -1,9 +1,11 @@
+import { assertPrReviewArtifactBoundary } from '../hooks/pr-workflow-gate.js';
 import { createSwarmTool } from './create-tool.js';
 declare function atomicWrite(filePath: string, content: string): Promise<void>;
 declare function atomicCreate(filePath: string, content: string): Promise<boolean>;
 export declare const _internals: {
     atomicWrite: typeof atomicWrite;
     atomicCreate: typeof atomicCreate;
+    assertBoundary: typeof assertPrReviewArtifactBoundary;
 };
 export declare function executeWritePrReviewArtifact(args: unknown, directory: string, context?: {
     sessionID?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "opencode-swarm",
-	"version": "7.149.0",
+	"version": "7.150.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",
@@ -114,6 +114,7 @@
 		"check:pending-fragment": "bun run scripts/check-pending-fragment.ts",
 		"check:gate-portability": "bun run scripts/check-gate-portability.ts",
 		"check:bare-spawn": "bun run scripts/check-bare-executable-spawn.ts",
+		"check:error-channel-discard": "bun run scripts/check-error-channel-discard.ts",
 		"check:memory-recall": "bun run scripts/memory-recall-regression.ts"
 	},
 	"dependencies": {