@agentxm/workspace-operations 0.28.10 → 0.28.12

package/dist/src/index.d.ts

@@ -27,5 +27,5 @@ export * from "./plan/job-step-message.js";
 export { scanPlanReadiness, type PlanReadinessReport } from "./operations/scan-plan-readiness.js";
 export { augmentPlanWithReconciliation, type AugmentedPlanResult, type DegradedLockfileState, } from "./operations/augment-plan.js";
 export { rollbackWorkspaceClosure, runWorkspaceTransaction, settleWorkspaceClosure, withWorkspaceClosure, type WorkspaceTransactionArgs, } from "./operations/transaction.js";
-export { TRANSITION_WAIT_BOUND_MILLIS, acquireWorkspaceTransitionLock, heldWorkspaceTransition, isWorkspaceTransitionHeldByThisInvocation, transitionLockPath, type HeldWorkspaceTransition, } from "./operations/transition-lock.js";
+export { liveWorkspaceTransitionLock, type WorkspaceTransitionLock, TRANSITION_WAIT_BOUND_MILLIS, acquireWorkspaceTransitionLock, heldWorkspaceTransition, isWorkspaceTransitionHeldByThisInvocation, transitionLockPath, type HeldWorkspaceTransition, } from "./operations/transition-lock.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/src/index.js

@@ -39,5 +39,5 @@ export { augmentPlanWithReconciliation, } from "./operations/augment-plan.js";
 // Workspace transaction runner and closure lifecycle
 export { rollbackWorkspaceClosure, runWorkspaceTransaction, settleWorkspaceClosure, withWorkspaceClosure, } from "./operations/transaction.js";
 // Transition lock runtime
-export { TRANSITION_WAIT_BOUND_MILLIS, acquireWorkspaceTransitionLock, heldWorkspaceTransition, isWorkspaceTransitionHeldByThisInvocation, transitionLockPath, } from "./operations/transition-lock.js";
+export { liveWorkspaceTransitionLock, TRANSITION_WAIT_BOUND_MILLIS, acquireWorkspaceTransitionLock, heldWorkspaceTransition, isWorkspaceTransitionHeldByThisInvocation, transitionLockPath, } from "./operations/transition-lock.js";
 //# sourceMappingURL=index.js.map

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

@@ -11,12 +11,13 @@ 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";
+import { type WorkspaceTransitionLock } 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 declare const makeWorkspaceTransactionCapabilities: MakeWorkspaceTransactionCapabilities;
+export declare const makeWorkspaceTransactionCapabilities: (lock: WorkspaceTransitionLock) => MakeWorkspaceTransactionCapabilities;
 /**
  * Create workspace mutations effect.
  *

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

@@ -13,13 +13,13 @@ 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";
+import { liveWorkspaceTransitionLock } 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* () {
+export const makeWorkspaceTransactionCapabilities = (lock) => ({ 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
@@ -28,6 +28,7 @@ export const makeWorkspaceTransactionCapabilities = ({ workspaceDir, settingsPat
     const transactionSemaphore = yield* Semaphore.make(1);
     const fsLayer = Layer.mergeAll(Layer.succeed(FileSystem.FileSystem, fs), Layer.succeed(Path.Path, path));
     const runTransaction = (args) => runWorkspaceTransaction({
+        lock,
         workspaceDir,
         semaphore: transactionSemaphore,
         targets: [
@@ -40,7 +41,8 @@ export const makeWorkspaceTransactionCapabilities = ({ workspaceDir, settingsPat
             ? {}
             : { onRestorationStarted: args.onRestorationStarted }),
     }).pipe(Effect.provide(fsLayer));
-    const acquireTransition = (request) => acquireWorkspaceTransitionLock({
+    const acquireTransition = (request) => lock
+        .acquire({
         workspaceDir,
         holder: {
             command: request.command,
@@ -48,7 +50,8 @@ export const makeWorkspaceTransactionCapabilities = ({ workspaceDir, settingsPat
             ...(request.candidateId === undefined ? {} : { candidateId: request.candidateId }),
         },
         ...(request.onWaiting === undefined ? {} : { onWaiting: request.onWaiting }),
-    }).pipe(Effect.provide(fsLayer));
+    })
+        .pipe(Effect.provide(fsLayer));
     return { runTransaction, acquireTransition };
 });
 /**
@@ -62,7 +65,7 @@ export const makeWorkspaceTransactionCapabilities = ({ workspaceDir, settingsPat
  * @param options - WorkspaceMutations layer options
  * @returns Effect yielding WorkspaceMutationsService
  */
