@byok-sdk/client 0.11.0 → 0.12.0

package/README.md

@@ -175,9 +175,21 @@ strict Agent execution has one workspace authority and never falls back to a
 task-scoped Git workspace.
 
 Successful startup with this configuration advertises `agent-home-contract`. Agent offers are distinct
-from legacy task offers and fail closed when identity, profile revision,
-session/runtime/cwd evidence, or the one-writer lease does not match. Agent
-files other than the SDK-reserved `.byok` namespace are opaque; there is no
+from legacy task offers and fail closed when identity, profile revision, or
+session/runtime/cwd evidence does not match. Within one daemon process,
+execution leases are scoped to `(agentId, sessionRef)`: different sessions of
+one Agent may run concurrently in the same canonical home, while the same
+session remains serialized. Fresh
+tasks bind their task-scoped admission lease to the runtime-created session
+before the SDK exposes that session. Shared `.byok` metadata mutations use a
+short per-home gate. Agent-memory hosted projection serializes the complete
+close-time outbox transaction per home because its durable outbox is one CAS
+authority; the publish wait remains timeout-bounded and does not serialize the
+sessions' runtime execution. The process-owned home activity marker remains
+held until the final active session exits so relocation stays fail-closed. A
+second daemon process remains excluded by that marker; cross-process session
+multiplexing is not provided. Agent files
+other than the SDK-reserved `.byok` namespace are opaque; there is no
 required `artifacts/` directory and the client does not parse or index their
 contents.
 

package/dist/agent-home.d.ts

@@ -73,6 +73,14 @@ export interface AgentHomeBinding {
     readonly resolution: AgentHomeResolution;
     readonly lease: AgentHomeLease;
 }
+export interface AgentHomeExecutionLease extends AgentHomeLease {
+    /** Fresh tasks are task-keyed until the runtime returns its durable session id. */
+    bindSession(sessionRef: string): Promise<void>;
+}
+export interface AgentHomeExecutionBinding {
+    readonly resolution: AgentHomeResolution;
+    readonly lease: AgentHomeExecutionLease;
+}
 export declare function validateAgentRef(value: unknown): AgentRef;
 /**
  * SDK-owned deterministic Agent-home layout. The downstream supplies exactly
@@ -112,11 +120,29 @@ export declare class AgentHomeLeaseManager {
     acquire(resolution: AgentHomeResolution): Promise<AgentHomeLease>;
     private openLeaseMarker;
 }
+/**
+ * Session-scoped execution leases share one process-owned home marker. The
+ * marker remains until the final session exits, so relocation still sees the
+ * Agent home as active, while different sessions no longer exclude each other.
+ */
+export declare class AgentHomeExecutionLeaseManager {
+    private readonly manager;
+    private static readonly groups;
+    private static readonly queues;
+    constructor(manager: AgentHomeLeaseManager);
+    acquire(resolution: AgentHomeResolution, input: {
+        readonly taskId: string;
+        readonly sessionRef?: string;
+    }): Promise<AgentHomeExecutionLease>;
+    mutate<T>(binding: AgentHomeExecutionBinding, operation: () => Promise<T>): Promise<T>;
+    private exclusive;
+}
 /** Coordinates SDK-owned initialization, optional projection, and the lease. */
 export declare class AgentHomeManager {
     readonly layout: AgentHomeLayout;
     readonly projection?: AgentHomeProjection;
     readonly leaseManager: AgentHomeLeaseManager;
+    readonly executionLeaseManager: AgentHomeExecutionLeaseManager;
     constructor(options: {
         hostStorageRoot: string;
         projection?: AgentHomeProjection;
@@ -129,8 +155,15 @@ export declare class AgentHomeManager {
     preflightSync(): void;
     /** Resolve and lease without applying downstream projection side effects. */
     acquire(agentRef: AgentRef): Promise<AgentHomeBinding>;
+    acquireExecution(agentRef: AgentRef, input: {
+        readonly taskId: string;
+        readonly sessionRef?: string;
+    }): Promise<AgentHomeExecutionBinding>;
     /** Initialize only after any requested session exact-match has succeeded. */
     initialize(binding: AgentHomeBinding): Promise<void>;
+    initializeExecution(binding: AgentHomeExecutionBinding): Promise<void>;
+    mutateExecution<T>(binding: AgentHomeExecutionBinding, operation: () => Promise<T>): Promise<T>;
+    private initializeResolved;
     supportsTaskFreeProjection(): boolean;
     /**
      * Apply one task-free projection under the same canonical-home writer lease

package/dist/agent-memory/index.js

@@ -1,4 +1,4 @@
-import { randomUUID, createHash } from 'crypto';
+import { createHash, randomUUID } from 'crypto';
 import { constants, existsSync, promises } from 'fs';
 import path2 from 'path';
 import '@byok-sdk/protocol';
@@ -292,21 +292,24 @@ async function recordAuditWarning(context, kind, values) {
   }
 }
 var agentMemoryHomeQueues = /* @__PURE__ */ new Map();
-async function exclusiveAgentMemoryHome(home, fn) {
-  const previous = agentMemoryHomeQueues.get(home) ?? Promise.resolve();
+async function exclusiveAgentMemoryHomeQueue(queues, home, fn) {
+  const previous = queues.get(home) ?? Promise.resolve();
   let release;
   const next = new Promise((resolve) => {
     release = resolve;
   });
-  agentMemoryHomeQueues.set(home, next);
+  queues.set(home, next);
   await previous;
   try {
     return await fn();
   } finally {
     release();
-    if (agentMemoryHomeQueues.get(home) === next) agentMemoryHomeQueues.delete(home);
+    if (queues.get(home) === next) queues.delete(home);
   }
 }
+async function exclusiveAgentMemoryHome(home, fn) {
+  return exclusiveAgentMemoryHomeQueue(agentMemoryHomeQueues, home, fn);
+}
 var AgentMemoryService = class {
   constructor(input) {
     this.input = input;