@hachej/boring-agent 0.1.100 → 0.1.103

package/dist/{chunk-ZOHN72OS.js → chunk-6WKQ4FC4.js}

@@ -7,7 +7,7 @@ import {
   readConfiguredDefaultModel,
   registerConfiguredModelProviders,
   withPiHarnessDefaults
-} from "./chunk-GRMDMWBW.js";
+} from "./chunk-TW7G33QH.js";
 import {
   AGENT_KNOWLEDGE_FILESYSTEM_ID,
   AgentDefinitionValidationError,
@@ -29,7 +29,7 @@ import {
   validateAgentDefinition,
   validateAgentDeployment,
   validateTool
-} from "./chunk-3OEDBRKY.js";
+} from "./chunk-JNEKOVMJ.js";
 import {
   safeCapture
 } from "./chunk-4IQ4HHBG.js";
@@ -41,12 +41,12 @@ import {
   AgentGatewayErrorCode,
   extractToolUiMetadata,
   sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "./chunk-LSO2AO6Q.js";
+} from "./chunk-7QM22DU7.js";
 import {
   AgentDefinitionErrorCode,
   AgentDeploymentErrorCode,
   ErrorCode
-} from "./chunk-VXF5DWS6.js";
+} from "./chunk-K25PK5EC.js";
 
 // src/server/sandbox/snapshots/deploymentSnapshot.ts
 var VERCEL_UV_BIN_DIR = "/workspace/.boring-agent/sdk/uv/bin";
@@ -147,6 +147,7 @@ function createServerFileSearch(workspace, sandbox) {
 // src/server/sandbox/remote-worker/protocol.ts
 var REMOTE_WORKER_RUNTIME_CWD = "/workspace";
 var REMOTE_WORKER_PROVIDER = "remote-worker";
+var REMOTE_WORKER_EXCLUSIVE_BINARY_CREATE_CAPABILITY = "exclusive-binary-create";
 var WORKER_INTERNAL_TOKEN_HEADER = "x-boring-internal-token";
 var WORKER_WORKSPACE_ID_HEADER = "x-boring-workspace-id";
 var WORKER_REQUEST_ID_HEADER = "x-boring-request-id";
@@ -314,6 +315,9 @@ var RemoteWorkerClient = class {
       headers: makeHeaders({ token: this.token, workspaceId: this.workspaceId, requestId: this.requestId })
     }, this.requestTimeoutMs);
     if (!response.ok) throw await parseError(response);
