@hachej/boring-agent 0.1.99 → 0.1.101

package/dist/{chunk-GRMDMWBW.js → chunk-T37OVD6L.js}

@@ -603,7 +603,7 @@ var PiSessionStore = class {
   sessionDir;
   allowLegacyUnscopedAccess;
   pathDerivedLegacyAccess;
-  trustedNativeRuntimeScopeIdentity;
+  allowUnscopedNativeAccess;
   prefixCache = /* @__PURE__ */ new Map();
   listInFlight = /* @__PURE__ */ new Map();
   writerTails = /* @__PURE__ */ new Map();
@@ -613,25 +613,25 @@ var PiSessionStore = class {
       this.sessionDir = options;
       this.allowLegacyUnscopedAccess = true;
       this.pathDerivedLegacyAccess = false;
-      this.trustedNativeRuntimeScopeIdentity = void 0;
+      this.allowUnscopedNativeAccess = false;
       return;
     }
     this.allowLegacyUnscopedAccess = true;
     this.pathDerivedLegacyAccess = options?.sessionDir === void 0 && options?.sessionNamespace === void 0;
-    this.trustedNativeRuntimeScopeIdentity = options?.trustedNativeRuntimeScopeIdentity?.trim() || void 0;
+    this.allowUnscopedNativeAccess = options?.allowUnscopedNativeAccess === true;
     this.sessionDir = options?.sessionDir ?? (options?.sessionNamespace ? sessionDirForNamespace(options.sessionNamespace, options.sessionRoot) : defaultSessionDir(options?.storageCwd ?? cwd, options?.sessionRoot));
   }
   getSessionDir() {
     return this.sessionDir;
   }
