opencode-swarm 7.126.1 → 7.126.3

package/dist/tools/index.d.ts

@@ -101,6 +101,7 @@ export { lean_turbo_runner_status } from './lean-turbo-runner-status';
 export { lean_turbo_status } from './lean-turbo-status';
 export { lint_spec } from './lint-spec';
 export { mutation_test } from './mutation-test';
+export { executePreparePrWorkflowCheckout, prepare_pr_workflow_checkout, } from './prepare-pr-workflow-checkout';
 export { executeRunPrFeedbackStageA, run_pr_feedback_stage_a, } from './run-pr-feedback-stage-a';
 export { symbols } from './symbols';
 export { type SyntaxCheckFileResult, type SyntaxCheckInput, type SyntaxCheckResult, syntax_check, syntaxCheck, } from './syntax-check';

package/dist/tools/manifest.d.ts

@@ -44,6 +44,7 @@ export declare const TOOL_MANIFEST: {
     completion_verify: () => ToolDefinition;
     complete_pr_workflow: () => ToolDefinition;
     abort_pr_workflow: () => ToolDefinition;
+    prepare_pr_workflow_checkout: () => ToolDefinition;
     run_pr_feedback_stage_a: () => ToolDefinition;
     submit_council_verdicts: () => ToolDefinition;
     submit_phase_council_verdicts: () => ToolDefinition;

package/dist/tools/prepare-pr-workflow-checkout.d.ts

@@ -0,0 +1,25 @@
+import { createSwarmTool } from './create-tool.js';
+/**
+ * Preserve explicit dirty tracked files before the unbound PR checkout.
+ *
+ * The tool uses the canonical gate's cross-process mutation lock and
+ * schema-validated state, so an abort, bind, or same-session reactivation
+ * cannot revoke or replace authorization while the fixed Git command runs.
+ * The independent receipt is retained under `.swarm/` after terminal gate
+ * cleanup so the exact stash recovery command remains auditable.
+ */
+export declare function executePreparePrWorkflowCheckout(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+declare function runGit(directory: string, args: string[], options?: {
+    captureStdout?: boolean;
+}): Promise<{
+    exitCode: number;
+    stdout: string;
+}>;
+/** Test-only seam for serializing concurrent real-Git checkout preparation. */
+export declare const _internals: {
+    runGit: typeof runGit;
+};
+export declare const prepare_pr_workflow_checkout: ReturnType<typeof createSwarmTool>;
+export {};

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

@@ -16,12 +16,13 @@ import { extractFileOntology } from './ontology';
 import { safeRealpathSync } from './safe-realpath';
 import type { BuildWorkspaceGraphOptions, GraphEdge, GraphNode, RepoGraph, RepoGraphDiagnostics, SymbolEdge } from './types';
 /**
- * _internals DI seam for safeRealpathSync.
- * Defaults to the real implementation. Tests can override this to inject
- * mock behavior without calling mock.module(...) which leaks across test files
- * in Bun's shared test-runner process.
+ * _internals DI seam for the walk clock and graph helpers.
+ * Defaults to the real implementations. Tests can override these to inject
+ * deterministic behavior without calling mock.module(...) which leaks across
+ * test files in Bun's shared test-runner process.
  */
 export declare const _internals: {
+    now: () => number;
     safeRealpathSync: typeof safeRealpathSync;
     extractTSSymbols: typeof extractTSSymbols;
     extractPythonSymbols: typeof extractPythonSymbols;

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

@@ -156,6 +156,10 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: "architect"[];
     };
+    prepare_pr_workflow_checkout: {
+        description: string;
+        agents: "architect"[];
+    };
     run_pr_feedback_stage_a: {
         description: string;
         agents: "architect"[];

package/dist/utils/timeout.d.ts

@@ -1,9 +1,10 @@
 /**
  * Timeout primitives used by the plugin init path.
  *
- * Hard rule: every timer scheduled here must call `unref()` so it never holds
- * the process open, and every Promise.race must clear the timer in `finally`
- * so it does not leak the timer reference after the racer settles.
+ * Deadline timers must call `unref()` and every Promise.race must clear its
+ * timer in `finally`, so timeouts never pin or leak a process handle. Awaited
+ * cooperative-yield timers are deliberately ref'ed: unref'ing the only handle
+ * can strand their caller before the awaited promise resolves.
  */
 /**
  * Race a promise against a timeout. The timer is cleared in `finally` so the
@@ -18,6 +19,9 @@
 export declare function withTimeout<T>(promise: Promise<T>, ms: number, timeoutError: Error): Promise<T>;
 /**
  * Yield to the macrotask queue. Works under both Node and Bun runtimes,
- * unlike `setImmediate` which is Node-only.
+ * unlike `setImmediate` which is Node-only. The timer intentionally remains
+ * ref'ed: callers await this promise, so unref'ing its only handle can strand a
+ * direct async caller when no unrelated host handle is active. Detached startup
+ * work is made non-pinning at its outer scheduling boundary instead.
  */
 export declare function yieldToEventLoop(): Promise<void>;

package/package.json

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