@wrongstack/runtime 0.297.0 → 0.298.0

package/dist/clipboard.js

@@ -6,6 +6,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import { buildChildEnv } from "@wrongstack/core/utils";
 var MAX_IMAGE_BYTES = 10 * 1024 * 1024;
+var MAX_TEXT_BYTES = 4 * 1024 * 1024;
 async function readClipboardImage() {
   const platform = process.platform;
   if (platform === "win32") return readWindows();
@@ -70,10 +71,14 @@ async function readWindows() {
     `$img.Save('${tmp.replace(/\\/g, "\\\\")}', [System.Drawing.Imaging.ImageFormat]::Png)`,
     'Write-Output "OK"'
   ].join("; ");
-  const out = await runCmd("powershell", ["-NoProfile", "-Command", ps]);
-  if (!out || out.trim() === "NO_IMAGE") return null;
-  if (!out.includes("OK")) return null;
-  return readPngFile(tmp);
+  try {
+    const out = await runCmd("powershell", ["-NoProfile", "-Command", ps]);
+    if (!out || out.trim() === "NO_IMAGE") return null;
+    if (!out.includes("OK")) return null;
+    return await readPngFile(tmp);
+  } finally {
+    await fs.unlink(tmp).catch(() => void 0);
+  }
 }
 async function readDarwin() {
   const tmp = path.join(os.tmpdir(), `wstack-clip-${randomUUID()}.png`);
@@ -90,9 +95,13 @@ async function readDarwin() {
     "end try",
     'return "OK"'
   ].join("\n");
-  const out = await runCmd("osascript", ["-e", script]);
-  if (out?.trim() !== "OK") return null;
-  return readPngFile(tmp);
+  try {
+    const out = await runCmd("osascript", ["-e", script]);
+    if (out?.trim() !== "OK") return null;
+    return await readPngFile(tmp);
+  } finally {
+    await fs.unlink(tmp).catch(() => void 0);
+  }
 }
 async function readLinux() {
   const tmp = path.join(os.tmpdir(), `wstack-clip-${randomUUID()}.png`);
@@ -137,6 +146,7 @@ function runCmd(cmd, args) {
       windowsHide: true
     });
     let out = "";