+    const body2 = await response.json().catch(() => ({}));
+    const capabilities2 = Array.isArray(body2.capabilities) ? body2.capabilities.filter((capability) => capability === "exclusive-binary-create") : void 0;
+    return { ok: true, ...capabilities2 ? { capabilities: capabilities2 } : {} };
   }
   async workspace(op) {
     const response = await this.fetchWithTimeout(`${this.baseUrl}/internal/workspaces/${encodeWorkspaceId(this.workspaceId)}/fs`, {
@@ -412,6 +416,7 @@ function constantTimeTokenEqual(a, b) {
 }
 
 // src/server/workspace/createRemoteWorkerWorkspace.ts
+var EEXIST_CODE = "EEXIST";
 function expectContent(result) {
   if ("content" in result && typeof result.content === "string") return result.content;
   throw new Error("remote worker returned invalid file content response");
@@ -492,7 +497,7 @@ function createRemoteWatcher(client) {
     }
   };
 }
-function createRemoteWorkerWorkspace(client) {
+function createRemoteWorkerWorkspace(client, supportsExclusiveBinaryCreate = false) {
   let watcher = null;
   return {
     root: REMOTE_WORKER_RUNTIME_CWD,
@@ -514,6 +519,18 @@ function createRemoteWorkerWorkspace(client) {
     async writeBinaryFile(path, data) {
       await client.workspace({ op: "writeBinaryFile", path, dataBase64: encodeBytesForWorker(data) });
     },
+    ...supportsExclusiveBinaryCreate ? {
+      async createBinaryFile(path, data) {
+        try {
+          await client.workspace({ op: "createBinaryFile", path, dataBase64: encodeBytesForWorker(data) });
+        } catch (error) {
+          if (error?.code === ErrorCode.enum.REMOTE_WORKER_ALREADY_EXISTS) {
+            throw Object.assign(new Error("EEXIST: file already exists"), { code: EEXIST_CODE });
+          }
+          throw error;
+        }
+      }
+    } : {},
     async readFileWithStat(path) {
       const result = await client.workspace({ op: "readFileWithStat", path });
       if ("content" in result && "stat" in result) return { content: result.content, stat: result.stat };
@@ -562,9 +579,14 @@ function createRemoteWorkerModeAdapter(opts = {}) {
         requestId: ctx.requestId,
         fetchImpl: opts.fetchImpl
       });
-      const workspace = createRemoteWorkerWorkspace(client);
+      const health = await client.health();
+      const workspace = createRemoteWorkerWorkspace(
+        client,
+        health.capabilities?.includes(
+          REMOTE_WORKER_EXCLUSIVE_BINARY_CREATE_CAPABILITY
+        ) ?? false
+      );
       const sandbox = createRemoteWorkerSandbox(client);
-      await sandbox.init?.({ workspace, sessionId: ctx.sessionId });
       return {
         runtimeContext: { runtimeCwd: REMOTE_WORKER_RUNTIME_CWD },
         bash: { kind: "remote" },
@@ -4713,6 +4735,7 @@ function toolInputFromCall(part) {
 }
 function assistantParts(message, messageId) {
   const content = message.content;
+  const assistantAborted = message.stopReason === "aborted";
   if (typeof content === "string") return [{ type: "text", id: `${messageId}:text:0`, text: content }];
   if (!Array.isArray(content)) return [];
   return content.flatMap((part, index) => {
@@ -4732,7 +4755,7 @@ function assistantParts(message, messageId) {
     }
     if (part.type === "toolCall") {
       const toolCallId = optionalString(part.id) ?? `${messageId}:tool:${index}`;
-      const state = part.state === "output-error" ? "output-error" : part.state === "output-available" ? "output-available" : "input-available";
+      const state = part.state === "output-error" ? "output-error" : part.state === "output-available" ? "output-available" : part.state === "aborted" || assistantAborted ? "aborted" : "input-available";
       return [
         {
           type: "tool-call",
@@ -7334,11 +7357,7 @@ function toSessionCtx(ctx) {
   if (ctx.sessionAuthority !== "workspace-scope") {
     return { workspaceId: ctx.workspaceId, userId: ctx.authSubject };
   }
-  const sessionCtx = { workspaceId: ctx.storageScope ?? ctx.workspaceId };
-  if (ctx.runtimeScopeIdentity) {
-    Object.assign(sessionCtx, { runtimeScopeIdentity: ctx.runtimeScopeIdentity });
-  }
-  return sessionCtx;
+  return { workspaceId: ctx.storageScope ?? ctx.workspaceId };
 }
 function liveAttachmentKey(sessionId, messageId, index) {
   return `${JSON.stringify(sessionId)}:${JSON.stringify(messageId)}:${index}`;
@@ -7591,6 +7610,7 @@ function assertUniqueRuntimeFilesystemBindings(bindings) {
 var MUTATION_CAPABILITY = {
   write: "write",
   writeBinary: "write",
+  createBinary: "write",
   delete: "delete",
   mkdir: "create-child"
 };
@@ -7611,6 +7631,7 @@ function intersectRuntimeFilesystemBinding(host, request) {
       ...request.operations,
       write: guarded(request.operations.write?.bind(request.operations), MUTATION_CAPABILITY.write),
       writeBinary: guarded(request.operations.writeBinary?.bind(request.operations), MUTATION_CAPABILITY.writeBinary),
+      createBinary: guarded(request.operations.createBinary?.bind(request.operations), MUTATION_CAPABILITY.createBinary),
       delete: guarded(request.operations.delete?.bind(request.operations), MUTATION_CAPABILITY.delete),
       mkdir: guarded(request.operations.mkdir?.bind(request.operations), MUTATION_CAPABILITY.mkdir),
       move: request.operations.move ? async (args) => {
@@ -7732,18 +7753,7 @@ var AgentSessionInventory = class {
   async resolveSessionRuntime(agentTypeId, scope, claim, sessionId) {
     const resolved = await this.resolveStore(agentTypeId, scope, claim);
     if (!resolved) return void 0;
-    try {
-      return {
-        runtimeScope: resolved.runtimeScope,
-        runtimeScopeIdentity: await resolved.store.readRuntimeScopeIdentity(
-          { workspaceId: claim.workspaceScopeId },
-          sessionId
-        )
-      };
-    } catch (error) {
-      if (error instanceof Error && error.message === `Session not found: ${sessionId}`) return void 0;
-      throw error;
-    }
+    return await resolved.store.has({ workspaceId: claim.workspaceScopeId }, sessionId) ? resolved.runtimeScope : void 0;
   }
   async resolveStore(agentTypeId, scope, claim) {
     const agent = this.compiledById.get(agentTypeId);
@@ -7931,7 +7941,7 @@ async function buildAgentComposition(input) {
     sessionNamespace: configuredNamespace,
     sessionDir: runtimeScope.sessionDir ?? factoryInput.sessionDir
   }) : async (factoryInput) => {
-    const { createPiCodingAgentHarness } = await import("./createHarness-5TEXLUYX.js");
+    const { createPiCodingAgentHarness } = await import("./createHarness-4Q6DQBRT.js");
     return createPiCodingAgentHarness({
       ...factoryInput,
       pi,
@@ -7973,7 +7983,6 @@ async function buildAgentComposition(input) {
     tools,
     runtimeBundle,
     readyTracker,
-    runtimeScopeIdentity: runtimeScope.identity,
     dispose() {
       disposed ??= service.dispose().finally(() => durableEventStore?.close());
       return disposed;
@@ -8059,13 +8068,12 @@ function gatewayError(dto) {
 function sessionTarget(ref) {
   return { kind: "session", ref };
 }
-function context(claim, requestId, runtimeScopeIdentity) {
+function context(claim, requestId) {
   return {
     workspaceId: claim.workspaceScopeId,
     storageScope: claim.workspaceScopeId,
     authSubject: claim.authSubjectId,
     sessionAuthority: "workspace-scope",
-    ...runtimeScopeIdentity ? { runtimeScopeIdentity } : {},
     requestId
   };
 }
@@ -8094,10 +8102,8 @@ var EmbeddedAgentGateway = class {
   runtime;
   cursorSecret = randomUUID2();
   connections = /* @__PURE__ */ new Set();
-  pins = /* @__PURE__ */ new Map();
-  unpinnedSessionFallbackPins = /* @__PURE__ */ new Set();
   writerTails = /* @__PURE__ */ new Map();
-  sessionRuntimeResolutionObserver;
+  knownSessions = /* @__PURE__ */ new Set();
   closed = false;
   /** Host-owned addressed runtime-capability effect seam. */
   async runHostEffect(input) {
@@ -8132,29 +8138,36 @@ var EmbeddedAgentGateway = class {
     const binding = await this.bindingForSession(scope, claim, ref);
     return { claim, binding };
   }
-  /** Side-effect-free reload lookup: validates persisted existence/pin and requires an already-published binding. */
+  /** Side-effect-free reload lookup: validates session access and requires the current binding to be published. */
   async inspectPublishedSessionBinding(scope, ref) {
     const claim = await this.verify(scope);
     if (!this.runtime.compiledById.has(ref.agentTypeId)) {
       throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     }
-    const authority = await this.runtime.resolveSessionRuntime(
+    const sessionKey = agentSessionKey(claim.workspaceScopeId, ref);
+    const persistedRuntime = await this.runtime.resolveSessionRuntime(
       ref.agentTypeId,
       scope,
       claim,
       ref.sessionId
     );
-    const cached = this.pins.get(agentSessionKey(claim.workspaceScopeId, ref));
-    if (!authority && !cached) {
+    if (!persistedRuntime && !this.knownSessions.has(sessionKey)) {
       throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     }
-    const runtimeScopeIdentity = authority?.runtimeScopeIdentity ?? cached ?? authority?.runtimeScope.identity;
-    const binding = this.runtime.findPublishedBinding(
+    const resolved = persistedRuntime ?? await this.runtime.resolveAgentRuntimeScope(
+      ref.agentTypeId,
+      scope,
+      claim,
+      "existing-session",
+      `session:${ref.sessionId}`,
+      ref.sessionId
+    );
+    const binding = this.runtime.findPublishedCurrentBinding(
       ref.agentTypeId,
       claim.workspaceScopeId,
-      runtimeScopeIdentity,
-      authority?.runtimeScope.physicalBindingIdentity ?? authority?.runtimeScope.identity,
-      authority?.runtimeScope.environment.provisioningFingerprint
+      resolved.physicalBindingIdentity ?? resolved.identity,
+      resolved.identity,
+      resolved.environment.provisioningFingerprint
     );
     if (!binding) {
       throw new AgentGatewayError(
@@ -8164,10 +8177,6 @@ var EmbeddedAgentGateway = class {
     }
     return { claim, binding };
   }
-  /** Server-only test observer for distinguishing runtime pin resolution paths. */
-  setSessionRuntimeResolutionObserverForTesting(observer) {
-    this.sessionRuntimeResolutionObserver = observer;
-  }
   /** Test-only activity seam used by the shared implementation conformance. */
   setActivityForTesting(workspaceScopeId, ref, activity) {
     this.runtime.activity.set(workspaceScopeId, ref, activity);
@@ -8234,31 +8243,31 @@ var EmbeddedAgentGateway = class {
         return await this.runtime.runBindingOperation(preparedBinding.key, async () => {
           if (input.resumeSessionId) {
             const candidateRef = { agentTypeId: input.agentTypeId, sessionId: input.resumeSessionId };
-            const authority = await this.runtime.resolveSessionRuntime(
+            const resolved = await this.runtime.resolveSessionRuntime(
               input.agentTypeId,
               input.scope,
               claim,
               input.resumeSessionId
             ).catch(() => void 0);
-            if (authority?.runtimeScopeIdentity === preparedBinding.scope.identity) {
+            if (resolved) {
               const rows = await preparedBinding.composition.service.listSessions?.(
-                context(claim, input.requestId, preparedBinding.scope.identity),
+                context(claim, input.requestId),
                 { includeId: input.resumeSessionId, includeEmpty: true }
               ) ?? [];
               const candidate = rows.find((row) => row.id === input.resumeSessionId);
               if (candidate?.turnCount === 0) {
-                this.pins.set(agentSessionKey(claim.workspaceScopeId, candidateRef), preparedBinding.scope.identity);
+                this.knownSessions.add(agentSessionKey(claim.workspaceScopeId, candidateRef));
                 this.runtime.activity.set(claim.workspaceScopeId, candidateRef, "idle");
                 return candidateRef;
               }
             }
           }
           const created = await preparedBinding.composition.service.createSession(
-            context(claim, input.requestId, preparedBinding.scope.identity),
+            context(claim, input.requestId),
             { title: input.title }
           );
           const ref = { agentTypeId: input.agentTypeId, sessionId: created.id };
-          this.pins.set(agentSessionKey(claim.workspaceScopeId, ref), preparedBinding.scope.identity);
+          this.knownSessions.add(agentSessionKey(claim.workspaceScopeId, ref));
           this.runtime.activity.set(claim.workspaceScopeId, ref, "idle");
           return ref;
         });
@@ -8276,13 +8285,13 @@ var EmbeddedAgentGateway = class {
     let state;
     try {
       state = await binding.composition.service.readState(
-        context(claim, randomUUID2(), binding.scope.identity),
+        context(claim, randomUUID2()),
         input.ref.sessionId
       );
     } catch {
       throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     }
-    const loaded = await this.loadSummary(binding.composition.service, claim, input.ref, binding.scope.identity);
+    const loaded = await this.loadSummary(binding.composition.service, claim, input.ref);
     const status = this.runtime.activity.get(claim.workspaceScopeId, input.ref);
     return {
       ref: input.ref,
@@ -8294,14 +8303,14 @@ var EmbeddedAgentGateway = class {
   async connectSession(input) {
     const claim = await this.verify(input.scope);
     const binding = await this.bindingForSession(input.scope, claim, input.ref);
-    await this.loadSummary(binding.composition.service, claim, input.ref, binding.scope.identity);
+    await this.loadSummary(binding.composition.service, claim, input.ref);
     const queue = new AgentSessionEventQueue();
     const initialCursor = input.cursor ?? (await binding.composition.service.readState(
-      context(claim, randomUUID2(), binding.scope.identity),
+      context(claim, randomUUID2()),
       input.ref.sessionId
     )).seq;
     const subscribed = await binding.composition.service.subscribe(
-      context(claim, randomUUID2(), binding.scope.identity),
+      context(claim, randomUUID2()),
       input.ref.sessionId,
       initialCursor,
       (event) => {
@@ -8349,7 +8358,7 @@ var EmbeddedAgentGateway = class {
         const currentBinding = await this.bindingForSession(input.scope, current, input.ref);
         return await this.sessionEffect(input.ref, current, "session.interrupt", requestId, {}, async () => {
           const receipt = await currentBinding.composition.service.interrupt(
-            context(current, requestId, currentBinding.scope.identity),
+            context(current, requestId),
             input.ref.sessionId,
             {}
           );
@@ -8364,7 +8373,7 @@ var EmbeddedAgentGateway = class {
         const currentBinding = await this.bindingForSession(input.scope, current, input.ref);
         return await this.sessionEffect(input.ref, current, "session.stop", requestId, {}, async () => {
           const receipt = await currentBinding.composition.service.stop(
-            context(current, requestId, currentBinding.scope.identity),
+            context(current, requestId),
             input.ref.sessionId,
             {}
           );
@@ -8379,7 +8388,7 @@ var EmbeddedAgentGateway = class {
           clientNonce: clientNonce ?? null,
           clientSeq: clientSeq ?? null
         }, () => currentBinding.composition.service.clearQueue(
-          context(current, requestId, currentBinding.scope.identity),
+          context(current, requestId),
           input.ref.sessionId,
           { ...clientNonce ? { clientNonce } : {}, ...clientSeq === void 0 ? {} : { clientSeq } }
         ), {
@@ -8389,7 +8398,6 @@ var EmbeddedAgentGateway = class {
               currentBinding.composition.service,
               current,
               input.ref,
-              currentBinding.scope.identity,
               requestId,
               clientNonce,
               clientSeq
@@ -8406,7 +8414,7 @@ var EmbeddedAgentGateway = class {
     const service = binding.composition.service;
     if (command.kind === "prompt") {
       return await this.sessionEffect(ref, claim, "session.prompt", command.requestId, command, async () => {
-        const receipt = await service.prompt(context(claim, command.requestId, binding.scope.identity), ref.sessionId, {
+        const receipt = await service.prompt(context(claim, command.requestId), ref.sessionId, {
           message: command.content,
           displayMessage: command.displayContent,
           clientNonce: command.clientNonce,
@@ -8430,7 +8438,7 @@ var EmbeddedAgentGateway = class {
       });
     }
     return await this.sessionEffect(ref, claim, "session.followup", command.requestId, command, async () => {
-      const receipt = await service.followUp(context(claim, command.requestId, binding.scope.identity), ref.sessionId, {
+      const receipt = await service.followUp(context(claim, command.requestId), ref.sessionId, {
         message: command.content,
         displayMessage: command.displayContent,
         clientNonce: command.clientNonce,
@@ -8464,7 +8472,7 @@ var EmbeddedAgentGateway = class {
     const binding = await this.bindingForSession(input.scope, claim, input.ref);
     await this.sessionEffect(input.ref, claim, "session.delete", input.requestId, {}, async () => {
       await binding.composition.service.deleteSession(
-        context(claim, input.requestId, binding.scope.identity),
+        context(claim, input.requestId),
         input.ref.sessionId
       );
       this.runtime.activity.delete(claim.workspaceScopeId, input.ref);
@@ -8481,18 +8489,17 @@ var EmbeddedAgentGateway = class {
     if (!this.runtime.compiledById.has(ref.agentTypeId)) {
       throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     }
-    const key = agentSessionKey(claim.workspaceScopeId, ref);
-    const authority = await this.runtime.resolveSessionRuntime(
+    const sessionKey = agentSessionKey(claim.workspaceScopeId, ref);
+    const persistedRuntime = await this.runtime.resolveSessionRuntime(
       ref.agentTypeId,
       scope,
       claim,
       ref.sessionId
     );
-    const cached = this.pins.get(key);
-    if (!authority && !cached) {
+    if (!persistedRuntime && !this.knownSessions.has(sessionKey)) {
       throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND, "session was not found");
     }
-    const resolved = authority?.runtimeScope ?? await this.runtime.resolveAgentRuntimeScope(
+    const currentRuntime = persistedRuntime ?? await this.runtime.resolveAgentRuntimeScope(
       ref.agentTypeId,
       scope,
       claim,
@@ -8500,45 +8507,11 @@ var EmbeddedAgentGateway = class {
       `session:${ref.sessionId}`,
       ref.sessionId
     );
-    const persistedPin = authority?.runtimeScopeIdentity;
-    const pinned = persistedPin ?? cached;
-    if (pinned && pinned !== resolved.identity) {
-      throw new AgentGatewayError(
-        AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH,
-        "session is pinned to a different runtime scope"
-      );
-    }
-    const publishedPinned = pinned && typeof this.runtime.findPublishedBinding === "function" ? this.runtime.findPublishedBinding(
-      ref.agentTypeId,
-      claim.workspaceScopeId,
-      pinned
-    ) : void 0;
-    if (publishedPinned && !this.unpinnedSessionFallbackPins.has(key)) {
-      this.sessionRuntimeResolutionObserver?.({
-        source: persistedPin ? "persisted-runtime-pin" : "unpinned-session-fallback",
-        runtimeScopeIdentity: pinned
-      });
-      this.pins.set(key, pinned);
-      return publishedPinned;
-    }
-    const runtimeScopeIdentity = pinned ?? resolved.identity;
-    this.sessionRuntimeResolutionObserver?.({
-      source: persistedPin ? "persisted-runtime-pin" : "unpinned-session-fallback",
-      runtimeScopeIdentity
-    });
-    this.pins.set(key, runtimeScopeIdentity);
-    if (!pinned) this.unpinnedSessionFallbackPins.add(key);
-    return await this.runtime.resolveBinding(
-      ref.agentTypeId,
-      scope,
-      claim,
-      resolved,
-      pinned ? "pinned" : "current"
-    );
+    return await this.runtime.resolveBinding(ref.agentTypeId, scope, claim, currentRuntime);
   }
-  async loadSummary(service, claim, ref, runtimeScopeIdentity) {
+  async loadSummary(service, claim, ref) {
     const list = await service.listSessions?.(
-      context(claim, randomUUID2(), runtimeScopeIdentity),
+      context(claim, randomUUID2()),
       { includeId: ref.sessionId, includeEmpty: true }
     ) ?? [];
     const summary = list.find((item) => item.id === ref.sessionId);
@@ -8758,7 +8731,7 @@ var EmbeddedAgentGateway = class {
   async promptAdmission(scope, claim, ref, requestId, requireIdle) {
     const binding = await this.bindingForSession(scope, claim, ref);
     const snapshot = await binding.composition.service.readState(
-      context(claim, requestId, binding.scope.identity),
+      context(claim, requestId),
       ref.sessionId
     );
     const admissible = requireIdle ? snapshot.status === "idle" : snapshot.status === "idle" || snapshot.status === "error";
@@ -8769,10 +8742,10 @@ var EmbeddedAgentGateway = class {
       { status: snapshot.status }
     ).toJSON();
   }
-  async queueClearAdmission(service, claim, ref, runtimeScopeIdentity, requestId, clientNonce, clientSeq) {
+  async queueClearAdmission(service, claim, ref, requestId, clientNonce, clientSeq) {
     if (clientNonce === void 0 || clientSeq === void 0) return void 0;
     const snapshot = await service.readState(
-      context(claim, requestId, runtimeScopeIdentity),
+      context(claim, requestId),
       ref.sessionId
     );
     const byNonce = snapshot.queue.followUps.find((item) => item.clientNonce === clientNonce);
@@ -9596,8 +9569,7 @@ function createAgentHostRuntimeCapabilityProjection(input) {
           requestId: request.id,
           userId: claim.authSubjectId,
           sessionCtx: {
-            workspaceId: claim.workspaceScopeId,
-            runtimeScopeIdentity: binding.scope.identity
+            workspaceId: claim.workspaceScopeId
           },
           ...typeof user?.email === "string" && user.email.trim() ? { userEmail: user.email.trim() } : {},
           userEmailVerified: user?.emailVerified === true
@@ -9659,8 +9631,7 @@ function createAgentHostRuntimeCapabilityProjection(input) {
             requestId,
             userId: scope.authSubjectId,
             sessionCtx: {
-              workspaceId: scope.workspaceScopeId,
-              runtimeScopeIdentity: binding.scope.identity
+              workspaceId: scope.workspaceScopeId
             }
           });
           return { ok: true, sessionId, name };
@@ -9817,7 +9788,7 @@ function body(schema, request, reply) {
 function statusFor(error) {
   if (error.code === AgentGatewayErrorCode.AGENT_SCOPE_DENIED) return 403;
   if (error.code === AgentGatewayErrorCode.AGENT_TYPE_UNKNOWN || error.code === AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND) return 404;
-  if (error.code === AgentGatewayErrorCode.AGENT_REQUEST_CONFLICT || error.code === AgentGatewayErrorCode.AGENT_REQUEST_IN_PROGRESS || error.code === AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN || error.code === AgentGatewayErrorCode.AGENT_RUNTIME_RESTART_REQUIRED || error.code === AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE || error.code === AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH) return 409;
+  if (error.code === AgentGatewayErrorCode.AGENT_REQUEST_CONFLICT || error.code === AgentGatewayErrorCode.AGENT_REQUEST_IN_PROGRESS || error.code === AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN || error.code === AgentGatewayErrorCode.AGENT_RUNTIME_RESTART_REQUIRED || error.code === AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE) return 409;
   if (error.code === AgentGatewayErrorCode.AGENT_GATEWAY_CLOSED) return 503;
   return 400;
 }
@@ -10117,7 +10088,7 @@ function parseWithSchema(schema, value, reply, scope) {
 function statusForGatewayError(code) {
   if (code === AgentGatewayErrorCode.AGENT_SCOPE_DENIED) return 403;
   if (code === AgentGatewayErrorCode.AGENT_SESSION_NOT_FOUND || code === AgentGatewayErrorCode.AGENT_TYPE_UNKNOWN) return 404;
-  if (code === AgentGatewayErrorCode.AGENT_REQUEST_CONFLICT || code === AgentGatewayErrorCode.AGENT_REQUEST_IN_PROGRESS || code === AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN || code === AgentGatewayErrorCode.AGENT_RUNTIME_RESTART_REQUIRED || code === AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE || code === AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH || code.includes("CURSOR") || code.includes("REPLAY")) return 409;
+  if (code === AgentGatewayErrorCode.AGENT_REQUEST_CONFLICT || code === AgentGatewayErrorCode.AGENT_REQUEST_IN_PROGRESS || code === AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN || code === AgentGatewayErrorCode.AGENT_RUNTIME_RESTART_REQUIRED || code === AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE || code.includes("CURSOR") || code.includes("REPLAY")) return 409;
   if (code === AgentGatewayErrorCode.AGENT_GATEWAY_CLOSED || code === AgentGatewayErrorCode.AGENT_SHARED_ENVIRONMENT_UNAVAILABLE) return 503;
   return 400;
 }
@@ -11312,7 +11283,6 @@ function createRuntime(options, compiledAgents) {
   );
   const activity = new AgentSessionActivityIndex();
   const bindings = /* @__PURE__ */ new Map();
-  const publishedBindings = /* @__PURE__ */ new Map();
   const publishedCurrentBindings = /* @__PURE__ */ new Map();
   const currentBindingReservations = /* @__PURE__ */ new Map();
   const nextBindingGeneration = /* @__PURE__ */ new Map();
@@ -11395,20 +11365,12 @@ function createRuntime(options, compiledAgents) {
     },
     async resolveSessionRuntime(agentTypeId, scope, claim, sessionId) {
       runtime.assertOpen();
-      try {
-        const authority = await inventory.resolveSessionRuntime(agentTypeId, scope, claim, sessionId);
-        if (!authority) return void 0;
-        validateResolvedRuntimeScope(authority.runtimeScope);
-        return authority;
-      } catch {
-        throw new AgentGatewayError(
-          AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH,
-          "session runtime scope metadata is unavailable"
-        );
-      }
+      const resolved = await inventory.resolveSessionRuntime(agentTypeId, scope, claim, sessionId);
+      if (resolved) validateResolvedRuntimeScope(resolved);
+      return resolved;
     },
     resolveAgentRuntimeScope,
-    async resolveBinding(agentTypeId, scope, claim, resolvedRuntimeScope, purpose = "current") {
+    async resolveBinding(agentTypeId, scope, claim, resolvedRuntimeScope) {
       runtime.assertOpen();
       const agent = compiledById.get(agentTypeId);
       if (!agent) throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_TYPE_UNKNOWN, "agent type is not available");
@@ -11429,7 +11391,7 @@ function createRuntime(options, compiledAgents) {
       ]);
       const physicalBindingIdentity = resolved.physicalBindingIdentity ?? resolved.identity;
       const currentKey = JSON.stringify([agentTypeId, claim.workspaceScopeId, physicalBindingIdentity]);
-      const useCanonicalCurrent = purpose === "current" && options.resolveAuthorizedAgentRuntimeScope !== void 0;
+      const useCanonicalCurrent = options.resolveAuthorizedAgentRuntimeScope !== void 0;
       if (useCanonicalCurrent) {
         const current = publishedCurrentBindings.get(currentKey);
         if (current) return current;
@@ -11481,7 +11443,6 @@ function createRuntime(options, compiledAgents) {
               await disposeBinding(binding2);
               throw new AgentGatewayError(AgentGatewayErrorCode.AGENT_GATEWAY_CLOSED, "agent host is closing");
             }
-            publishedBindings.set(key, binding2);
             if (useCanonicalCurrent && currentBindingReservations.get(currentKey) === key && !publishedCurrentBindings.has(currentKey)) {
               publishedCurrentBindings.set(currentKey, binding2);
               currentBindingReservations.delete(currentKey);
@@ -11514,18 +11475,14 @@ function createRuntime(options, compiledAgents) {
       }
       return binding;
     },
-    findPublishedBinding(agentTypeId, workspaceScopeId, runtimeScopeIdentity, physicalBindingIdentity, provisioningFingerprint) {
-      const matches = [...publishedBindings.values()].filter((binding) => binding.agentTypeId === agentTypeId && binding.workspaceScopeId === workspaceScopeId && (!runtimeScopeIdentity || binding.scope.identity === runtimeScopeIdentity) && (!physicalBindingIdentity || (binding.scope.physicalBindingIdentity ?? binding.scope.identity) === physicalBindingIdentity) && (!provisioningFingerprint || binding.scope.environment.provisioningFingerprint === provisioningFingerprint));
-      return matches.length === 1 ? matches[0] : void 0;
-    },
-    findPublishedCurrentBinding(agentTypeId, workspaceScopeId, physicalBindingIdentity, runtimeScopeIdentity, provisioningFingerprint) {
+    findPublishedCurrentBinding(agentTypeId, workspaceScopeId, physicalBindingIdentity, bindingIdentity, provisioningFingerprint) {
       const exact = publishedCurrentBindings.get(JSON.stringify([
         agentTypeId,
         workspaceScopeId,
         physicalBindingIdentity
       ]));
       if (exact) return exact;
-      const matches = [...publishedCurrentBindings.values()].filter((binding) => binding.agentTypeId === agentTypeId && binding.workspaceScopeId === workspaceScopeId && (!runtimeScopeIdentity || binding.scope.identity === runtimeScopeIdentity) && (!provisioningFingerprint || binding.scope.environment.provisioningFingerprint === provisioningFingerprint));
+      const matches = [...publishedCurrentBindings.values()].filter((binding) => binding.agentTypeId === agentTypeId && binding.workspaceScopeId === workspaceScopeId && (!bindingIdentity || binding.scope.identity === bindingIdentity) && (!provisioningFingerprint || binding.scope.environment.provisioningFingerprint === provisioningFingerprint));
       return matches.length === 1 ? matches[0] : void 0;
     },
     startDrain() {
@@ -11634,7 +11591,6 @@ function createRuntime(options, compiledAgents) {
         }
         const resolvedBindings = await Promise.allSettled([...bindings.values()]);
         bindings.clear();
-        publishedBindings.clear();
         publishedCurrentBindings.clear();
         nextBindingGeneration.clear();
         currentBindingReservations.clear();
@@ -12138,7 +12094,7 @@ import { lstat as lstat4, open as open2, opendir, realpath as realpath5, stat as
 import { homedir as homedir2 } from "node:os";
 import { dirname as dirname8, isAbsolute as isAbsolute7, join as join9, parse, relative as relative9, resolve as resolve8, sep as sep8 } from "node:path";
 import { fileURLToPath as fileURLToPath7 } from "node:url";
-import { DefaultPackageManager as DefaultPackageManager2, getAgentDir as getAgentDir2 } from "@mariozechner/pi-coding-agent";
+import { DefaultPackageManager as DefaultPackageManager2, getAgentDir as getAgentDir2, loadProjectContextFiles } from "@mariozechner/pi-coding-agent";
 var DEFAULT_PI_RESOURCE_DIGEST_LIMITS = Object.freeze({
   maxDepth: 32,
   maxFiles: 1e4,
@@ -12150,11 +12106,13 @@ function createPiResourceDigestInput(input) {
   const piAgentDir = resolvePiPath(input.piAgentDir ?? getAgentDir2(), process.cwd());
   const piUserHome = resolvePiPath(input.piUserHome ?? homedir2(), process.cwd());
   const noSkills = input.noSkills ?? true;
+  const noContextFiles = input.noContextFiles ?? true;
   return {
     piCwd,
     piAgentDir,
     piUserHome,
     noSkills,
+    noContextFiles,
     promptParts: input.resourceSets.flatMap((set) => set.promptParts ?? []),
     additionalSkillPaths: uniqueStrings(input.resourceSets.flatMap((set) => set.additionalSkillPaths ?? [])),
     packages: compactPiPackages(input.resourceSets.flatMap((set) => set.packages ?? [])),
@@ -12168,7 +12126,7 @@ function createPiResourceDigestInput(input) {
     ...input.limits ? { limits: input.limits } : {}
   };
 }
-var FORMAT_VERSION = "boring-pi-resource-digest-v4";
+var FORMAT_VERSION = "boring-pi-resource-digest-v5";
 var EXCLUDED_DIRECTORIES = /* @__PURE__ */ new Set([".git", "node_modules"]);
 var EXCLUDED_FILES = /* @__PURE__ */ new Set([".boring-signature.json"]);
 async function digestPiResourceInputs(input) {
@@ -12177,6 +12135,7 @@ async function digestPiResourceInputs(input) {
   const piAgentDir = resolvePiPath(input.piAgentDir, process.cwd());
   const piUserHome = resolvePiPath(input.piUserHome, process.cwd());
   const projectSettingsDir = join9(piCwd, ".pi");
+  const noContextFiles = input.noContextFiles ?? true;
   const authorizedRoots = [...new Set(input.authorizedRoots.map((path) => resolvePiPath(path, piCwd)))];
   if (authorizedRoots.length === 0) {
     throw stableError(ErrorCode.enum.CONFIG_INVALID, 400, "Pi resource digest requires at least one independently authorized root");
@@ -12188,8 +12147,28 @@ async function digestPiResourceInputs(input) {
   frameString(hash, "project-settings-dir", projectSettingsDir);
   frameString(hash, "user-agent-dir", piAgentDir);
   frameString(hash, "user-home", piUserHome);
+  frameString(hash, "context-policy", noContextFiles ? "sealed" : "ambient");
   const promptText = (input.promptParts ?? []).map((part) => part?.trim()).filter((part) => Boolean(part)).join("\n\n");
   frameString(hash, "prompt", promptText);
+  if (!noContextFiles) {
+    const contextFiles = loadProjectContextFiles({ cwd: piCwd, agentDir: piAgentDir });
+    for (const contextFile of contextFiles) {
+      const bytes = Buffer.byteLength(contextFile.content);
+      state.nodes += 1;
+      if (state.nodes > state.limits.maxFiles) {
+        throw limitError(`Pi resource tree exceeds maximum node count ${state.limits.maxFiles}`);
+      }
+      if (bytes > state.limits.maxFileBytes) {
+        throw limitError(`Pi context file exceeds maximum bytes ${state.limits.maxFileBytes}: ${contextFile.path}`);
+      }
+      if (state.bytes + bytes > state.limits.maxTotalBytes) {
+        throw limitError(`Pi resource tree exceeds maximum total bytes ${state.limits.maxTotalBytes}`);
+      }
+      frameString(hash, "context-path", contextFile.path);
+      frameString(hash, "context-content", contextFile.content);
+      state.bytes += bytes;
+    }
+  }
   await hashResourceCollection(state, piCwd, "settings", [
     join9(projectSettingsDir, "settings.json"),
     join9(piAgentDir, "settings.json")
@@ -12633,6 +12612,7 @@ async function createStandaloneAgentHostApp(options = {}) {
           return createPiResourceDigestInput({
             piCwd: workspaceRoot,
             noSkills: pi.noSkills,
+            noContextFiles: pi.noContextFiles,
             resourceSets: [{
               promptParts: [
                 options.systemPromptAppend,
@@ -13123,6 +13103,14 @@ function createUserFilesystemBinding(workspace, policy, resolvePolicyPath) {
         const stat7 = await workspace.stat(target);
         return { mtimeMs: stat7.kind === "file" ? stat7.mtimeMs : void 0 };
       },
+      ...workspace.createBinaryFile ? {
+        async createBinary({ path, content }) {
+          await requireCapability(path, "write");
+          const target = workspacePath(workspace, path);
+          await workspace.createBinaryFile(target, content);
+          return {};
+        }
+      } : {},
       async delete({ path }) {
         await requireCapability(path, "delete");
         await workspace.unlink(workspacePath(workspace, path));
@@ -13508,6 +13496,7 @@ export {
   resolveWorkspaceRoot,
   REMOTE_WORKER_RUNTIME_CWD,
   REMOTE_WORKER_PROVIDER,
+  REMOTE_WORKER_EXCLUSIVE_BINARY_CREATE_CAPABILITY,
   WORKER_INTERNAL_TOKEN_HEADER,
   WORKER_WORKSPACE_ID_HEADER,
   WORKER_REQUEST_ID_HEADER,