-  /** Reads the Host execution pin from authoritative session metadata. */
-  async readRuntimeScopeIdentity(ctx, sessionId) {
-    const filepath = await this.resolveSessionFile(sessionId, ctx);
-    const entries = parseJsonlPrefixEntries2(await readJsonlPrefix2(filepath));
-    const header = entries.find((entry) => entry.type === "session");
-    const directNative = isTimestampNamedPiSessionFile(filepath, header?.id ?? sessionId);
-    if (!this.headerBelongsToCtx(header, ctx, directNative)) throw new Error(`Session not found: ${sessionId}`);
-    return readHeaderRuntimeScopeIdentity(header);
+  async has(ctx, sessionId) {
+    try {
+      await this.resolveSessionFile(sessionId, ctx);
+      return true;
+    } catch (error) {
+      if (error instanceof Error && error.message === `Session not found: ${sessionId}`) return false;
+      throw error;
+    }
   }
   async list(ctx, options) {
     const normalizedOptions = normalizeListOptions(options);
@@ -999,7 +999,7 @@ var PiSessionStore = class {
       if (ctx) await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
       return matchedPath;
     }
-    if (ctx && (this.pathDerivedLegacyAccess || this.hasTrustedNativeRuntimeCapability(ctx) || await this.nativeFilePin(matchedPath) !== null)) {
+    if (ctx && (this.pathDerivedLegacyAccess || this.allowUnscopedNativeAccess || await this.nativeFilePin(matchedPath) !== null)) {
       await this.assertFileBelongsToCtx(matchedPath, ctx, sessionId);
       return matchedPath;
     }
@@ -1284,22 +1284,16 @@ var PiSessionStore = class {
   }
   /**
    * A bare Pi transcript carries no tenancy, so only a path-derived trusted
-   * local store may reach it. Boring-created native transcripts carry an exact
-   * persisted tenancy/runtime pin and remain reachable by hosted/namespaced
-   * stores without minting a compatibility wrapper.
+   * local store may reach it. Boring-created native transcripts carry exact
+   * persisted tenancy and remain reachable by hosted/namespaced stores without
+   * minting a compatibility wrapper.
    */
   nativeFileBelongsToCtx(header, ctx) {
     const pinned = readHeaderSessionCtx(header);
-    if (pinned === null && this.hasTrustedNativeRuntimeCapability(ctx)) return true;
+    if (pinned === null && this.allowUnscopedNativeAccess) return true;
     if (this.pathDerivedLegacyAccess) return this.storedCtxBelongsToCtx(pinned, ctx);
     return pinned !== null && sameSessionCtx(pinned, ctx);
   }
-  hasTrustedNativeRuntimeCapability(ctx) {
-    const runtimeScopeIdentity = ctx.runtimeScopeIdentity?.trim();
-    return Boolean(
-      runtimeScopeIdentity && this.trustedNativeRuntimeScopeIdentity && runtimeScopeIdentity === this.trustedNativeRuntimeScopeIdentity
-    );
-  }
   /** The Boring tenancy pin on a native transcript, or null when unpinned. */
   async nativeFilePin(filepath) {
     try {
@@ -1368,19 +1362,11 @@ function readHeaderSessionCtx(header) {
   if (!raw || typeof raw !== "object") return {};
   return normalizeSessionCtx(raw) ?? {};
 }
-function readHeaderRuntimeScopeIdentity(header) {
-  const raw = header?.boringSessionCtx?.runtimeScopeIdentity;
-  if (raw === void 0) return void 0;
-  if (typeof raw !== "string" || !raw.trim()) throw new Error("Session runtime scope identity is invalid");
-  return raw;
-}
 function normalizeSessionCtx(ctx) {
-  const runtimeScopeIdentity = typeof ctx?.runtimeScopeIdentity === "string" && ctx.runtimeScopeIdentity.trim() ? ctx.runtimeScopeIdentity : "";
-  if (!ctx?.workspaceId && !ctx?.userId && !runtimeScopeIdentity) return void 0;
+  if (!ctx?.workspaceId && !ctx?.userId) return void 0;
   return {
-    ...ctx?.workspaceId ? { workspaceId: ctx.workspaceId } : {},
-    ...ctx?.userId ? { userId: ctx.userId } : {},
-    ...runtimeScopeIdentity ? { runtimeScopeIdentity } : {}
+    ...ctx.workspaceId ? { workspaceId: ctx.workspaceId } : {},
+    ...ctx.userId ? { userId: ctx.userId } : {}
   };
 }
 function sameSessionCtx(a, b) {
@@ -1928,14 +1914,11 @@ function sessionCtxFromRunContext(ctx) {
   return normalizeSessionCtx2(ctx.sessionCtx ?? { workspaceId: ctx.workspaceId }) ?? {};
 }
 function normalizeSessionCtx2(ctx) {
-  if (!ctx?.workspaceId && !ctx?.runtimeScopeIdentity) return void 0;
-  return {
-    ...ctx.workspaceId ? { workspaceId: ctx.workspaceId } : {},
-    ...ctx.runtimeScopeIdentity ? { runtimeScopeIdentity: ctx.runtimeScopeIdentity } : {}
-  };
+  if (!ctx?.workspaceId) return void 0;
+  return { workspaceId: ctx.workspaceId };
 }
 function sessionCacheKey(sessionId, ctx) {
-  return JSON.stringify([sessionId, ctx.workspaceId ?? "", ctx.runtimeScopeIdentity ?? ""]);
+  return JSON.stringify([sessionId, ctx.workspaceId ?? ""]);
 }
 async function applyRequestedSessionOptions(handle, input, options = {}) {
   const requestedModel = resolveRequestedModel(handle.modelRegistry, input, { strict: options.strictModelResolution });

package/dist/{chunk-LSO2AO6Q.js → chunk-XCZBICZS.js}

@@ -47,7 +47,6 @@ var AgentGatewayErrorCode = {
   AGENT_REQUEST_OUTCOME_UNKNOWN: "AGENT_REQUEST_OUTCOME_UNKNOWN",
   AGENT_RUNTIME_RESTART_REQUIRED: "AGENT_RUNTIME_RESTART_REQUIRED",
   AGENT_COMMAND_INVALID_STATE: "AGENT_COMMAND_INVALID_STATE",
-  AGENT_SESSION_RUNTIME_SCOPE_MISMATCH: "AGENT_SESSION_RUNTIME_SCOPE_MISMATCH",
   AGENT_SHARED_ENVIRONMENT_UNAVAILABLE: "AGENT_SHARED_ENVIRONMENT_UNAVAILABLE",
   AGENT_GATEWAY_CLOSED: "AGENT_GATEWAY_CLOSED"
 };
@@ -64,7 +63,6 @@ var AGENT_GATEWAY_ERROR_CODES = [
   AgentGatewayErrorCode.AGENT_REQUEST_OUTCOME_UNKNOWN,
   AgentGatewayErrorCode.AGENT_RUNTIME_RESTART_REQUIRED,
   AgentGatewayErrorCode.AGENT_COMMAND_INVALID_STATE,
-  AgentGatewayErrorCode.AGENT_SESSION_RUNTIME_SCOPE_MISMATCH,
   AgentGatewayErrorCode.AGENT_SHARED_ENVIRONMENT_UNAVAILABLE,
   AgentGatewayErrorCode.AGENT_GATEWAY_CLOSED
 ];

package/dist/{chunk-ZOHN72OS.js → chunk-XTMY3PWI.js}

@@ -7,7 +7,7 @@ import {
   readConfiguredDefaultModel,
   registerConfiguredModelProviders,
   withPiHarnessDefaults
-} from "./chunk-GRMDMWBW.js";
+} from "./chunk-T37OVD6L.js";
 import {
   AGENT_KNOWLEDGE_FILESYSTEM_ID,
   AgentDefinitionValidationError,
@@ -41,7 +41,7 @@ import {
   AgentGatewayErrorCode,
   extractToolUiMetadata,
   sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "./chunk-LSO2AO6Q.js";
+} from "./chunk-XCZBICZS.js";
 import {
   AgentDefinitionErrorCode,
   AgentDeploymentErrorCode,
@@ -7334,11 +7334,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}`;
@@ -7732,18 +7728,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 +7916,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-7C2A5UVH.js");
     return createPiCodingAgentHarness({
       ...factoryInput,
       pi,
@@ -7973,7 +7958,6 @@ async function buildAgentComposition(input) {
     tools,
     runtimeBundle,
     readyTracker,
-    runtimeScopeIdentity: runtimeScope.identity,
     dispose() {
       disposed ??= service.dispose().finally(() => durableEventStore?.close());
       return disposed;
@@ -8059,13 +8043,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 +8077,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 +8113,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 +8152,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 +8218,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 +8260,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 +8278,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 +8333,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 +8348,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 +8363,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 +8373,6 @@ var EmbeddedAgentGateway = class {
               currentBinding.composition.service,
               current,
               input.ref,
-              currentBinding.scope.identity,
               requestId,
               clientNonce,
               clientSeq
@@ -8406,7 +8389,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 +8413,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 +8447,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 +8464,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 +8482,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 +8706,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 +8717,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 +9544,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 +9606,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 +9763,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 +10063,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 +11258,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 +11340,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 +11366,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 +11418,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 +11450,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 +11566,6 @@ function createRuntime(options, compiledAgents) {
         }
         const resolvedBindings = await Promise.allSettled([...bindings.values()]);
         bindings.clear();
-        publishedBindings.clear();
         publishedCurrentBindings.clear();
         nextBindingGeneration.clear();
         currentBindingReservations.clear();

package/dist/core/index.d.ts

@@ -1,8 +1,8 @@
-import { A as AgentHarness, a as AgentReadiness, b as Agent } from '../harness-DS8jLKIx.js';
-export { c as AGENT_NOT_IMPLEMENTED_UNTIL_T1, d as AgentActor, e as AgentCoreHarness, f as AgentCoreHarnessFactory, g as AgentCorePromptInput, h as AgentCoreSessionAdapter, i as AgentCoreSessionSnapshot, j as AgentEvent, k as AgentMessageContent, l as AgentMessagePart, m as AgentNotImplementedError, n as AgentReadinessStatus, o as AgentResolveInputResponse, p as AgentSendInput, q as AgentStartReceipt, r as AgentStreamOptions } from '../harness-DS8jLKIx.js';
-import { S as SessionStore } from '../piChatEvent-B3ehh9V0.js';
-import { A as AgentCoreSessionService, a as AgentEffectAdmission } from '../piChatSessionService-xnv8rcdh.js';
-export { b as AGENT_EFFECT_METHODS, c as AgentEffectAdmissionError, P as PiChatEventStreamResult, d as PiChatEventStreamSubscription, e as PiChatEventSubscriber, f as PiChatReplayRangeError, g as PiChatSessionService, h as PiSessionCreateInit, i as PiSessionRequestContext, w as withAgentEffectAdmission } from '../piChatSessionService-xnv8rcdh.js';
+import { A as AgentHarness, a as AgentReadiness, b as Agent } from '../harness-s-kEgJkK.js';
+export { c as AGENT_NOT_IMPLEMENTED_UNTIL_T1, d as AgentActor, e as AgentCoreHarness, f as AgentCoreHarnessFactory, g as AgentCorePromptInput, h as AgentCoreSessionAdapter, i as AgentCoreSessionSnapshot, j as AgentEvent, k as AgentMessageContent, l as AgentMessagePart, m as AgentNotImplementedError, n as AgentReadinessStatus, o as AgentResolveInputResponse, p as AgentSendInput, q as AgentStartReceipt, r as AgentStreamOptions } from '../harness-s-kEgJkK.js';
+import { S as SessionStore } from '../piChatEvent-Bzof4IEy.js';
+import { A as AgentCoreSessionService, a as AgentEffectAdmission } from '../piChatSessionService-BU4L5hxM.js';
+export { b as AGENT_EFFECT_METHODS, c as AgentEffectAdmissionError, P as PiChatEventStreamResult, d as PiChatEventStreamSubscription, e as PiChatEventSubscriber, f as PiChatReplayRangeError, g as PiChatSessionService, h as PiSessionCreateInit, i as PiSessionRequestContext, w as withAgentEffectAdmission } from '../piChatSessionService-BU4L5hxM.js';
 import '@mariozechner/pi-coding-agent';
 import 'zod';
 

package/dist/{createHarness-5TEXLUYX.js → createHarness-7C2A5UVH.js}

@@ -5,7 +5,7 @@ import {
   mergePiPackageSources,
   projectSkillResourceLocations,
   withPiHarnessDefaults
-} from "./chunk-GRMDMWBW.js";
+} from "./chunk-T37OVD6L.js";
 import "./chunk-4IQ4HHBG.js";
 import "./chunk-VXF5DWS6.js";
 export {