+    let outBytes = 0;
     let settled = false;
     let killedByTimeout = false;
     const finish = (value) => {
@@ -144,6 +154,7 @@ function runCmd(cmd, args) {
       settled = true;
       clearTimeout(timer);
       clearTimeout(killCap);
+      child.stdout.off("data", onStdoutData);
       resolve(value);
     };
     const timer = setTimeout(() => {
@@ -151,9 +162,18 @@ function runCmd(cmd, args) {
       child.kill("SIGTERM");
     }, CLIPBOARD_CMD_TIMEOUT_MS);
     const killCap = setTimeout(() => finish(null), CLIPBOARD_CMD_TIMEOUT_MS + 2e3);
-    child.stdout.on("data", (c) => {
-      out += String(c);
-    });
+    const onStdoutData = (c) => {
+      const chunk = Buffer.isBuffer(c) ? c : Buffer.from(c);
+      outBytes += chunk.byteLength;
+      if (outBytes > MAX_TEXT_BYTES) {
+        out = "";
+        child.kill("SIGTERM");
+        finish(null);
+        return;
+      }
+      out += chunk.toString("utf8");
+    };
+    child.stdout.on("data", onStdoutData);
     child.on("error", () => finish(null));
     child.on("exit", (code) => {
       if (killedByTimeout) return finish(null);
@@ -200,6 +220,7 @@ function runCmdToFile(cmd, args, outPath) {
       windowsHide: true
     });
     const chunks = [];
+    let outputBytes = 0;
     let settled = false;
     let killedByTimeout = false;
     const finish = (value) => {
@@ -207,6 +228,7 @@ function runCmdToFile(cmd, args, outPath) {
       settled = true;
       clearTimeout(timer);
       clearTimeout(killCap);
+      child.stdout.off("data", onStdoutData);
       resolve(value);
     };
     const timer = setTimeout(() => {
@@ -214,7 +236,17 @@ function runCmdToFile(cmd, args, outPath) {
       child.kill("SIGTERM");
     }, CLIPBOARD_CMD_TIMEOUT_MS);
     const killCap = setTimeout(() => finish(false), CLIPBOARD_CMD_TIMEOUT_MS + 2e3);
-    child.stdout.on("data", (c) => chunks.push(c));
+    const onStdoutData = (c) => {
+      outputBytes += c.byteLength;
+      if (outputBytes > MAX_IMAGE_BYTES) {
+        chunks.length = 0;
+        child.kill("SIGTERM");
+        finish(false);
+        return;
+      }
+      chunks.push(c);
+    };
+    child.stdout.on("data", onStdoutData);
     child.on("error", () => finish(false));
     child.on("exit", async (code) => {
       if (killedByTimeout) return finish(false);

package/dist/fleet/light-subagent-factory.d.ts

@@ -34,6 +34,11 @@ export interface LightSubagentFactoryDeps {
      * `host.opts.statusTracker` thread in the CLI factory.
      */
     statusTracker?: ProviderModelStatusTracker | undefined;
+    /**
+     * Optional trusted control-plane hook for the isolated tool pipeline.
+     * The host owns this hook; it is not exposed through the agent's tools.
+     */
+    installToolBoundary?: ((pipelines: import('@wrongstack/core/agent').AgentPipelines) => void) | undefined;
 }
 /**
  * Retrieve and abort a light subagent's AbortController (stored in ctx.meta

package/dist/governance-bootstrap.d.ts

@@ -0,0 +1,94 @@
+import type { ExistingGovernanceAdminCredential, GovernanceCompatibilityCleanup, GovernanceCompatibilityFallback, GovernanceCompatibilityFallbackCode, GovernanceCompatibilityRuntime, GovernanceCompatibilityRuntimeSnapshot, GovernanceDaemonOperatorStatus, GovernanceModelCapability, GovernanceModelSession, GovernanceObservationCategory, PrepareGovernanceCompatibilityOptions, PrepareGovernanceCompatibilityResult } from '@wrongstack/governance';
+import { connectGovernanceProjectClient, readGovernanceDaemonAttachmentBroker } from '@wrongstack/governance';
+export type { GovernanceEvidenceCandidate, GovernanceEvidenceCandidateMissingBinding, GovernanceEvidenceTraceSnapshot, GovernanceToolOutcomeMetadata, } from '@wrongstack/governance';
+export { createGovernanceEvidenceCandidate, GOVERNANCE_EVIDENCE_CANDIDATE_SCHEMA_VERSION, } from '@wrongstack/governance';
+export interface BootstrapGovernanceRuntimeOptions {
+    readonly projectRoot: string;
+    readonly projectId: string;
+    readonly adminClientId: string;
+    readonly modelClientId: string;
+    readonly modelCapabilities: readonly GovernanceModelCapability[];
+    readonly adminTtlMs?: number | undefined;
+    readonly modelTtlMs?: number | undefined;
+    readonly timeoutMs?: number | undefined;
+    readonly existingAdmin?: ExistingGovernanceAdminCredential | undefined;
+}
+export interface GovernanceRuntimeBootstrapSnapshot {
+    readonly mode: 'governed';
+    readonly source: 'attached' | 'launched';
+    readonly daemon: GovernanceCompatibilityRuntimeSnapshot['daemon'];
+    readonly model: GovernanceCompatibilityRuntimeSnapshot['model'];
+}
+export interface GovernanceRuntimeBootstrapCloseResult {
+    readonly ok: boolean;
+    readonly action: 'detach' | 'shutdown';
+    readonly message: string;
+}
+export type GovernanceDaemonOperatorStatusReadResult = {
+    readonly available: true;
+    readonly status: GovernanceDaemonOperatorStatus;
+} | {
+    readonly available: false;
+    readonly code: 'broker_missing' | 'broker_invalid' | 'connection_failed' | 'request_rejected' | 'unexpected_response';
+    readonly message: string;
+};
+export interface GovernanceDaemonOperatorStatusReaderDependencies {
+    readonly readBroker: typeof readGovernanceDaemonAttachmentBroker;
+    readonly connectClient: typeof connectGovernanceProjectClient;
+}
+export declare function readGovernanceDaemonOperatorStatus(projectRoot: string): Promise<GovernanceDaemonOperatorStatusReadResult>;
+/** Internal source-test seam. Package consumers use readGovernanceDaemonOperatorStatus. */
+export declare function readGovernanceDaemonOperatorStatusWithDependencies(projectRoot: string, dependencies: GovernanceDaemonOperatorStatusReaderDependencies): Promise<GovernanceDaemonOperatorStatusReadResult>;
+export interface GovernanceRuntimeObservationInput {
+    readonly taskId: string | null;
+    readonly category: GovernanceObservationCategory;
+    readonly observedAt: string;
+    readonly payload: Readonly<Record<string, unknown>>;
+}
+export type GovernanceRuntimeWorkspaceSnapshotResult = {
+    readonly recorded: true;
+    readonly snapshot: import('@wrongstack/governance').WorkspaceSnapshotFenceDescriptor;
+} | {
+    readonly recorded: false;
+    readonly code: 'closed' | 'request_failed' | 'request_rejected' | 'unexpected_response' | 'workspace_snapshot_invalid';
+    readonly message: string;
+};
+export type GovernanceRuntimeObservationResult = {
+    readonly recorded: true;
+    readonly observationId: string;
+    readonly idempotentReplay: boolean;
+    readonly sequence: number;
+} | {
+    readonly recorded: false;
+    readonly observationId?: string | undefined;
+    readonly code: 'backpressure' | 'closed' | 'request_failed' | 'request_rejected' | 'unexpected_response';
+    readonly message: string;
+};
+export declare const MAX_PENDING_GOVERNANCE_OBSERVATIONS = 256;
+declare const GOVERNANCE_RUNTIME_BOOTSTRAP_HANDLE_CONSTRUCTION: unique symbol;
+export declare class GovernanceRuntimeBootstrapHandle {
+    #private;
+    readonly model: GovernanceModelSession;
+    constructor(construction: typeof GOVERNANCE_RUNTIME_BOOTSTRAP_HANDLE_CONSTRUCTION, runtime: GovernanceCompatibilityRuntime);
+    snapshot(): GovernanceRuntimeBootstrapSnapshot;
+    observe(input: GovernanceRuntimeObservationInput): Promise<GovernanceRuntimeObservationResult>;
+    recordWorkspaceSnapshot(manifestHash: string): Promise<GovernanceRuntimeWorkspaceSnapshotResult>;
+    close(): Promise<GovernanceRuntimeBootstrapCloseResult>;
+    private closeOnce;
+    private recordObservation;
+}
+export type GovernanceRuntimeBootstrapResult = {
+    readonly mode: 'governed';
+    readonly handle: GovernanceRuntimeBootstrapHandle;
+} | {
+    readonly mode: 'legacy';
+    readonly code: 'bootstrap_failed' | GovernanceCompatibilityFallbackCode;
+    readonly phase: 'bootstrap' | GovernanceCompatibilityFallback['phase'];
+    readonly message: string;
+    readonly cleanup: GovernanceCompatibilityCleanup;
+};
+type GovernanceCompatibilityFactory = (options: PrepareGovernanceCompatibilityOptions) => Promise<PrepareGovernanceCompatibilityResult>;
+export declare function bootstrapGovernanceRuntime(options: BootstrapGovernanceRuntimeOptions): Promise<GovernanceRuntimeBootstrapResult>;
+/** Internal source-test seam. Package consumers use bootstrapGovernanceRuntime. */
+export declare function bootstrapGovernanceRuntimeWithFactory(options: BootstrapGovernanceRuntimeOptions, prepare: GovernanceCompatibilityFactory): Promise<GovernanceRuntimeBootstrapResult>;
+//# sourceMappingURL=governance-bootstrap.d.ts.map

package/dist/governance-bootstrap.js

@@ -0,0 +1,330 @@
+// src/governance-bootstrap.ts
+import { randomUUID } from "node:crypto";
+import {
+  connectGovernanceProjectClient,
+  GOVERNANCE_SERVICE_PROTOCOL_VERSION,
+  prepareGovernanceCompatibilityRuntime,
+  projectGovernanceDaemonOperatorStatus,
+  readGovernanceDaemonAttachmentBroker
+} from "@wrongstack/governance";
+
+// src/governance-sanitize.ts
+import { sanitizeGovernanceMessage } from "@wrongstack/governance";
+
+// src/governance-bootstrap.ts
+import {
+  createGovernanceEvidenceCandidate,
+  GOVERNANCE_EVIDENCE_CANDIDATE_SCHEMA_VERSION
+} from "@wrongstack/governance";
+var GOVERNANCE_DAEMON_OPERATOR_STATUS_DEPENDENCIES = {
+  readBroker: readGovernanceDaemonAttachmentBroker,
+  connectClient: connectGovernanceProjectClient
+};
+function readGovernanceDaemonOperatorStatus(projectRoot) {
+  return readGovernanceDaemonOperatorStatusWithDependencies(
+    projectRoot,
+    GOVERNANCE_DAEMON_OPERATOR_STATUS_DEPENDENCIES
+  );
+}
+async function readGovernanceDaemonOperatorStatusWithDependencies(projectRoot, dependencies) {
+  let broker;
+  try {
+    broker = await dependencies.readBroker(projectRoot);
+  } catch (error) {
+    return Object.freeze({
+      available: false,
+      code: "broker_invalid",
+      message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error))
+    });
+  }
+  if (broker.kind === "missing") {
+    return Object.freeze({
+      available: false,
+      code: "broker_missing",
+      message: "Governance attachment broker is not published for this project."
+    });
+  }
+  if (broker.kind === "invalid") {
+    return Object.freeze({
+      available: false,
+      code: "broker_invalid",
+      message: sanitizeGovernanceMessage(broker.reason)
+    });
+  }
+  let connection;
+  try {
+    connection = await dependencies.connectClient({
+      projectRoot,
+      projectId: broker.broker.projectId,
+      credential: broker.broker.credential
+    });
+  } catch (error) {
+    return Object.freeze({
+      available: false,
+      code: "connection_failed",
+      message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error))
+    });
+  }
+  if (!connection.connected) {
+    return Object.freeze({
+      available: false,
+      code: "connection_failed",
+      message: sanitizeGovernanceMessage(connection.message)
+    });
+  }
+  let response;
+  try {
+    response = await connection.client.request({
+      protocolVersion: GOVERNANCE_SERVICE_PROTOCOL_VERSION,
+      requestId: `operator-daemon-status-${randomUUID()}`,
+      type: "read_daemon_status"
+    });
+  } catch (error) {
+    return Object.freeze({
+      available: false,
+      code: "connection_failed",
+      message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error))
+    });
+  }
+  if (!response.ok) {
+    return Object.freeze({
+      available: false,
+      code: "request_rejected",
+      message: sanitizeGovernanceMessage(response.error.message)
+    });
+  }
+  if (response.result.type !== "daemon_status") {
+    return Object.freeze({
+      available: false,
+      code: "unexpected_response",
+      message: "Governance daemon returned an unexpected status response."
+    });
+  }
+  return Object.freeze({
+    available: true,
+    status: projectGovernanceDaemonOperatorStatus(response.result)
+  });
+}
+var MAX_PENDING_GOVERNANCE_OBSERVATIONS = 256;
+var GOVERNANCE_RUNTIME_BOOTSTRAP_HANDLE_CONSTRUCTION = /* @__PURE__ */ Symbol(
+  "governance-runtime-bootstrap-handle-construction"
+);
+var GovernanceRuntimeBootstrapHandle = class {
+  model;
+  #runtime;
+  #snapshot;
+  #pendingObservations = /* @__PURE__ */ new Set();
+  #acceptingRuntimeWrites = true;
+  #closePromise;
+  constructor(construction, runtime) {
+    if (construction !== GOVERNANCE_RUNTIME_BOOTSTRAP_HANDLE_CONSTRUCTION) {
+      throw new Error("Governance runtime handles must be created through the bootstrap adapter.");
+    }
+    this.#runtime = runtime;
+    this.model = runtime.model;
+    const snapshot = runtime.snapshot();
+    this.#snapshot = Object.freeze({
+      mode: "governed",
+      source: snapshot.source,
+      daemon: snapshot.daemon,
+      model: snapshot.model
+    });
+  }
+  snapshot() {
+    return this.#snapshot;
+  }
+  observe(input) {
+    if (!this.#acceptingRuntimeWrites) {
+      return Promise.resolve(
+        Object.freeze({
+          recorded: false,
+          code: "closed",
+          message: "Governance runtime is closing and no longer accepts observations."
+        })
+      );
+    }
+    if (this.#pendingObservations.size >= MAX_PENDING_GOVERNANCE_OBSERVATIONS) {
+      return Promise.resolve(
+        Object.freeze({
+          recorded: false,
+          code: "backpressure",
+          message: "Governance observation queue reached its bounded capacity."
+        })
+      );
+    }
+    const pending = this.recordObservation(input);
+    this.#pendingObservations.add(pending);
+    void pending.finally(() => this.#pendingObservations.delete(pending));
+    return pending;
+  }
+  async recordWorkspaceSnapshot(manifestHash) {
+    if (!this.#acceptingRuntimeWrites) {
+      return Object.freeze({
+        recorded: false,
+        code: "closed",
+        message: "Governance runtime is closing and no longer accepts workspace snapshots."
+      });
+    }
+    try {
+      const response = await this.#runtime.recordWorkspaceSnapshot(manifestHash);
+      if (!response.ok) {
+        return Object.freeze({
+          recorded: false,
+          code: "request_rejected",
+          message: sanitizeGovernanceMessage(response.error.message)
+        });
+      }
+      if (response.result.type !== "workspace_snapshot_recorded") {
+        return Object.freeze({
+          recorded: false,
+          code: "unexpected_response",
+          message: "Governance workspace snapshot returned an unexpected response."
+        });
+      }
+      if (!response.result.result.recorded) {
+        return Object.freeze({
+          recorded: false,
+          code: response.result.result.code,
+          message: sanitizeGovernanceMessage(response.result.result.message)
+        });
+      }
+      return Object.freeze({
+        recorded: true,
+        snapshot: response.result.result.snapshot
+      });
+    } catch (error) {
+      return Object.freeze({
+        recorded: false,
+        code: "request_failed",
+        message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error))
+      });
+    }
+  }
+  close() {
+    if (this.#closePromise) return this.#closePromise;
+    this.#closePromise = this.closeOnce();
+    return this.#closePromise;
+  }
+  async closeOnce() {
+    this.#acceptingRuntimeWrites = false;
+    await Promise.allSettled([...this.#pendingObservations]);
+    const action = this.#snapshot.source === "launched" ? "shutdown" : "detach";
+    try {
+      const response = action === "shutdown" ? await this.#runtime.shutdownDaemon("WrongStack runtime session ended") : await this.#runtime.close();
+      if (response === null) {
+        return Object.freeze({ ok: true, action, message: "Governance runtime already closed." });
+      }
+      if (!response.ok) {
+        return Object.freeze({
+          ok: false,
+          action,
+          message: sanitizeGovernanceMessage(response.error.message)
+        });
+      }
+      const completed = action === "shutdown" ? response.result.type === "daemon_shutdown_accepted" : response.result.type === "capability_grant_revoked" || response.result.type === "runtime_attachment_released";
+      return Object.freeze({
+        ok: completed,
+        action,
+        message: completed ? `Governance runtime ${action} completed.` : `Governance runtime ${action} returned an unexpected response.`
+      });
+    } catch (error) {
+      return Object.freeze({
+        ok: false,
+        action,
+        message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error))
+      });
+    }
+  }
+  async recordObservation(input) {
+    const observationId = randomUUID();
+    try {
+      const response = await this.model.request({
+        protocolVersion: GOVERNANCE_SERVICE_PROTOCOL_VERSION,
+        requestId: `observe-${observationId}`,
+        type: "record_observation",
+        observation: {
+          observationId,
+          projectId: this.#snapshot.model.projectId,
+          taskId: input.taskId,
+          source: this.#snapshot.model.clientId,
+          category: input.category,
+          observedAt: input.observedAt,
+          payload: input.payload
+        }
+      });
+      if (!response.ok) {
+        return Object.freeze({
+          recorded: false,
+          observationId,
+          code: "request_rejected",
+          message: sanitizeGovernanceMessage(response.error.message)
+        });
+      }
+      if (response.result.type !== "observation_result") {
+        return Object.freeze({
+          recorded: false,
+          observationId,
+          code: "unexpected_response",
+          message: "Governance observation returned an unexpected response."
+        });
+      }
+      if (!response.result.result.handled) {
+        return Object.freeze({
+          recorded: false,
+          observationId,
+          code: "request_rejected",
+          message: sanitizeGovernanceMessage(response.result.result.message)
+        });
+      }
+      return Object.freeze({
+        recorded: true,
+        observationId,
+        idempotentReplay: response.result.result.idempotentReplay,
+        sequence: response.result.result.observation.sequence
+      });
+    } catch (error) {
+      return Object.freeze({
+        recorded: false,
+        observationId,
+        code: "request_failed",
+        message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error))
+      });
+    }
+  }
+};
+function bootstrapGovernanceRuntime(options) {
+  return bootstrapGovernanceRuntimeWithFactory(options, prepareGovernanceCompatibilityRuntime);
+}
+async function bootstrapGovernanceRuntimeWithFactory(options, prepare) {
+  let prepared;
+  try {
+    prepared = await prepare(options);
+  } catch (error) {
+    return Object.freeze({
+      mode: "legacy",
+      code: "bootstrap_failed",
+      phase: "bootstrap",
+      message: sanitizeGovernanceMessage(error instanceof Error ? error.message : String(error)),
+      cleanup: "unavailable"
+    });
+  }
+  if (prepared.mode === "legacy") return prepared;
+  return Object.freeze({
+    mode: "governed",
+    handle: new GovernanceRuntimeBootstrapHandle(
+      GOVERNANCE_RUNTIME_BOOTSTRAP_HANDLE_CONSTRUCTION,
+      prepared.runtime
+    )
+  });
+}
+export {
+  GOVERNANCE_EVIDENCE_CANDIDATE_SCHEMA_VERSION,
+  GovernanceRuntimeBootstrapHandle,
+  MAX_PENDING_GOVERNANCE_OBSERVATIONS,
+  bootstrapGovernanceRuntime,
+  bootstrapGovernanceRuntimeWithFactory,
+  createGovernanceEvidenceCandidate,
+  readGovernanceDaemonOperatorStatus,
+  readGovernanceDaemonOperatorStatusWithDependencies
+};
+//# sourceMappingURL=governance-bootstrap.js.map

