opencode-swarm 7.132.2 → 7.134.0

package/dist/cli/worktree-collision-ownership-c4bdnjtx.js

@@ -0,0 +1,221 @@
+// @bun
+import {
+  scanWorktreeProvisioningOwnersForRecovery
+} from "./index-b4z7s917.js";
+import {
+  scanWorktreeMergeFailuresForRecovery
+} from "./index-b8zgtz81.js";
+import {
+  scanDelegationFallbacksForRecovery,
+  scanDelegationsForRecovery
+} from "./index-y3v1404y.js";
+import"./index-2ghkk9ve.js";
+import"./index-fsrp8wp3.js";
+import"./index-5nybajn9.js";
+import"./index-7g4c7s5r.js";
+import"./index-q2rrv0cy.js";
+import"./index-bpmtbmy9.js";
+import"./index-z6xqpmqg.js";
+import"./index-zjygnfay.js";
+import {
+  bunSpawn
+} from "./index-qe3v54nb.js";
+import"./index-zgwm4ryv.js";
+import"./index-a76rekgs.js";
+
+// src/hooks/delegation-gate/worktree-collision-ownership.ts
+import * as path2 from "path";
+
+// src/hooks/delegation-gate/worktree-ownership-tag.ts
+import * as fs from "fs";
+import * as path from "path";
+var OWNERSHIP_TAG_SCAN_TIMEOUT_MS = 2000;
+var MAX_OWNERSHIP_TAGS = 512;
+function decodeTagPart(value) {
+  if (!value || !/^[A-Za-z0-9_-]+$/.test(value))
+    return null;
+  const decoded = Buffer.from(value, "base64url").toString("utf8");
+  return decoded && Buffer.from(decoded, "utf8").toString("base64url") === value ? decoded : null;
+}
+async function scanBackgroundWorktreeOwnershipTagsForRecovery(directory) {
+  try {
+    fs.statSync(path.join(directory, ".git"));
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return { status: "ok", owners: [] };
+    }
+    return {
+      status: "uncertain",
+      reason: `Git metadata could not be inspected: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+  const proc = bunSpawn([
+    "git",
+    "-C",
+    directory,
+    "for-each-ref",
+    `--count=${MAX_OWNERSHIP_TAGS + 1}`,
+    "--format=%(refname:strip=2)%00%(objectname)",
+    "refs/tags/swarm-preserved-owner/"
+  ], {
+    stdin: "ignore",
+    stdout: "pipe",
+    stderr: "ignore",
+    timeout: OWNERSHIP_TAG_SCAN_TIMEOUT_MS
+  });
+  try {
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      return {
+        status: "uncertain",
+        reason: `ownership tag scan exited ${exitCode}`
+      };
+    }
+    const lines = (await proc.stdout.text()).split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    if (lines.length > MAX_OWNERSHIP_TAGS) {
+      return {
+        status: "uncertain",
+        reason: `ownership tag scan exceeded the ${MAX_OWNERSHIP_TAGS}-tag safety bound`
+      };
+    }
+    const owners = [];
+    for (const line of lines) {
+      const [tag, ref, ...extra] = line.split("\x00");
+      const segments = tag?.split("/") ?? [];
+      const sessionId = decodeTagPart(segments[1] ?? "");
+      const laneId = decodeTagPart(segments[2] ?? "");
+      const callDigest = segments[3];
+      if (extra.length > 0 || segments.length !== 4 || segments[0] !== "swarm-preserved-owner" || !sessionId || !laneId || !callDigest || !/^[0-9a-f]{12}$/.test(callDigest) || !ref || !/^[0-9a-f]{40,64}$/i.test(ref)) {
+        return {
+          status: "uncertain",
+          reason: `malformed background ownership tag entry "${tag ?? ""}"`
+        };
+      }
+      owners.push({ sessionId, laneId, callDigest, ref });
+    }
+    return { status: "ok", owners };
+  } catch (error) {
+    return {
+      status: "uncertain",
+      reason: `ownership tag scan failed: ${error instanceof Error ? error.message : String(error)}`
+    };
+  } finally {
+    try {
+      proc.kill();
+    } catch {}
+  }
+}
+
+// src/hooks/delegation-gate/worktree-collision-ownership.ts
+function normalizedPath(value) {
+  const resolved = path2.normalize(path2.resolve(value));
+  return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function descriptorCoordinateMatch(descriptor, identity) {
+  const branchMatches = descriptor.branchName === identity.branchName;
+  const pathMatches = normalizedPath(descriptor.worktreePath) === normalizedPath(identity.worktreePath);
+  if (!branchMatches && !pathMatches)
+    return "none";
+  if (!branchMatches || !pathMatches || descriptor.parentSessionId !== identity.parentSessionId || descriptor.taskId !== identity.taskId) {
+    return "uncertain";
+  }
+  return "exact";
+}
+function isProvenSettled(record) {
+  const settlement = record.coderSettlement;
+  return settlement?.state === "settled" && settlement.outcome?.kind === "standard-worktree" && (settlement.outcome.result === "merged" || settlement.outcome.result === "unchanged");
+}
+function classifyRecord(record, identity, ownerKind) {
+  if (!record.worktree)
+    return null;
+  const coordinates = descriptorCoordinateMatch(record.worktree, identity);
+  if (coordinates === "none")
+    return null;
+  if (coordinates === "uncertain") {
+    return {
+      status: "uncertain",
+      reason: `${ownerKind} background owner has conflicting identity for branch "${identity.branchName}"`
+    };
+  }
+  if (isProvenSettled(record))
+    return null;
+  const lifecycle = record.coderSettlement?.state === "preserved" ? "preserved" : "active";
+  return {
+    status: "protected",
+    ownerKind,
+    lifecycle,
+    reason: `${ownerKind} background owner ${record.correlationId} is ${record.status}` + (record.coderSettlement ? ` with coder settlement ${record.coderSettlement.state}` : " without a settled workspace outcome")
+  };
+}
+async function inspectStandardWorktreeCollisionOwnership(identity) {
+  const provisioning = scanWorktreeProvisioningOwnersForRecovery(identity.directory);
+  if (provisioning.status === "uncertain")
+    return provisioning;
+  for (const owner of provisioning.owners) {
+    const sameSession = owner.parentSessionId === identity.parentSessionId || owner.worktreeSessionId === identity.parentSessionId;
+    if (!sameSession)
+      continue;
+    if (owner.schemaVersion === 1 || owner.taskId === identity.taskId) {
+      return {
+        status: "protected",
+        ownerKind: "provisioning",
+        lifecycle: "active",
+        reason: owner.schemaVersion === 1 ? `legacy provisioning owner ${owner.callID} cannot disprove ownership of this same-session lane` : `provisioning owner ${owner.callID} is active for task ${identity.taskId}`
+      };
+    }
+  }
+  const fallback = await scanDelegationFallbacksForRecovery(identity.directory);
+  if (fallback.status === "uncertain")
+    return fallback;
+  for (const artifact of fallback.owners) {
+    const classified = classifyRecord(artifact.record, identity, "fallback");
+    if (classified)
+      return classified;
+  }
+  const primary = scanDelegationsForRecovery(identity.directory);
+  if (primary.status === "uncertain")
+    return primary;
+  for (const record of primary.owners) {
+    const classified = classifyRecord(record, identity, "primary");
+    if (classified)
+      return classified;
+  }
+  const tags = await scanBackgroundWorktreeOwnershipTagsForRecovery(identity.directory);
+  if (tags.status === "uncertain")
+    return tags;
+  for (const owner of tags.owners) {
+    if (owner.sessionId === identity.parentSessionId && owner.laneId === identity.taskId) {
+      return {
+        status: "protected",
+        ownerKind: "ownership-tag",
+        lifecycle: "preserved",
+        reason: `durable ownership tag ${owner.callDigest} preserves this same-session lane`
+      };
+    }
+  }
+  const mergeStatus = scanWorktreeMergeFailuresForRecovery(identity.directory);
+  if (mergeStatus.status === "uncertain")
+    return mergeStatus;
+  for (const [, failure] of mergeStatus.failures) {
+    const branchMatches = failure.branch === identity.branchName;
+    const pathMatches = typeof failure.worktreePath === "string" && normalizedPath(failure.worktreePath) === normalizedPath(identity.worktreePath);
+    if (!branchMatches && !pathMatches)
+      continue;
+    if (!branchMatches || !pathMatches) {
+      return {
+        status: "uncertain",
+        reason: `merge-status owner has conflicting identity for branch "${identity.branchName}"`
+      };
+    }
+    return {
+      status: "protected",
+      ownerKind: "merge-status",
+      lifecycle: "preserved",
+      reason: `merge-status records ${failure.outcome} at stage ${failure.stage}`
+    };
+  }
+  return { status: "unowned" };
+}
+export {
+  inspectStandardWorktreeCollisionOwnership
+};

package/dist/commands/command-dispatch.d.ts

@@ -1,5 +1,8 @@
 import type { AgentDefinition } from '../agents/index.js';
+import type { AutoReviewConfig } from '../config/schema.js';
 import type { EvaluationModelDispatcher } from '../evaluation/model-dispatcher.js';
+import type { ReviewModelDispatcher } from '../review/contracts.js';
+import type { ReviewAgentModelRegistry } from '../review/runtime.js';
 import { type CommandEntry, resolveCommand } from './registry.js';
 export type ResolvedSwarmCommand = NonNullable<ReturnType<typeof resolveCommand>>;
 export type SwarmCommandPolicyResult = {
@@ -29,5 +32,9 @@ export declare function executeSwarmCommand(args: {
     buildHelpText?: () => string;
     policy?: SwarmCommandPolicy;
     evaluationModelDispatcher?: EvaluationModelDispatcher;
+    reviewModelDispatcher?: ReviewModelDispatcher;
+    autoReviewConfig?: AutoReviewConfig;
+    activeAgentName?: string;
+    reviewAgentModelRegistry?: ReviewAgentModelRegistry;
 }): Promise<SwarmCommandExecutionResult>;
 export type { CommandEntry };

package/dist/commands/index.d.ts

@@ -1,5 +1,8 @@
 import type { AgentDefinition } from '../agents/index.js';
+import type { AutoReviewConfig } from '../config/schema.js';
 import type { EvaluationModelDispatcher } from '../evaluation/model-dispatcher.js';
+import type { ReviewModelDispatcher } from '../review/contracts.js';
+import type { ReviewAgentModelRegistry } from '../review/runtime.js';
 export { handleAcknowledgeSpecDriftCommand } from './acknowledge-spec-drift';
 export { handleAgentsCommand } from './agents';
 export { handleAnalyzeCommand } from './analyze';
@@ -49,6 +52,7 @@ export { COMMAND_REGISTRY, resolveCommand, VALID_COMMANDS, } from './registry.js
 export { handleResetCommand } from './reset';
 export { handleResetSessionCommand } from './reset-session';
 export { handleRetrieveCommand } from './retrieve';
+export { handleReviewCommand } from './review';
 export { handleRollbackCommand } from './rollback';
 export { handleSddCommand, handleSddProjectCommand, handleSddStatusCommand, handleSddValidateCommand, } from './sdd';
 export { handleSimulateCommand } from './simulate';
@@ -71,6 +75,9 @@ export declare function createSwarmCommandHandler(directory: string, agents: Rec
         tools?: Record<string, boolean>;
     }>;
     evaluationModelDispatcher?: EvaluationModelDispatcher;
+    reviewModelDispatcher?: ReviewModelDispatcher;
+    autoReviewConfig?: AutoReviewConfig;
+    reviewAgentModelRegistry?: ReviewAgentModelRegistry;
 }): (input: {
     command: string;
     sessionID: string;

package/dist/commands/registry.d.ts

@@ -1,5 +1,9 @@
 import type { AgentDefinition } from '../agents/index.js';
+import type { AutoReviewConfig } from '../config/schema.js';
 import type { EvaluationModelDispatcher } from '../evaluation/model-dispatcher.js';
+import type { ReviewModelDispatcher } from '../review/contracts.js';
+import type { ReviewAgentModelRegistry } from '../review/runtime.js';
+import { handleReviewCommand } from './review.js';
 declare function levenshteinDistance(a: string, b: string): number;
 declare function findSimilarCommands(query: string): string[];
 declare function emitValidationWarnings(prefix: string, warnings: readonly string[]): void;
@@ -20,6 +24,10 @@ export type CommandContext = {
      */
     source?: 'cli' | 'chat';
     evaluationModelDispatcher?: EvaluationModelDispatcher;
+    reviewModelDispatcher?: ReviewModelDispatcher;
+    autoReviewConfig?: AutoReviewConfig;
+    activeAgentName?: string;
+    reviewAgentModelRegistry?: ReviewAgentModelRegistry;
 };
 export type CommandResult = Promise<string>;
 export type CommandCategory = 'core' | 'agent' | 'config' | 'diagnostics' | 'utility';
@@ -236,6 +244,14 @@ export declare const COMMAND_REGISTRY: {
         readonly category: "diagnostics";
         readonly toolPolicy: "agent";
     };
+    readonly review: {
+        readonly handler: typeof handleReviewCommand;
+        readonly description: "Run the independent review model against a selected Git diff";
+        readonly args: "--base <ref>, --range <from..to|from...to>, --working-tree, --json";
+        readonly details: "Collects one bounded canonical diff, dispatches the configured reviewer in a fresh read-only session, optionally validates eligible HIGH/CRITICAL findings when configured or required by gate mode, and persists the receipt and evidence. With no selector, reviews the default merge-base plus working-tree scope.";
+        readonly category: "diagnostics";
+        readonly toolPolicy: "human-only";
+    };
     readonly costs: {
         readonly handler: (ctx: CommandContext) => Promise<string>;
         readonly description: "Show per-agent and per-task token/cost telemetry [--json]";

package/dist/commands/review.d.ts

@@ -0,0 +1,21 @@
+import { type ReviewDiffSelector } from '../review/diff-source.js';
+import { type ReviewEngineResult, type RunReviewEngineInput } from '../review/engine.js';
+import type { AutoReviewEvidence } from '../review/evidence.js';
+import type { CommandContext } from './registry.js';
+declare function findAgentName(agents: CommandContext['agents'], role: string, preferredPrefix?: string): string | undefined;
+declare function formatSelector(selector: ReviewDiffSelector): string;
+declare function renderHuman(result: ReviewEngineResult, evidence: AutoReviewEvidence | null, requestedSelector: ReviewDiffSelector): string;
+declare function renderJson(result: ReviewEngineResult, evidence: AutoReviewEvidence | null, requestedSelector: ReviewDiffSelector): string;
+export declare function handleReviewCommand(ctx: CommandContext): Promise<string>;
+export declare const _internals: {
+    runReviewEngine: (input: RunReviewEngineInput) => Promise<ReviewEngineResult>;
+    readEvidence: (evidencePath: string | undefined, directory: string) => AutoReviewEvidence | null;
+};
+export declare const _test_exports: {
+    MAX_JSON_WRAPPER_BYTES: number;
+    findAgentName: typeof findAgentName;
+    formatSelector: typeof formatSelector;
+    renderHuman: typeof renderHuman;
+    renderJson: typeof renderJson;
+};
+export {};

package/dist/config/agent-names.d.ts

@@ -9,11 +9,11 @@
  * constants.ts re-exports every symbol here, so existing
  * `import { ALL_AGENT_NAMES } from '../config/constants'` call sites are unchanged.
  */
-export declare const QA_AGENTS: readonly ["reviewer", "critic", "critic_oversight"];
+export declare const QA_AGENTS: readonly ["reviewer", "critic", "critic_oversight", "critic_finding_validator"];
 export declare const PIPELINE_AGENTS: readonly ["explorer", "coder", "test_engineer"];
 export declare const ORCHESTRATOR_NAME: "architect";
-export declare const ALL_SUBAGENT_NAMES: readonly ["sme", "researcher", "docs", "docs_design", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "critic_architecture_supervisor", "curator_init", "curator_phase", "curator_postmortem", "curator_consolidation", "council_generalist", "council_skeptic", "council_domain_expert", "skill_improver", "spec_writer", "reviewer", "critic", "critic_oversight", "explorer", "coder", "test_engineer"];
-export declare const ALL_AGENT_NAMES: readonly ["architect", "sme", "researcher", "docs", "docs_design", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "critic_architecture_supervisor", "curator_init", "curator_phase", "curator_postmortem", "curator_consolidation", "council_generalist", "council_skeptic", "council_domain_expert", "skill_improver", "spec_writer", "reviewer", "critic", "critic_oversight", "explorer", "coder", "test_engineer"];
+export declare const ALL_SUBAGENT_NAMES: readonly ["sme", "researcher", "docs", "docs_design", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "critic_architecture_supervisor", "curator_init", "curator_phase", "curator_postmortem", "curator_consolidation", "council_generalist", "council_skeptic", "council_domain_expert", "skill_improver", "spec_writer", "reviewer", "critic", "critic_oversight", "critic_finding_validator", "explorer", "coder", "test_engineer"];
+export declare const ALL_AGENT_NAMES: readonly ["architect", "sme", "researcher", "docs", "docs_design", "designer", "critic_sounding_board", "critic_drift_verifier", "critic_hallucination_verifier", "critic_architecture_supervisor", "curator_init", "curator_phase", "curator_postmortem", "curator_consolidation", "council_generalist", "council_skeptic", "council_domain_expert", "skill_improver", "spec_writer", "reviewer", "critic", "critic_oversight", "critic_finding_validator", "explorer", "coder", "test_engineer"];
 export type QAAgentName = (typeof QA_AGENTS)[number];
 export type PipelineAgentName = (typeof PIPELINE_AGENTS)[number];
 export type AgentName = (typeof ALL_AGENT_NAMES)[number];