@agentxm/workspace-operations 0.28.11 → 0.28.13

package/dist/src/testing.js

@@ -7,6 +7,29 @@
  * @experimental This API is unstable and may change without notice.
  * @packageDocumentation
  */
+import * as Layer from "effect/Layer";
+import { ConfiguredAgentOutcomesProvider } from "@agentxm/workspace-state";
+import { ConfiguredAgentOutcomesProviderTest } from "@agentxm/workspace-state/testing";
+import { FootprintRecorder, makeFootprintRecorder } from "@agentxm/workspace-transactions";
+import { OperationJournal, makeOperationJournal } from "./plan/operation-journal.js";
+/**
+ * An empty journal for one test invocation, standing in for the
+ * per-invocation journal the CLI's operation lifecycle creates around every
+ * command. Provide it wherever a test drives a plan directly instead of
+ * through that lifecycle. A test that asserts on what was recorded should
+ * build the service itself with `makeOperationJournal` and keep the ref.
+ */
+export const OperationJournalTest = Layer.effect(OperationJournal, makeOperationJournal);
+/** A fresh footprint recorder for one test invocation. */
+export const FootprintRecorderTest = Layer.effect(FootprintRecorder, makeFootprintRecorder);
+/**
+ * Every per-invocation service `resolveExecutionCandidate` acquires that the CLI's
+ * operation lifecycle opens around a command: the journal, the footprint
+ * recorder, and a configured-agent outcome provider with no per-type
+ * refinement. A test that drives a plan directly needs all of them, so this
+ * is the layer to reach for rather than assembling the three by hand.
+ */
+export const PlanInvocationTest = Layer.mergeAll(OperationJournalTest, FootprintRecorderTest, ConfiguredAgentOutcomesProviderTest);
 export { ResolvePlanInteractionTest, } from "./plan/resolve-plan-interaction.js";
 export { interactiveOnlyPlanExecution, preapprovedPlanExecution, promptablePlanExecution, } from "./plan/plan-execution-fixtures.js";
 //# sourceMappingURL=testing.js.map

package/package.json

@@ -4,17 +4,18 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-model": "^0.28.11",
-    "@agentxm/registry-protocol": "^0.28.11",
-    "@agentxm/workspace-state": "^0.28.11",
-    "effect": "4.0.0-rc.112",
-    "proper-lockfile": "^4.1.2"
-  },
-  "description": "AXM workspace operations kernel: plans, execution candidates, operation resolutions, and workspace transactions for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
+    "@agentxm/extension-model": "^0.28.13",
+    "@agentxm/extension-resolution": "^0.28.13",
+    "@agentxm/registry-protocol": "^0.28.13",
+    "@agentxm/workspace-state": "^0.28.13",
+    "@agentxm/workspace-transactions": "^0.28.13",
+    "effect": "4.0.0-rc.112"
+  },
+  "description": "AXM workspace operations: plans, execution candidates, closure execution, and operation resolutions for the axm CLI. Unstable and unsupported — use the axm.sh CLI.",
   "devDependencies": {
+    "@agentxm/specification-metadata": "^0.28.13",
     "@effect/platform-node": "4.0.0-rc.112",
     "@effect/vitest": "4.0.0-rc.112",
-    "@types/proper-lockfile": "^4.1.4",
     "@typescript/native": "npm:typescript@^7.0.2",
     "typescript": "npm:@typescript/typescript6@^6.0.2",
     "vitest": "^4.1.10",
@@ -29,11 +30,6 @@
       "default": "./dist/src/index.js",
       "types": "./dist/src/index.d.ts"
     },
-    "./live": {
-      "axm-source": "./src/live.ts",
-      "default": "./dist/src/live.js",
-      "types": "./dist/src/live.d.ts"
-    },
     "./testing": {
       "axm-source": "./src/testing.ts",
       "default": "./dist/src/testing.js",
@@ -54,11 +50,11 @@
     "access": "public"
   },
   "repository": {
-    "directory": "packages/workspace-operations",
+    "directory": "packages/core/workspace-operations",
     "type": "git",
     "url": "https://github.com/agentxm/axm.git"
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.11"
-}
+  "version": "0.28.13"
+}