-export const loadWorkspace = (options) => makeWorkspaceMutations(options, makeWorkspaceTransactionCapabilities);
+export const loadWorkspace = (options) => makeWorkspaceMutations(options, makeWorkspaceTransactionCapabilities(liveWorkspaceTransitionLock));
 /**
  * Create a layer that loads workspace read model from disk.
  *

package/dist/src/operations/memory-transition-lock.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Deterministic in-process workspace transition admission for tests.
+ *
+ * One world owns admission state while each invocation receives an isolated
+ * ownership view. Waiting uses Effect time so contention and interruption can
+ * be exercised without native timers or lock files.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import type { WorkspaceTransitionLock } from "./transition-lock.js";
+export interface MemoryTransitionLockWorld {
+    readonly counts: () => {
+        readonly acquisitions: number;
+        readonly releases: number;
+    };
+    readonly invocation: () => WorkspaceTransitionLock;
+}
+/** Make one isolated admission world for a deterministic test scenario. */
+export declare const makeMemoryTransitionLockWorld: () => MemoryTransitionLockWorld;
+//# sourceMappingURL=memory-transition-lock.d.ts.map

package/dist/src/operations/memory-transition-lock.js

@@ -0,0 +1,57 @@
+/**
+ * Deterministic in-process workspace transition admission for tests.
+ *
+ * One world owns admission state while each invocation receives an isolated
+ * ownership view. Waiting uses Effect time so contention and interruption can
+ * be exercised without native timers or lock files.
+ *
+ * @experimental This API is unstable and may change without notice.
+ */
+import * as Effect from "effect/Effect";
+import * as Option from "effect/Option";
+import * as Semaphore from "effect/Semaphore";
+/** Make one isolated admission world for a deterministic test scenario. */
+export const makeMemoryTransitionLockWorld = () => {
+    const admission = Semaphore.makeUnsafe(1);
+    let acquisitions = 0;
+    let releases = 0;
+    let holder = Option.none();
+    return {
+        counts: () => ({ acquisitions, releases }),
+        invocation: () => {
+            let held;
+            return {
+                held: (directory) => (held?.directory === directory ? held.lease : undefined),
+                acquire: (args) => Effect.uninterruptibleMask((restore) => Effect.gen(function* () {
+                    let waitedMillis = 0;
+                    let reportedWaiting = false;
+                    while (!(yield* admission.takeIfAvailable(1))) {
+                        if (!reportedWaiting && args.onWaiting !== undefined) {
+                            yield* restore(args.onWaiting(holder));
+                            reportedWaiting = true;
+                        }
+                        if (waitedMillis >= (args.waitBoundMillis ?? 60_000)) {
+                            return Option.some({ holder, waitedMillis });
+                        }
+                        yield* restore(Effect.sleep("250 millis"));
+                        waitedMillis += 250;
+                    }
+                    holder = Option.some(args.holder);
+                    acquisitions += 1;
+                    held = {
+                        directory: args.workspaceDir,
+                        lease: { compromised: Effect.never, isCompromised: () => false },
+                    };
+                    yield* Effect.addFinalizer(() => Effect.gen(function* () {
+                        held = undefined;
+                        holder = Option.none();
+                        releases += 1;
+                        yield* admission.release(1);
+                    }));
+                    return Option.none();
+                })),
+            };
+        },
+    };
+};
+//# sourceMappingURL=memory-transition-lock.js.map

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

@@ -10,9 +10,11 @@ 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";
+import type { WorkspaceTransitionLock } from "./transition-lock.js";
 /** 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 lock: WorkspaceTransitionLock;
     readonly workspaceDir: string;
     /** In-process admission owned by the workspace service instance. */
     readonly semaphore: Semaphore.Semaphore;

package/dist/src/operations/transaction.js

@@ -14,7 +14,6 @@ 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) => {
@@ -94,8 +93,7 @@ export const rollbackWorkspaceClosure = (closureId) => CurrentWorkspaceTransacti
             dropClosureSnapshots(context, closureId);
             return;
         }
