opencode-swarm 7.124.0 → 7.125.1

package/dist/tools/complete-pr-workflow.d.ts

@@ -0,0 +1,5 @@
+import { createSwarmTool } from './create-tool.js';
+export declare function executeCompletePrWorkflow(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const complete_pr_workflow: ReturnType<typeof createSwarmTool>;

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

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
 import { createParallelDispatcher } from '../parallel/dispatcher/parallel-dispatcher.js';
 import { createSwarmTool } from './create-tool.js';
 export declare const MAX_PROMPT_CHARS = 80000;
@@ -6,12 +7,18 @@ declare const LaneSchema: z.ZodObject<{
     id: z.ZodString;
     agent: z.ZodString;
     prompt: z.ZodString;
+    workflow_lane: z.ZodOptional<z.ZodString>;
+    feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 declare const DispatchLanesArgsSchema: z.ZodObject<{
     lanes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         agent: z.ZodString;
         prompt: z.ZodString;
+        workflow_lane: z.ZodOptional<z.ZodString>;
+        feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     common_prompt: z.ZodOptional<z.ZodString>;
     max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -22,6 +29,9 @@ declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
         id: z.ZodString;
         agent: z.ZodString;
         prompt: z.ZodString;
+        workflow_lane: z.ZodOptional<z.ZodString>;
+        feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     common_prompt: z.ZodOptional<z.ZodString>;
     max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -30,7 +40,15 @@ declare const DispatchLanesAsyncArgsSchema: z.ZodObject<{
     batch_id: z.ZodOptional<z.ZodString>;
     mode: z.ZodOptional<z.ZodString>;
     pr_head_sha: z.ZodOptional<z.ZodString>;
+    base_sha: z.ZodOptional<z.ZodString>;
+    base_ref: z.ZodOptional<z.ZodString>;
     scope: z.ZodOptional<z.ZodString>;
+    trigger_evaluation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        trigger_id: z.ZodString;
+        result: z.ZodLiteral<"MATCHED">;
+        evidence: z.ZodString;
+    }, z.core.$strict>>>;
+    feedback_inventory: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 declare const CollectLaneResultsArgsSchema: z.ZodObject<{
     batch_id: z.ZodString;
@@ -213,12 +231,16 @@ export declare const _internals: {
     getSessionOps: () => SessionOps | null;
     getGeneratedAgentNames: () => readonly string[];
     createParallelDispatcher: typeof createParallelDispatcher;
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolveExactMergeBase: typeof resolveExactMergeBase;
     now: () => number;
     sleep: (ms: number) => Promise<void>;
 };
 export declare const _test_exports: {
     applyCommonPrompt: typeof applyCommonPrompt;
     applyExplorerFormatSuffix: typeof applyExplorerFormatSuffix;
+    applyPrWorkflowPromptContract: typeof applyPrWorkflowPromptContract;
+    buildReadOnlyTools: typeof buildReadOnlyTools;
     buildLaneSessionCreateArgs: typeof buildLaneSessionCreateArgs;
     extractAssistantTranscript: typeof extractAssistantTranscript;
     formatError: typeof formatError;
@@ -229,6 +251,9 @@ export declare const _test_exports: {
             id: z.ZodString;
             agent: z.ZodString;
             prompt: z.ZodString;
+            workflow_lane: z.ZodOptional<z.ZodString>;
+            feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         common_prompt: z.ZodOptional<z.ZodString>;
         max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -239,6 +264,9 @@ export declare const _test_exports: {
             id: z.ZodString;
             agent: z.ZodString;
             prompt: z.ZodString;
+            workflow_lane: z.ZodOptional<z.ZodString>;
+            feedback_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            review_item_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         common_prompt: z.ZodOptional<z.ZodString>;
         max_concurrent: z.ZodOptional<z.ZodNumber>;
@@ -247,7 +275,15 @@ export declare const _test_exports: {
         batch_id: z.ZodOptional<z.ZodString>;
         mode: z.ZodOptional<z.ZodString>;
         pr_head_sha: z.ZodOptional<z.ZodString>;
+        base_sha: z.ZodOptional<z.ZodString>;
+        base_ref: z.ZodOptional<z.ZodString>;
         scope: z.ZodOptional<z.ZodString>;
+        trigger_evaluation: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            trigger_id: z.ZodString;
+            result: z.ZodLiteral<"MATCHED">;
+            evidence: z.ZodString;
+        }, z.core.$strict>>>;
+        feedback_inventory: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>;
     DEFAULT_TIMEOUT_MS: number;
     DEFAULT_ASYNC_LAUNCH_TIMEOUT_MS: number;
@@ -280,6 +316,7 @@ declare function extractAssistantTranscript(messages: Array<{
     transcriptIncomplete: boolean;
 };
 declare function nextCollectPollInterval(currentMs: number): number;
+declare function buildReadOnlyTools(): ReadOnlyToolPermissions;
 type ApplyCommonPromptResult = {
     ok: true;
     lanes: DispatchLaneSpec[];
@@ -299,6 +336,13 @@ type ApplyCommonPromptResult = {
  */
 declare function applyCommonPrompt(lanes: DispatchLaneSpec[], commonPrompt: string | undefined): ApplyCommonPromptResult;
 declare function applyExplorerFormatSuffix(lanes: DispatchLaneSpec[]): DispatchLaneSpec[];
+declare function applyPrWorkflowPromptContract(lanes: DispatchLaneSpec[], options: {
+    mode?: string;
+    prHeadSha?: string;
+    revisionDigest?: string;
+    scope?: string;
+    callerFocus?: string;
+}): ApplyCommonPromptResult;
 declare function formatError(error: unknown): string;
 declare function buildLaneSessionCreateArgs(directory: string, lane: DispatchLaneSpec, context: Pick<DispatchLanesExecutionContext, 'sessionID'>): {
     body: {

package/dist/tools/index.d.ts

@@ -86,6 +86,7 @@ export type { ClassifiedFailure, FailureClassification, FailureCluster, } from '
 export { classifyAndCluster, classifyFailure, clusterFailures, } from '../test-impact/failure-classifier.js';
 export type { FlakyTestEntry } from '../test-impact/flaky-detector.js';
 export { computeFlakyScore, detectFlakyTests, isTestQuarantined, } from '../test-impact/flaky-detector.js';
+export { complete_pr_workflow, executeCompletePrWorkflow, } from './complete-pr-workflow';
 export { epic_plan_waves } from './epic-plan-waves';
 export { epic_record_divergence } from './epic-record-divergence';
 export { epic_decide_phase } from './epic-run-phase';
@@ -98,6 +99,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 { 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';
 export { test_impact } from './test-impact';

package/dist/tools/manifest.d.ts

@@ -42,6 +42,8 @@ export declare const TOOL_MANIFEST: {
     evidence_check: () => ToolDefinition;
     check_gate_status: () => ToolDefinition;
     completion_verify: () => ToolDefinition;
+    complete_pr_workflow: () => ToolDefinition;
+    run_pr_feedback_stage_a: () => ToolDefinition;
     submit_council_verdicts: () => ToolDefinition;
     submit_phase_council_verdicts: () => ToolDefinition;
     declare_council_criteria: () => ToolDefinition;

package/dist/tools/run-pr-feedback-stage-a.d.ts

@@ -0,0 +1,69 @@
+import { z } from 'zod';
+import { readGitTextAtRevision, resolveCurrentGitHead, resolveExactMergeBase, resolveGitControlStateDigest, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
+import { runExternalTool } from '../utils/external-tool-runner.js';
+import { createSwarmTool } from './create-tool.js';
+declare const STAGE_A_CATEGORIES: readonly ["build", "typecheck", "lint", "diff-check", "reproduction"];
+type StageACategory = (typeof STAGE_A_CATEGORIES)[number];
+declare const OPTIONAL_STAGE_A_CATEGORIES: readonly ["build", "typecheck", "lint"];
+type OptionalStageACategory = (typeof OPTIONAL_STAGE_A_CATEGORIES)[number];
+interface StageAObligation {
+    id: string;
+    category: OptionalStageACategory;
+    workingDirectory: string;
+    source: string;
+    validatorContract?: {
+        path: string;
+        id: string;
+    };
+}
+interface ContractBaseProvenance {
+    baseRef: string;
+    baseSha: string;
+}
+declare const StageACheckSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        lint: "lint";
+        build: "build";
+        typecheck: "typecheck";
+        "diff-check": "diff-check";
+        reproduction: "reproduction";
+    }>;
+    command: z.ZodArray<z.ZodString>;
+    targets: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    feedback_targets: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        feedback_item_id: z.ZodString;
+        target: z.ZodString;
+        expected_behavior: z.ZodString;
+    }, z.core.$strict>>>;
+    working_directory: z.ZodOptional<z.ZodString>;
+    obligation_id: z.ZodOptional<z.ZodString>;
+    validator_contract: z.ZodOptional<z.ZodObject<{
+        path: z.ZodString;
+        id: z.ZodString;
+    }, z.core.$strict>>;
+    timeout_ms: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>;
+declare function isPlausibleStageACommand(category: StageACategory, command: readonly string[]): boolean;
+type StageACheckInput = z.infer<typeof StageACheckSchema>;
+declare function commandMatchesObligationSource(directory: string, obligation: StageAObligation, check: StageACheckInput, contractValidated: boolean): boolean;
+/** Discover concrete workspace/category/source obligations from bounded local signals. */
+declare function discoverApplicableStageAObligations(directory: string, contractBase?: ContractBaseProvenance): StageAObligation[];
+declare function discoverApplicableStageACategories(directory: string, contractBase?: ContractBaseProvenance): OptionalStageACategory[];
+/** Execute every mandatory repository-generic Stage A category and persist receipts. */
+export declare function executeRunPrFeedbackStageA(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
+export declare const _internals: {
+    runExternalTool: typeof runExternalTool;
+    readGitTextAtRevision: typeof readGitTextAtRevision;
+    resolveExactMergeBase: typeof resolveExactMergeBase;
+    resolveCurrentGitHead: typeof resolveCurrentGitHead;
+    resolveGitControlStateDigest: typeof resolveGitControlStateDigest;
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    isPlausibleStageACommand: typeof isPlausibleStageACommand;
+    discoverApplicableStageACategories: typeof discoverApplicableStageACategories;
+    discoverApplicableStageAObligations: typeof discoverApplicableStageAObligations;
+    commandMatchesObligationSource: typeof commandMatchesObligationSource;
+};
+export declare const run_pr_feedback_stage_a: ReturnType<typeof createSwarmTool>;
+export {};

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

@@ -99,6 +99,14 @@ export declare const TOOL_METADATA: {
         description: string;
         agents: ("critic_oversight" | "architect")[];
     };
+    complete_pr_workflow: {
+        description: string;
+        agents: "architect"[];
+    };
+    run_pr_feedback_stage_a: {
+        description: string;
+        agents: "architect"[];
+    };
     submit_council_verdicts: {
         description: string;
         agents: never[];

package/dist/tools/write-pr-review-trigger-eval.d.ts

@@ -1,67 +1,75 @@
 import { z } from 'zod';
+import { resolveExactMergeBase, resolvePrWorkflowRevisionDigest } from '../background/workspace-snapshot.js';
 import { createSwarmTool } from './create-tool';
+export declare const _internals: {
+    resolvePrWorkflowRevisionDigest: typeof resolvePrWorkflowRevisionDigest;
+    resolveMergeBase: typeof resolveExactMergeBase;
+};
 /** Canonical trigger IDs and display values shared with the PR-review protocol. */
 export declare const PR_REVIEW_TRIGGER_DEFINITIONS: readonly [{
-    readonly id: "architect-prompts";
-    readonly trigger_row: "agents, prompts, templates, prompt interpolation, role text";
-    readonly micro_lane: "Architect prompt integrity";
+    readonly id: "auth-identity-secrets";
+    readonly scope: "universal";
+    readonly trigger_row: "authentication, authorization, identity, sessions, permissions, secrets, cryptography";
+    readonly micro_lane: "Identity and secret boundaries";
 }, {
-    readonly id: "council-orchestration";
-    readonly trigger_row: "council, verdict, quorum, veto, synthesis";
-    readonly micro_lane: "Council orchestration";
+    readonly id: "untrusted-input-boundaries";
+    readonly scope: "universal";
+    readonly trigger_row: "parsing, serialization, queries, templates/rendering, file or network input/output";
+    readonly micro_lane: "Untrusted input and sink analysis";
 }, {
-    readonly id: "guardrail-bypass";
-    readonly trigger_row: "guardrail, gate, delegation, rate limit, approval checks";
-    readonly micro_lane: "Guardrail bypass paths";
+    readonly id: "subprocess-platform";
+    readonly scope: "universal";
+    readonly trigger_row: "subprocesses, shell commands, filesystem operations, OS/runtime-specific code";
+    readonly micro_lane: "Subprocess and platform safety";
 }, {
-    readonly id: "evidence-schema";
-    readonly trigger_row: "schema, evidence, JSONL, migrations, serializers";
-    readonly micro_lane: "Evidence schema drift";
+    readonly id: "concurrency-state";
+    readonly scope: "universal";
+    readonly trigger_row: "queues, caches, retries, transactions, locks, state machines, async coordination";
+    readonly micro_lane: "Concurrency and state transitions";
 }, {
-    readonly id: "knowledge-contract";
-    readonly trigger_row: "knowledge, curator, hive, quarantine, memory";
-    readonly micro_lane: "Knowledge base contract";
+    readonly id: "dependencies-build-release";
+    readonly scope: "universal";
+    readonly trigger_row: "dependency manifests, lockfiles, installers, build scripts, CI, packaging, deployment";
+    readonly micro_lane: "Dependency and delivery integrity";
 }, {
-    readonly id: "phase-transitions";
-    readonly trigger_row: "phase, state, plan, .swarm/state, completion markers";
-    readonly micro_lane: "Phase transition validation";
+    readonly id: "api-schema-migrations";
+    readonly scope: "universal";
+    readonly trigger_row: "public API, wire/schema/config/storage formats, migrations, feature flags";
+    readonly micro_lane: "Compatibility and migration safety";
 }, {
-    readonly id: "model-role-mapping";
-    readonly trigger_row: "model, role, prefix, tool, agent config";
-    readonly micro_lane: "Model-to-role mapping";
-}, {
-    readonly id: "config-ratchet";
-    readonly trigger_row: "config, defaults, ratchet, locks, policy flags";
-    readonly micro_lane: "Config ratchet semantics";
-}, {
-    readonly id: "url-fetch";
-    readonly trigger_row: "url, fetch, http, GitHub PR/issue parsing, package fetch";
-    readonly micro_lane: "URL sanitization and external fetch";
+    readonly id: "test-infrastructure";
+    readonly scope: "universal";
+    readonly trigger_row: "tests, mocks, fixtures, harnesses, coverage, CI matrices";
+    readonly micro_lane: "Test validity and isolation";
 }, {
-    readonly id: "git-safety";
-    readonly trigger_row: "git, branch, checkout, reset, worktree, .git";
-    readonly micro_lane: "Git safety";
+    readonly id: "ui-accessibility-i18n";
+    readonly scope: "universal";
+    readonly trigger_row: "user interfaces, interaction flows, rendering, accessibility, localization";
+    readonly micro_lane: "UI and human-interface quality";
 }, {
-    readonly id: "shell-write";
-    readonly trigger_row: "shell, exec, command parser, file writes, delete/move/copy";
-    readonly micro_lane: "Shell/write authority and path containment";
+    readonly id: "privacy-observability";
+    readonly scope: "universal";
+    readonly trigger_row: "telemetry, logs, analytics, traces, retention, diagnostics";
+    readonly micro_lane: "Privacy and observability safety";
 }, {
-    readonly id: "test-infrastructure";
-    readonly trigger_row: "test, bun, mocks, fixtures, CI matrix";
-    readonly micro_lane: "Test infrastructure";
+    readonly id: "generated-provenance";
+    readonly scope: "universal";
+    readonly trigger_row: "generated, vendored, binary, model-produced, codegen or checked-in build artifacts";
+    readonly micro_lane: "Generated artifact provenance";
 }, {
-    readonly id: "metrics-privacy";
-    readonly trigger_row: "metrics, telemetry, logs, serialized traces";
-    readonly micro_lane: "Metrics and evidence privacy";
+    readonly id: "unclassified-risk";
+    readonly scope: "universal";
+    readonly trigger_row: "any changed artifact or behavior not confidently classified by the rows above";
+    readonly micro_lane: "Unclassified high-risk fallback";
 }];
 declare const WritePrReviewTriggerEvalArgsSchema: z.ZodObject<{
     run_id: z.ZodString;
+    pr_head_sha: z.ZodString;
+    base_sha: z.ZodOptional<z.ZodString>;
+    base_ref: z.ZodOptional<z.ZodString>;
     rows: z.ZodArray<z.ZodObject<{
         trigger_id: z.ZodString;
-        result: z.ZodEnum<{
-            MATCHED: "MATCHED";
-            "NO-MATCH": "NO-MATCH";
-        }>;
+        result: z.ZodLiteral<"MATCHED">;
         evidence: z.ZodString;
         source_batch_id: z.ZodOptional<z.ZodString>;
         source_lane_id: z.ZodOptional<z.ZodString>;
@@ -69,6 +77,8 @@ declare const WritePrReviewTriggerEvalArgsSchema: z.ZodObject<{
 }, z.core.$strict>;
 export type WritePrReviewTriggerEvalArgs = z.infer<typeof WritePrReviewTriggerEvalArgsSchema>;
 /** Validate and atomically persist the complete PR-review trigger evaluation. */
-export declare function executeWritePrReviewTriggerEval(args: unknown, directory: string): Promise<string>;
+export declare function executeWritePrReviewTriggerEval(args: unknown, directory: string, context?: {
+    sessionID?: string;
+}): Promise<string>;
 export declare const write_pr_review_trigger_eval: ReturnType<typeof createSwarmTool>;
 export {};

package/package.json

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

package/dist/cli/index-dqh3zhhc.js

@@ -1,133 +0,0 @@
-// @bun
-// src/background/workspace-snapshot.ts
-import * as child_process from "child_process";
-import { createHash } from "crypto";
-import * as path from "path";
-var GIT_SNAPSHOT_TIMEOUT_MS = 3000;
-var GIT_SNAPSHOT_MAX_BUFFER = 512 * 1024;
-function runGit(directory, args) {
-  const result = _internals.spawnSync("git", ["-C", directory, ...args], {
-    cwd: directory,
-    encoding: "utf-8",
-    timeout: GIT_SNAPSHOT_TIMEOUT_MS,
-    maxBuffer: GIT_SNAPSHOT_MAX_BUFFER,
-    stdio: ["ignore", "pipe", "pipe"]
-  });
-  if (result.error || result.status !== 0)
-    return null;
-  return typeof result.stdout === "string" ? result.stdout.trimEnd() : null;
-}
-function parseNulPaths(output) {
-  return output.split("\x00").filter((entry) => entry.length > 0);
-}
-function parsePorcelainPaths(output) {
-  const entries = parseNulPaths(output);
-  const paths = [];
-  for (let index = 0;index < entries.length; index++) {
-    const entry = entries[index];
-    if (entry.length < 4 || entry[2] !== " ")
-      return null;
-    const status = entry.slice(0, 2);
-    const changedPath = entry.slice(3);
-    if (!changedPath)
-      return null;
-    paths.push(changedPath);
-    if (status.includes("R") || status.includes("C")) {
-      const originalPath = entries[++index];
-      if (!originalPath)
-        return null;
-      paths.push(originalPath);
-    }
-  }
-  return [...new Set(paths)];
-}
-function captureWorkspaceSnapshot(directory, optionsOrScope = null, prHeadShaArg = null) {
-  const scope = typeof optionsOrScope === "object" && optionsOrScope !== null ? optionsOrScope.scope ?? null : optionsOrScope;
-  const prHeadSha = (() => {
-    if (typeof optionsOrScope !== "object" || optionsOrScope === null) {
-      return prHeadShaArg;
-    }
-    if (optionsOrScope.resolveCurrentPrHeadSha) {
-      return runGit(directory, ["rev-parse", "@{upstream}"]);
-    }
-    return optionsOrScope.prHeadSha ?? null;
-  })();
-  const gitHead = runGit(directory, ["rev-parse", "HEAD"]);
-  const porcelain = runGit(directory, [
-    "status",
-    "--porcelain=v1",
-    "-z",
-    "--untracked-files=all"
-  ]);
-  const changedFiles = porcelain === null ? null : parsePorcelainPaths(porcelain);
-  return {
-    directory: path.resolve(directory),
-    gitHead,
-    dirtyHash: porcelain === null ? null : digest(porcelain),
-    changedFiles,
-    prHeadSha,
-    scope
-  };
-}
-function changedFilesSinceSnapshot(directory, baseline) {
-  if (!baseline?.gitHead || baseline.changedFiles == null)
-    return null;
-  if (baseline.changedFiles.length > 0)
-    return null;
-  const current = captureWorkspaceSnapshot(directory);
-  if (!current.gitHead || current.changedFiles == null)
-    return null;
-  const changed = new Set(current.changedFiles);
-  if (baseline.gitHead !== current.gitHead) {
-    const committed = runGit(directory, [
-      "diff",
-      "--name-only",
-      "-z",
-      baseline.gitHead,
-      current.gitHead
-    ]);
-    if (committed === null)
-      return null;
-    for (const changedPath of parseNulPaths(committed))
-      changed.add(changedPath);
-  }
-  return [...changed];
-}
-function workspaceSnapshotMatches(expected, current) {
-  if (!expected)
-    return { ok: true };
-  if (path.resolve(expected.directory) !== path.resolve(current.directory)) {
-    return {
-      ok: false,
-      reason: `directory changed: expected ${expected.directory}, got ${current.directory}`
-    };
-  }
-  const checks = ["gitHead", "dirtyHash", "prHeadSha"];
-  for (const key of checks) {
-    const expectedValue = expected[key];
-    if (expectedValue === null)
-      continue;
-    if (current[key] !== expectedValue) {
-      return {
-        ok: false,
-        reason: `${key} changed: expected ${expectedValue}, got ${current[key] ?? "unknown"}`
-      };
-    }
-  }
-  return { ok: true };
-}
-var compareWorkspaceSnapshot = workspaceSnapshotMatches;
-function compareWorkspaceSnapshots(expected, current) {
-  const result = workspaceSnapshotMatches(expected, current);
-  if (result.ok)
-    return { stale: false };
-  return { stale: true, reason: result.reason };
-}
-function digest(text) {
-  return createHash("sha256").update(text).digest("hex");
-}
-var _internals = {
-  spawnSync: child_process.spawnSync
-};
-
-export { parsePorcelainPaths, captureWorkspaceSnapshot, changedFilesSinceSnapshot, workspaceSnapshotMatches, compareWorkspaceSnapshot, compareWorkspaceSnapshots, digest, _internals };

package/dist/cli/workspace-snapshot-eyf6gd0d.js

@@ -1,22 +0,0 @@
-// @bun
-import {
-  _internals,
-  captureWorkspaceSnapshot,
-  changedFilesSinceSnapshot,
-  compareWorkspaceSnapshot,
-  compareWorkspaceSnapshots,
-  digest,
-  parsePorcelainPaths,
-  workspaceSnapshotMatches
-} from "./index-dqh3zhhc.js";
-import"./index-a76rekgs.js";
-export {
-  workspaceSnapshotMatches,
-  parsePorcelainPaths,
-  digest,
-  compareWorkspaceSnapshots,
-  compareWorkspaceSnapshot,
-  changedFilesSinceSnapshot,
-  captureWorkspaceSnapshot,
-  _internals
-};