package/dist/src/live.d.ts

@@ -1,13 +0,0 @@
-/**
- * @agentxm/workspace-operations environment-backed composition.
- *
- * The composed workspace layer every entry point provides. Only application
- * composition roots import this module; feature logic keeps
- * `WorkspaceMutations` in its Effect environment.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-export { layer, loadWorkspace, makeWorkspaceTransactionCapabilities, } from "./operations/load-workspace.js";
-export type { WorkspaceLayerOptions } from "@agentxm/workspace-state";
-//# sourceMappingURL=live.d.ts.map

package/dist/src/live.js

@@ -1,12 +0,0 @@
-/**
- * @agentxm/workspace-operations environment-backed composition.
- *
- * The composed workspace layer every entry point provides. Only application
- * composition roots import this module; feature logic keeps
- * `WorkspaceMutations` in its Effect environment.
- *
- * @experimental This API is unstable and may change without notice.
- * @packageDocumentation
- */
-export { layer, loadWorkspace, makeWorkspaceTransactionCapabilities, } from "./operations/load-workspace.js";
-//# sourceMappingURL=live.js.map

package/dist/src/operations/load-workspace.d.ts

@@ -1,43 +0,0 @@
-/**
- * Live workspace composition: the one seam that needs both the workspace
- * state facade and the operations-side transaction machinery. Supplies the
- * transaction capabilities to `makeWorkspaceMutations` and publishes the
- * `loadWorkspace` effect and `layer` every entry point composes.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import { WorkspaceMutations, type MakeWorkspaceTransactionCapabilities, type WorkspaceLayerOptions, type WorkspaceMutationsError, type WorkspaceMutationsService } from "@agentxm/workspace-state";
-/**
- * The live transaction capabilities: the runner claims the shared settings
- * and lockfile targets by default, and both members eliminate FileSystem and
- * Path so the facade's methods stay `R = never` for callers.
- */
-export declare const makeWorkspaceTransactionCapabilities: MakeWorkspaceTransactionCapabilities;
-/**
- * Create workspace mutations effect.
- *
- * Loads an existing workspace from disk.
- *
- * The workspace must already be initialized. Missing or invalid settings and
- * invalid or unsupported lockfiles fail fast with a typed workspace error.
- *
- * @param options - WorkspaceMutations layer options
- * @returns Effect yielding WorkspaceMutationsService
- */
-export declare const loadWorkspace: (options: WorkspaceLayerOptions) => Effect.Effect<WorkspaceMutationsService, WorkspaceMutationsError, FileSystem.FileSystem | Path.Path>;
-/**
- * Create a layer that loads workspace read model from disk.
- *
- * The workspace must already be initialized.
- *
- * @param options - WorkspaceMutations layer options
- * @returns Layer providing WorkspaceMutations
- *
- * @experimental This API is unstable and may change without notice.
- */
-export declare const layer: (options: WorkspaceLayerOptions) => Layer.Layer<WorkspaceMutations, WorkspaceMutationsError, Path.Path | FileSystem.FileSystem>;
-//# sourceMappingURL=load-workspace.d.ts.map

package/dist/src/operations/load-workspace.js