package/dist/governance-mutation-snapshot-bridge.d.ts

@@ -0,0 +1,21 @@
+import type { AgentPipelines } from '@wrongstack/core/agent';
+import type { EventBus } from '@wrongstack/core/kernel';
+import type { WorkspaceCheckpointRef } from '@wrongstack/core/types';
+import type { GovernanceRuntimeWorkspaceSnapshotResult } from './governance-bootstrap.js';
+export declare const MAX_PENDING_GOVERNANCE_MUTATION_SNAPSHOTS = 64;
+export interface GovernanceWorkspaceSnapshotSink {
+    recordWorkspaceSnapshot(manifestHash: string): Promise<GovernanceRuntimeWorkspaceSnapshotResult>;
+}
+export interface GovernanceMutationSnapshotBridge {
+    installToolBoundary(pipelines: AgentPipelines): void;
+    close(): Promise<void>;
+}
+export declare function createGovernanceMutationSnapshotBridge(input: {
+    readonly events: EventBus;
+    readonly sink: GovernanceWorkspaceSnapshotSink;
+    readonly captureWorkspaceCheckpoint: () => Promise<WorkspaceCheckpointRef | undefined>;
+    readonly logger: {
+        warn(message: string, context?: unknown): void;
+    };
+}): GovernanceMutationSnapshotBridge;
+//# sourceMappingURL=governance-mutation-snapshot-bridge.d.ts.map