-        const held = heldWorkspaceTransition(path.resolve(context.workspaceDir));
-        const transitionCompromised = held === undefined ? () => false : held.isCompromised;
+        const transitionCompromised = context.isTransitionCompromised;
         yield* restoreAll(fs, path, owned, transitionCompromised).pipe(Effect.andThen(verifySnapshots(fs, path, owned)), Effect.matchEffect({
             onFailure: (restorationCause) => Effect.sync(() => {
                 context.pendingRestorationFailures.push({
@@ -267,8 +265,8 @@ export const runWorkspaceTransaction = (args) => 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({
+            if (args.lock.held(workspaceDir) === undefined) {
+                const contention = yield* args.lock.acquire({
                     workspaceDir,
                     holder: { command: "workspace-transaction", pid: process.pid },
                 });
@@ -279,7 +277,9 @@ export const runWorkspaceTransaction = (args) => Effect.gen(function* () {
                     });
                 }
             }
+            const held = args.lock.held(workspaceDir);
             const context = {
+                isTransitionCompromised: held?.isCompromised ?? (() => false),
                 fs,
                 path,
                 workspaceDir,
@@ -304,7 +304,6 @@ export const runWorkspaceTransaction = (args) => Effect.gen(function* () {
             // 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.

package/dist/src/operations/transition-lock.d.ts

@@ -63,4 +63,10 @@ export declare const acquireWorkspaceTransitionLock: (args: {
         readonly update: number;
     };
 }) => Effect.Effect<Option.Option<TransitionContention>, WorkspaceTransitionAcquireFailure, FileSystem.FileSystem | Path.Path | Scope.Scope>;
+/** One invocation's view of transition admission and ownership. */
+export interface WorkspaceTransitionLock {
+    readonly acquire: typeof acquireWorkspaceTransitionLock;
+    readonly held: typeof heldWorkspaceTransition;
+}
+export declare const liveWorkspaceTransitionLock: WorkspaceTransitionLock;
 //# sourceMappingURL=transition-lock.d.ts.map

package/dist/src/operations/transition-lock.js

@@ -291,4 +291,8 @@ export const acquireWorkspaceTransitionLock = (args) => Effect.gen(function* ()
         waitedMillis += Duration.toMillis(WAIT_INTERVAL);
     }
 });
+export const liveWorkspaceTransitionLock = {
+    acquire: acquireWorkspaceTransitionLock,
+    held: heldWorkspaceTransition,
+};
 //# sourceMappingURL=transition-lock.js.map

package/dist/src/testing.d.ts

@@ -9,4 +9,5 @@
  */
 export { ResolvePlanInteractionTest, type ResolvePlanInteractionTestState, } from "./plan/resolve-plan-interaction.js";
 export { interactiveOnlyPlanExecution, preapprovedPlanExecution, promptablePlanExecution, } from "./plan/plan-execution-fixtures.js";
+export { makeMemoryTransitionLockWorld, type MemoryTransitionLockWorld, } from "./operations/memory-transition-lock.js";
 //# sourceMappingURL=testing.d.ts.map

package/dist/src/testing.js

@@ -9,4 +9,5 @@
  */
 export { ResolvePlanInteractionTest, } from "./plan/resolve-plan-interaction.js";
 export { interactiveOnlyPlanExecution, preapprovedPlanExecution, promptablePlanExecution, } from "./plan/plan-execution-fixtures.js";
+export { makeMemoryTransitionLockWorld, } from "./operations/memory-transition-lock.js";
 //# sourceMappingURL=testing.js.map

package/package.json

@@ -4,9 +4,9 @@
     "url": "https://github.com/agentxm/axm/issues"
   },
   "dependencies": {
-    "@agentxm/extension-model": "^0.28.10",
-    "@agentxm/registry-protocol": "^0.28.10",
-    "@agentxm/workspace-state": "^0.28.10",
+    "@agentxm/extension-model": "^0.28.12",
+    "@agentxm/registry-protocol": "^0.28.12",
+    "@agentxm/workspace-state": "^0.28.12",
     "effect": "4.0.0-rc.112",
     "proper-lockfile": "^4.1.2"
   },
@@ -60,5 +60,5 @@
   },
   "sideEffects": false,
   "type": "module",
-  "version": "0.28.10"
+  "version": "0.28.12"
 }