@@ -1,77 +0,0 @@
-/**
- * Live workspace composition: the one seam that needs both the workspace
- * state facade and the operations-side transaction machinery. Supplies the
- * transaction capabilities to `makeWorkspaceMutations` and publishes the
- * `loadWorkspace` effect and `layer` every entry point composes.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Layer from "effect/Layer";
-import * as Path from "effect/Path";
-import * as Semaphore from "effect/Semaphore";
-import { WorkspaceMutations, makeWorkspaceMutations, } from "@agentxm/workspace-state";
-import { runWorkspaceTransaction } from "./transaction.js";
-import { acquireWorkspaceTransitionLock } from "./transition-lock.js";
-/**
- * The live transaction capabilities: the runner claims the shared settings
- * and lockfile targets by default, and both members eliminate FileSystem and
- * Path so the facade's methods stay `R = never` for callers.
- */
-export const makeWorkspaceTransactionCapabilities = ({ workspaceDir, settingsPath, lockPath, }) => Effect.gen(function* () {
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    // Transaction admission must be distinct from the facade's mutation
-    // mutex: a transaction calls the same service's mutation methods while
-    // it owns the outer admission permit.
-    const transactionSemaphore = yield* Semaphore.make(1);
-    const fsLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
-    const runTransaction = (args) => runWorkspaceTransaction({
-        workspaceDir,
-        semaphore: transactionSemaphore,
-        targets: [
-            ...(args.claimDefaultTargets === false ? [] : [settingsPath, lockPath]),
-            ...(args.targets ?? []),
-        ],
-        transition: args.transition,
-        validate: args.validate,
-        ...(args.onRestorationStarted === undefined
-            ? {}
-            : { onRestorationStarted: args.onRestorationStarted }),
-    }).pipe(Effect.provide(fsLayer));
-    const acquireTransition = (request) => acquireWorkspaceTransitionLock({
-        workspaceDir,
-        holder: {
-            command: request.command,
-            pid: process.pid,
-            ...(request.candidateId === undefined ? {} : { candidateId: request.candidateId }),
-        },
-        ...(request.onWaiting === undefined ? {} : { onWaiting: request.onWaiting }),
-    }).pipe(Effect.provide(fsLayer));
-    return { runTransaction, acquireTransition };
-});
-/**
- * Create workspace mutations effect.
- *
- * Loads an existing workspace from disk.
- *
- * The workspace must already be initialized. Missing or invalid settings and
- * invalid or unsupported lockfiles fail fast with a typed workspace error.
- *
- * @param options - WorkspaceMutations layer options
- * @returns Effect yielding WorkspaceMutationsService
- */
-export const loadWorkspace = (options) => makeWorkspaceMutations(options, makeWorkspaceTransactionCapabilities);
-/**
- * Create a layer that loads workspace read model from disk.
- *
- * The workspace must already be initialized.
- *
- * @param options - WorkspaceMutations layer options
- * @returns Layer providing WorkspaceMutations
- *
- * @experimental This API is unstable and may change without notice.
- */
-export const layer = (options) => Layer.effect(WorkspaceMutations, loadWorkspace(options));
-//# sourceMappingURL=load-workspace.js.map

package/dist/src/operations/transaction.d.ts

@@ -1,58 +0,0 @@
-/**
- * Workspace transaction mechanics: the snapshot/restore/validate/rollback
- * runner and the closure settlement operations, implemented against the
- * ambient authority context declared in `../transaction.ts`.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Path from "effect/Path";
-import * as Semaphore from "effect/Semaphore";
-import { WorkspaceRestorationIncomplete, type WorkspaceTransactionFailure } from "@agentxm/workspace-state";
-/** Run one semantic closure's mutations under its closure identity. */
-export declare const withWorkspaceClosure: (closureId: string) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
-export interface WorkspaceTransactionArgs<A, E, R> {
-    readonly workspaceDir: string;
-    /** In-process admission owned by the workspace service instance. */
-    readonly semaphore: Semaphore.Semaphore;
-    /** Authoritative files or directories that the transition may mutate. */
-    readonly targets: ReadonlyArray<string>;
-    /** Desired, lock, canonical, projection, and native-configuration mutation. */
-    readonly transition: Effect.Effect<A, E, R>;
-    /** Confirms the complete durable postcondition before the transaction commits. */
-    readonly validate: (value: A) => Effect.Effect<void, E, R>;
-    /** Observes the start of rollback restoration; never controls it. */
-    readonly onRestorationStarted?: Effect.Effect<void>;
-}
-/**
- * Settle one closure: its commits stand, so its snapshots leave the
- * restoration set and a later closure touching the same target takes a fresh
- * post-commit preimage. No-op outside a transaction.
- */
-export declare const settleWorkspaceClosure: (closureId: string) => Effect.Effect<void>;
-/**
- * Roll back one failed closure: restore and verify exactly its snapshots, in
- * reverse order, leaving every other closure's work in place. A restoration
- * that does not complete and verify records a pending typed failure the
- * transaction surfaces at its end — the truth travels in memory, never
- * through a later workspace write. No-op outside a transaction.
- */
-export declare const rollbackWorkspaceClosure: (closureId: string) => Effect.Effect<void>;
-/**
- * Run one coupled workspace mutation under the workspace transition lock.
- *
- * Every authoritative target is snapshotted into a uniquely prefixed
- * OS-temporary directory before the transition begins. A failed transition or
- * postcondition check restores and verifies the exact pre-operation paths and
- * removes the snapshots; a restoration that does not complete and verify
- * fails with the typed {@link WorkspaceRestorationIncomplete}, preserving the
- * snapshot directory for manual inspection. Nothing about a failure persists
- * in the workspace: the next mutation plans from the current workspace state.
- *
- * The invocation-level transition hold is reused when a plan-family apply
- * already acquired it; otherwise this transaction acquires its own for the
- * duration of the mutation.
- */
-export declare const runWorkspaceTransaction: <A, E, R>(args: WorkspaceTransactionArgs<A, E, R>) => Effect.Effect<A, WorkspaceTransactionFailure | WorkspaceRestorationIncomplete | E, R | FileSystem.FileSystem | Path.Path>;
-//# sourceMappingURL=transaction.d.ts.map