package/dist/governance-mutation-snapshot-bridge.js

@@ -0,0 +1,108 @@
+// src/governance-mutation-snapshot-bridge.ts
+var MAX_PENDING_GOVERNANCE_MUTATION_SNAPSHOTS = 64;
+function createGovernanceMutationSnapshotBridge(input) {
+  let closed = false;
+  let warned = false;
+  let pending = 0;
+  let tail = Promise.resolve();
+  const installedPipelines = /* @__PURE__ */ new WeakSet();
+  const awaitedCompletions = /* @__PURE__ */ new Set();
+  const awaitedCompletionOrder = [];
+  const warnOnce = (message, context) => {
+    if (warned) return;
+    warned = true;
+    if (context === void 0) input.logger.warn(message);
+    else input.logger.warn(message, context);
+  };
+  const completionKey = (sessionId, toolCallId) => sessionId === void 0 || toolCallId === void 0 ? void 0 : `${sessionId}\0${toolCallId}`;
+  const rememberAwaitedCompletion = (key) => {
+    if (key === void 0 || awaitedCompletions.has(key)) return;
+    awaitedCompletions.add(key);
+    awaitedCompletionOrder.push(key);
+    if (awaitedCompletionOrder.length > 512) {
+      const oldest = awaitedCompletionOrder.shift();
+      if (oldest !== void 0) awaitedCompletions.delete(oldest);
+    }
+  };
+  const enqueueSnapshot = async (completion, awaitedBoundary = false) => {
+    if (closed || !completion.ok || !completion.mutating) return;
+    while (pending >= MAX_PENDING_GOVERNANCE_MUTATION_SNAPSHOTS) {
+      if (awaitedBoundary) {
+        await tail;
+        if (closed) return;
+        continue;
+      }
+      warnOnce("governance: mutation snapshot queue reached bounded capacity", {
+        capacity: MAX_PENDING_GOVERNANCE_MUTATION_SNAPSHOTS
+      });
+      return;
+    }
+    pending += 1;
+    const settled = tail.then(async () => {
+      const checkpoint = await input.captureWorkspaceCheckpoint();
+      if (!checkpoint || !/^[a-f0-9]{64}$/u.test(checkpoint.manifestHash)) {
+        warnOnce("governance: failed to capture a valid post-mutation workspace identity");
+        return;
+      }
+      const result = await input.sink.recordWorkspaceSnapshot(checkpoint.manifestHash);
+      if (!result.recorded) {
+        warnOnce("governance: post-mutation workspace snapshot was not recorded", {
+          code: result.code,
+          message: result.message
+        });
+      }
+    }).catch((error) => {
+      warnOnce("governance: post-mutation workspace snapshot failed open", {
+        message: error instanceof Error ? error.message : String(error)
+      });
+    }).finally(() => {
+      pending -= 1;
+    });
+    tail = settled;
+    await settled;
+  };
+  const dispose = input.events.on("tool.executed", (event) => {
+    const key = completionKey(event.sessionId, event.id);
+    if (key !== void 0 && awaitedCompletions.delete(key)) return;
+    void enqueueSnapshot({ ok: event.ok, mutating: event.mutating === true });
+  });
+  return Object.freeze({
+    installToolBoundary: (pipelines) => {
+      if (installedPipelines.has(pipelines)) return;
+      installedPipelines.add(pipelines);
+      pipelines.toolCall.prepend({
+        name: "GovernanceWorkspaceSnapshotFence",
+        owner: "governance-compatibility",
+        handler: async (payload, next) => {
+          let completed = payload;
+          try {
+            completed = await next(payload);
+            return completed;
+          } finally {
+            const key = completionKey(completed.ctx.session.id, completed.toolUse.id);
+            await enqueueSnapshot(
+              {
+                ok: !completed.result.is_error,
+                mutating: completed.tool?.mutating === true
+              },
+              true
+            );
+            rememberAwaitedCompletion(key);
+          }
+        }
+      });
+    },
+    close: async () => {
+      if (!closed) {
+        closed = true;
+        dispose();
+      }
+      await tail;
+    }
+  });
+}
+export {
+  MAX_PENDING_GOVERNANCE_MUTATION_SNAPSHOTS,
+  createGovernanceMutationSnapshotBridge
+};
+//# sourceMappingURL=governance-mutation-snapshot-bridge.js.map