package/dist/src/operations/transaction.js

@@ -1,359 +0,0 @@
-/**
- * Workspace transaction mechanics: the snapshot/restore/validate/rollback
- * runner and the closure settlement operations, implemented against the
- * ambient authority context declared in `../transaction.ts`.
- *
- * @experimental This API is unstable and may change without notice.
- */
-import { createHash, randomBytes } from "node:crypto";
-import * as Cause from "effect/Cause";
-import * as Effect from "effect/Effect";
-import * as FileSystem from "effect/FileSystem";
-import * as Option from "effect/Option";
-import * as Path from "effect/Path";
-import * as Semaphore from "effect/Semaphore";
-import { recordFootprint } from "@agentxm/workspace-state";
-import { CurrentWorkspaceClosure, CurrentWorkspaceTransaction, protectInContext, TransitionLockUnavailable, WorkspaceDirectoryError, WorkspaceRestorationError, WorkspaceRestorationIncomplete, WorkspaceTransitionCompromised, } from "@agentxm/workspace-state";
-import { acquireWorkspaceTransitionLock, heldWorkspaceTransition, isWorkspaceTransitionHeldByThisInvocation, } from "./transition-lock.js";
-/** Run one semantic closure's mutations under its closure identity. */
-export const withWorkspaceClosure = (closureId) => (effect) => effect.pipe(Effect.provideService(CurrentWorkspaceClosure, closureId));
-const normalizedTargets = (path, targets) => {
-    const sorted = Array.from(new Set(targets.map((target) => path.resolve(target)))).sort((left, right) => left.length - right.length || left.localeCompare(right));
-    const retained = [];
-    for (const target of sorted) {
-        if (retained.some((parent) => target === parent || target.startsWith(`${parent}${path.sep}`))) {
-            continue;
-        }
-        retained.push(target);
-    }
-    return retained;
-};
-const workspaceRelative = (path, workspaceDir, target) => {
-    const relative = path.relative(path.dirname(workspaceDir), target);
-    return relative.startsWith("..") ? target : relative;
-};
-const sha256 = (input) => createHash("sha256").update(input).digest("hex");
-/**
- * Deterministic content hash of a path's current state: file bytes, symlink
- * target, recursive directory listing, or the literal `absent`.
- */
-const hashPathState = (fs, path, target) => Effect.gen(function* () {
-    const link = yield* fs.readLink(target).pipe(Effect.option);
-    if (Option.isSome(link))
-        return sha256(`symlink:${link.value}`);
-    const exists = yield* fs.exists(target);
-    if (!exists)
-        return "absent";
-    const info = yield* fs.stat(target);
-    if (info.type === "Directory") {
-        const entries = [...(yield* fs.readDirectory(target))].sort();
-        const parts = [];
-        for (const entry of entries) {
-            const child = yield* hashPathState(fs, path, path.join(target, entry));
-            parts.push(`${entry}:${child}`);
-        }
-        return sha256(`dir:${parts.join("\n")}`);
-    }
-    const bytes = yield* fs.readFile(target);
-    return sha256(bytes);
-}).pipe(Effect.catch(() => Effect.succeed("unhashable")));
-const dropClosureSnapshots = (context, closureId) => {
-    let index = context.snapshots.length;
-    while (index > 0) {
-        index -= 1;
-        if (context.snapshots[index]?.closure === closureId) {
-            context.snapshots.splice(index, 1);
-        }
-    }
-    context.protectedTargets.delete(closureId);
-};
-/**
- * Settle one closure: its commits stand, so its snapshots leave the
- * restoration set and a later closure touching the same target takes a fresh
- * post-commit preimage. No-op outside a transaction.
- */
-export const settleWorkspaceClosure = (closureId) => CurrentWorkspaceTransaction.pipe(Effect.flatMap(Option.match({
-    onNone: () => Effect.void,
-    onSome: (context) => context.snapshotSemaphore.withPermits(1)(Effect.sync(() => {
-        dropClosureSnapshots(context, closureId);
-    })),
-})));
-/**
- * Roll back one failed closure: restore and verify exactly its snapshots, in
- * reverse order, leaving every other closure's work in place. A restoration
- * that does not complete and verify records a pending typed failure the
- * transaction surfaces at its end — the truth travels in memory, never
- * through a later workspace write. No-op outside a transaction.
- */
-export const rollbackWorkspaceClosure = (closureId) => CurrentWorkspaceTransaction.pipe(Effect.flatMap(Option.match({
-    onNone: () => Effect.void,
-    onSome: (context) => context.snapshotSemaphore.withPermits(1)(Effect.gen(function* () {
-        const { fs, path } = context;
-        const owned = context.snapshots.filter((snapshot) => snapshot.closure === closureId);
-        if (owned.length === 0) {
-            dropClosureSnapshots(context, closureId);
-            return;
-        }
-        const held = heldWorkspaceTransition(path.resolve(context.workspaceDir));
-        const transitionCompromised = held === undefined ? () => false : held.isCompromised;
-        yield* restoreAll(fs, path, owned, transitionCompromised).pipe(Effect.andThen(verifySnapshots(fs, path, owned)), Effect.matchEffect({
-            onFailure: (restorationCause) => Effect.sync(() => {
-                context.pendingRestorationFailures.push({
-                    closureId,
-                    restorationCause,
-                    retained: owned.map((snapshot) => workspaceRelative(path, context.workspaceDir, snapshot.target)),
-                });
-            }),
-            onSuccess: () => Effect.void,
-        }));
-        dropClosureSnapshots(context, closureId);
-    })),
-})));
-/** Whether anything occupies the path: a file, directory, or (broken) symlink. */
-const pathPresent = (fs, target) => fs.readLink(target).pipe(Effect.map(() => true), Effect.catch(() => fs.exists(target)));
-/**
- * Restore one snapshot through validated staging and atomic publication.
- * The restored content is fully staged and validated in an owned
- * `<target>.tmp.<unique>` sibling before a rename publishes it, so abrupt
- * termination — including a forced process exit — can never expose a
- * partially restored target: the authoritative path holds the failure-time
- * content, the restored content, or (for a directory swap only, between two
- * renames) nothing, never a partial tree. The target path itself is never
- * removed; only owned `.tmp.` siblings are.
- */
-const restoreSnapshot = (fs, path, snapshot) => Effect.gen(function* () {
-    if (snapshot.state === "absent") {
-        if (!(yield* pathPresent(fs, snapshot.target)))
-            return;
-        // Publishing absence is one rename: the mutated tree leaves the
-        // authoritative path atomically, then the owned trash is removed.
-        const trash = `${snapshot.target}.tmp.${randomBytes(6).toString("hex")}`;
-        yield* fs.rename(snapshot.target, trash);
-        yield* fs.remove(trash, { recursive: true, force: true }).pipe(Effect.ignore);
-        return;
-    }
-    yield* fs.makeDirectory(path.dirname(snapshot.target), { recursive: true });
-    const staging = `${snapshot.target}.tmp.${randomBytes(6).toString("hex")}`;
-    yield* Effect.gen(function* () {
-        if (snapshot.state === "symlink") {
-            yield* fs.symlink(snapshot.linkTarget, staging);
-            const staged = yield* fs.readLink(staging);
-            if (staged !== snapshot.linkTarget) {
-                return yield* new WorkspaceRestorationError({
-                    target: snapshot.target,
-                    step: "stage",
-                    cause: { staged, expected: snapshot.linkTarget },
-                });
-            }
-        }
-        else {
-            yield* fs.copy(snapshot.backup, staging, { preserveTimestamps: true });
-            const stagedHash = yield* hashPathState(fs, path, staging);
-            const backupHash = yield* hashPathState(fs, path, snapshot.backup);
-            if (stagedHash !== backupHash || stagedHash === "unhashable") {
-                return yield* new WorkspaceRestorationError({
-                    target: snapshot.target,
-                    step: "stage",
-                    cause: { stagedHash, backupHash },
-                });
-            }
-        }
-        const targetLink = yield* fs.readLink(snapshot.target).pipe(Effect.option);
-        const targetInfo = Option.isSome(targetLink)
-            ? Option.none()
-            : yield* fs.stat(snapshot.target).pipe(Effect.option);
-        const targetPresent = Option.isSome(targetLink) || Option.isSome(targetInfo);
-        const targetIsDirectory = Option.exists(targetInfo, (info) => info.type === "Directory");
-        const stagedIsDirectory = snapshot.state === "copied" && (yield* fs.stat(staging)).type === "Directory";
-        if (!targetPresent || (!targetIsDirectory && !stagedIsDirectory)) {
-            // rename atomically replaces a file or symlink target.
-            yield* fs.rename(staging, snapshot.target);
-            return;
-        }
-        // A directory is swapped through two renames of owned names; the
-        // moved-aside content is intact in the trash sibling until removal.
-        const trash = `${snapshot.target}.tmp.${randomBytes(6).toString("hex")}`;
-        yield* fs.rename(snapshot.target, trash);
-        yield* fs.rename(staging, snapshot.target);
-        yield* fs.remove(trash, { recursive: true, force: true }).pipe(Effect.ignore);
-    }).pipe(Effect.onError(() => fs.remove(staging, { recursive: true, force: true }).pipe(Effect.ignore)));
-});
-const restoreAll = (fs, path, snapshots, transitionCompromised) => Effect.forEach([...snapshots].reverse(), (snapshot) => Effect.suspend(() => 
-// Restoration is a durable write like any other: once lock ownership
-// is lost it must stop, or it could overwrite a successor's work.
-transitionCompromised()
-    ? Effect.fail(new WorkspaceRestorationError({
-        target: snapshot.target,
-        step: "stopped",
-        cause: undefined,
-    }))
-    : restoreSnapshot(fs, path, snapshot).pipe(Effect.andThen(recordFootprint({ path: snapshot.target, change: "restored" })))), {
-    discard: true,
-});
-const verifySnapshots = (fs, path, snapshots) => Effect.forEach(snapshots, (snapshot) => Effect.gen(function* () {
-    const verified = yield* Effect.gen(function* () {
-        if (snapshot.state === "absent") {
-            return !(yield* fs.exists(snapshot.target));
-        }
-        if (snapshot.state === "symlink") {
-            const link = yield* fs.readLink(snapshot.target).pipe(Effect.option);
-            return Option.exists(link, (value) => value === snapshot.linkTarget);
-        }
-        const restored = yield* hashPathState(fs, path, snapshot.target);
-        const backup = yield* hashPathState(fs, path, snapshot.backup);
-        return restored === backup && restored !== "unhashable";
-    }).pipe(Effect.catch(() => Effect.succeed(false)));
-    if (!verified) {
-        return yield* new WorkspaceRestorationError({
-            target: snapshot.target,
-            step: "verify",
-            cause: { state: snapshot.state },
-        });
-    }
-}), { discard: true });
-/**
- * Run one coupled workspace mutation under the workspace transition lock.
- *
- * Every authoritative target is snapshotted into a uniquely prefixed
- * OS-temporary directory before the transition begins. A failed transition or
- * postcondition check restores and verifies the exact pre-operation paths and
- * removes the snapshots; a restoration that does not complete and verify
- * fails with the typed {@link WorkspaceRestorationIncomplete}, preserving the
- * snapshot directory for manual inspection. Nothing about a failure persists
- * in the workspace: the next mutation plans from the current workspace state.
- *
- * The invocation-level transition hold is reused when a plan-family apply
- * already acquired it; otherwise this transaction acquires its own for the
- * duration of the mutation.
- */
-export const runWorkspaceTransaction = (args) => Effect.gen(function* () {
-    const current = yield* CurrentWorkspaceTransaction;
-    if (Option.isSome(current)) {
-        const activeClosure = yield* CurrentWorkspaceClosure;
-        yield* Effect.forEach(normalizedTargets(current.value.path, args.targets), (target) => protectInContext(current.value, target, activeClosure), { discard: true });
-        const value = yield* args.transition;
-        yield* args.validate(value);
-        return value;
-    }
-    const fs = yield* FileSystem.FileSystem;
-    const path = yield* Path.Path;
-    const workspaceDir = path.resolve(args.workspaceDir);
-    const missingWorkspaceAncestors = [];
-    let ancestor = workspaceDir;
-    while (true) {
-        const exists = yield* fs
-            .exists(ancestor)
-            .pipe(Effect.mapError((cause) => new WorkspaceDirectoryError({ path: ancestor, step: "inspect", cause })));
-        if (exists)
-            break;
-        missingWorkspaceAncestors.push(ancestor);
-        const parent = path.dirname(ancestor);
-        if (parent === ancestor)
-            break;
-        ancestor = parent;
-    }
-    return yield* args.semaphore.withPermits(1)(Effect.gen(function* () {
-        yield* fs
-            .makeDirectory(workspaceDir, { recursive: true })
-            .pipe(Effect.mapError((cause) => new WorkspaceDirectoryError({ path: workspaceDir, step: "create", cause })));
-        const scratchDir = path.join(workspaceDir, "tmp");
-        const removeEmptyScratch = fs.readDirectory(scratchDir).pipe(Effect.flatMap((entries) => entries.length === 0
-            ? fs.remove(scratchDir, { recursive: true, force: false })
-            : Effect.void), Effect.ignore);
-        const removeNewEmptyWorkspace = Effect.forEach(missingWorkspaceAncestors, (directory) => fs.readDirectory(directory).pipe(Effect.flatMap((entries) => entries.length === 0
-            ? fs.remove(directory, { recursive: true, force: false })
-            : Effect.void), Effect.ignore), { concurrency: 1, discard: true });
-        return yield* Effect.scoped(Effect.gen(function* () {
-            // The invocation-level transition hold already provides
-            // cross-process exclusion; acquiring here again would deadlock on
-            // our own lock.
-            if (!isWorkspaceTransitionHeldByThisInvocation(workspaceDir)) {
-                const contention = yield* acquireWorkspaceTransitionLock({
-                    workspaceDir,
-                    holder: { command: "workspace-transaction", pid: process.pid },
-                });
-                if (Option.isSome(contention)) {
-                    return yield* new TransitionLockUnavailable({
-                        holder: Option.getOrUndefined(contention.value.holder),
-                        waitedMillis: contention.value.waitedMillis,
-                    });
-                }
-            }
-            const context = {
-                fs,
-                path,
-                workspaceDir,
-                snapshotStore: { dir: undefined },
-                protectedTargets: new Map(),
-                snapshots: [],
-                snapshotSemaphore: Semaphore.makeUnsafe(1),
-                pendingRestorationFailures: [],
-                snapshotSequence: { value: 0 },
-            };
-            // The store is removed only when nothing in it is still needed:
-            // a closure whose rollback failed leaves its pre-change
-            // snapshots preserved for manual recovery, and the typed
-            // restoration fact names this directory.
-            const removeSnapshotStore = Effect.suspend(() => context.snapshotStore.dir === undefined ||
-                context.pendingRestorationFailures.length > 0
-                ? Effect.void
-                : fs
-                    .remove(context.snapshotStore.dir, { recursive: true, force: true })
-                    .pipe(Effect.ignore));
-            // The compromise signal of the hold serializing this mutation:
-            // the invocation-level hold when one exists, else the one just
-            // acquired above. Mutation races against it and stops when
-            // ownership is lost.
-            const held = heldWorkspaceTransition(workspaceDir);
-            // Interruptible like the business side: the race runs inside the
-            // uninterruptible rollback guard, and its loser must be
-            // interruptible for the race to settle.
-            const compromiseSignal = (held === undefined ? Effect.never : held.compromised).pipe(Effect.interruptible);
-            const transitionCompromised = held === undefined ? () => false : held.isCompromised;
-            const business = Effect.gen(function* () {
-                // The transaction's own declared targets belong to the
-                // operation closure: no semantic closure is active yet.
-                yield* Effect.forEach(normalizedTargets(path, args.targets), (target) => protectInContext(context, target, undefined), { discard: true });
-                const value = yield* args.transition;
-                yield* args.validate(value);
-                return value;
-            }).pipe(Effect.provideService(CurrentWorkspaceTransaction, Option.some(context)), Effect.interruptible);
-            const retainAll = (cause, restorationCause) => Effect.gen(function* () {
-                const interruption = Cause.hasInterruptsOnly(cause);
-                return yield* new WorkspaceRestorationIncomplete({
-                    terminationCause: interruption ? "interruption" : "failure",
-                    transitionCause: cause,
-                    restorationCause,
-                    snapshotDir: context.snapshotStore.dir,
-                    retained: context.snapshots.map((snapshot) => workspaceRelative(path, workspaceDir, snapshot.target)),
-                });
-            });
-            // The mask/restore shape is load-bearing: the business runs in
-            // the restored (interruptible) region so an external termination
-            // request reaches it, while the settlement handlers — rollback,
-            // verification, and the typed retain path — run uninterruptibly
-            // and observe the interruption as a cause. A blanket mask would
-            // never deliver the interrupt to the parked business and the
-            // invocation could not stop.
-            return yield* Effect.uninterruptibleMask((restoreInterruptibility) => restoreInterruptibility(Effect.raceFirst(business, compromiseSignal)).pipe(Effect.matchCauseEffect({
-                onFailure: (cause) => {
-                    const raceError = Option.getOrUndefined(Cause.findErrorOption(cause));
-                    if (raceError instanceof WorkspaceTransitionCompromised) {
-                        // Ownership is lost: restoring now could overwrite a
-                        // successor's work. Retain everything the failure left,
-                        // keep the snapshots, and fail typed.
-                        return retainAll(cause, raceError);
-                    }
-                    return (args.onRestorationStarted ?? Effect.void)
-                        .pipe(Effect.andThen(restoreAll(fs, path, context.snapshots, transitionCompromised)), Effect.andThen(verifySnapshots(fs, path, context.snapshots)))
-                        .pipe(Effect.matchEffect({
-                        onFailure: (restorationCause) => retainAll(cause, restorationCause),
-                        onSuccess: () => removeSnapshotStore.pipe(Effect.andThen(Effect.failCause(cause))),
-                    }));
-                },
-                onSuccess: (value) => removeSnapshotStore.pipe(Effect.as(value)),
-            })));
-        })).pipe(Effect.ensuring(removeEmptyScratch), Effect.ensuring(removeNewEmptyWorkspace));
-    }));
-});
-//# sourceMappingURL=transaction.js.map