@hachej/boring-agent 0.1.83 → 0.1.85

package/dist/{chunk-DC3S7SZG.js → chunk-6O5ADR57.js}

@@ -1,6 +1,6 @@
 import {
   ErrorCode
-} from "./chunk-PG2WOJ22.js";
+} from "./chunk-HDIRWHJB.js";
 
 // src/shared/tool-ui.ts
 function isRecord(value) {

package/dist/{chunk-PG2WOJ22.js → chunk-HDIRWHJB.js}

@@ -73,6 +73,9 @@ var ErrorCode = z.enum([
   "PROVISIONING_UV_BOOTSTRAP_FAILED",
   "PROVISIONING_UV_INSTALL_FAILED",
   "PROVISIONING_ARTIFACT_FAILED",
+  // Lane W same-workspace share deep-link (AR1-003)
+  "AR1_SHARE_NOT_FOUND",
+  "AR1_SHARE_TOMBSTONED",
   // Internal
   "ERR_NOT_IMPLEMENTED_UNTIL_T1",
   "INTERNAL_ERROR"
@@ -90,7 +93,8 @@ var AgentConsumptionErrorCode = z.enum([
   "AGENT_CONSUMPTION_INVALID_TRANSITION",
   "AGENT_CONSUMPTION_CYCLE_DETECTED",
   "AGENT_CONSUMPTION_DEPTH_EXCEEDED",
-  "AGENT_CONSUMPTION_SCHEMA_MISMATCH"
+  "AGENT_CONSUMPTION_SCHEMA_MISMATCH",
+  "AGENT_CONSUMPTION_LEGACY_ARTIFACT_REJECTED"
 ]);
 var ApiErrorPayloadSchema = z.object({
   code: ErrorCode,

package/dist/{chunk-7V3E6KHX.js → chunk-HY7EERLW.js}

@@ -3,18 +3,21 @@ import {
   AgentDeploymentValidationError,
   OpaqueRefSchema,
   Sha256DigestSchema,
+  ShareEntryErrorCode,
   canonicalStringify,
   createAgentAssetDigest,
   createAgentDefinitionDigest,
   createAgentDeploymentDigest,
+  resolveShareEntry,
   sha256Bytes,
   validateAgentDefinition,
   validateAgentDeployment,
   validateTool
-} from "./chunk-WODTQBXR.js";
+} from "./chunk-YONTHCD7.js";
 import {
+  AgentEffectAdmissionError,
   createAgentRuntimeBridge
-} from "./chunk-TNN3LPXE.js";
+} from "./chunk-LYBTHR7J.js";
 import {
   sessionStreamPath
 } from "./chunk-WSQ5QNIY.js";
@@ -29,7 +32,7 @@ import {
   StopReceiptSchema,
   extractToolUiMetadata,
   sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "./chunk-DC3S7SZG.js";
+} from "./chunk-6O5ADR57.js";
 import {
   createLogger,
   createPiCodingAgentHarness,
@@ -40,7 +43,7 @@ import {
   registerConfiguredModelProviders,
   setEnvDefault,
   withPiHarnessDefaults
-} from "./chunk-5NAN3TAR.js";
+} from "./chunk-ZUDWQAAB.js";
 import {
   safeCapture
 } from "./chunk-AQBXNPMD.js";
@@ -48,7 +51,7 @@ import {
   AgentDefinitionErrorCode,
   AgentDeploymentErrorCode,
   ErrorCode
-} from "./chunk-PG2WOJ22.js";
+} from "./chunk-HDIRWHJB.js";
 
 // src/server/sandbox/direct/createDirectSandbox.ts
 import { spawn } from "child_process";
@@ -7309,6 +7312,19 @@ var PiChatMeteringCoordinator = class {
     if (run2) this.release(run2, "run-rejected");
     this.pruneSession(stateKey, state);
   }
+  /**
+   * Mark the currently-active run as voluntarily user-stopped (the /stop button),
+   * so its terminal accounting RELEASES the hold instead of charging the fallback.
+   * Must be called before the abort so the flag is set when the native aborted
+   * agent-end is observed. Runs with real usage recorded before the stop still
+   * settle that usage; only the unused remainder of the hold is released. No-op if
+   * there is no active run (e.g. the stop landed before agent-start — releasePending
+   * handles that case).
+   */
+  markActiveStopped(sessionId) {
+    const active = this.sessions.get(sessionId)?.active;
+    if (active && !active.terminal) active.userStopped = true;
+  }
   /**
    * Release prompt runs reserved but not yet bound to an agent-start —
    * e.g. a stop/interrupt landing in the window between acceptance and the
@@ -7494,6 +7510,7 @@ var PiChatMeteringCoordinator = class {
       recordedMessageIds: /* @__PURE__ */ new Set(),
       lastIdlessUsageKey: void 0,
       usageWriteFailed: false,
+      userStopped: false,
       reservation: Promise.resolve(),
       terminal: false,
       ops: Promise.resolve()
@@ -7535,7 +7552,7 @@ var PiChatMeteringCoordinator = class {
         if (run2.billableUsageCount > 0) {
           return this.sink.settleRun({ ...run2.scope, reservationId: run2.reservationId, status });
         }
-        const didPaidWork = status === "ok";
+        const didPaidWork = status === "ok" && !run2.userStopped;
         if (didPaidWork) {
           return this.sink.releaseRun({ ...run2.scope, reservationId: run2.reservationId, reason: "fallback-hold-charge" });
         }
@@ -7987,6 +8004,7 @@ var HarnessPiChatService = class {
     const sessionKey = this.sessionKey(ctx, sessionId);
     const adapter = await this.getAdapter(ctx, sessionId, "");
     const clearedQueue = this.clearAllFollowUps(adapter, sessionId, sessionKey);
+    this.metering?.markActiveStopped(sessionKey);
     this.metering?.releaseQueued(sessionKey);
     this.metering?.releasePending(sessionKey);
     await adapter.abort();
@@ -8479,12 +8497,13 @@ function createAgentRuntimeBridge2(config, options = {}) {
   }
   return createAgentRuntimeBridge({
     runtimeFactory: () => createRuntime(config, options),
+    admitEffect: options.service?.admitEffect,
     readiness: config.readiness,
     readinessRequirements: config.readinessRequirements
   });
 }
 async function createRuntime(config, options) {
-  const harnessFactory = config.harnessFactory ?? (await import("./createHarness-TGBJZISM.js")).createPiCodingAgentHarness;
+  const harnessFactory = config.harnessFactory ?? (await import("./createHarness-MJ5GEL6J.js")).createPiCodingAgentHarness;
   const harnessInput = {
     tools: config.tools ?? [],
     cwd: config.workdir ?? DEFAULT_WORKDIR,
@@ -9496,6 +9515,166 @@ function sameSessionCtx(a, b) {
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 import { z as z2 } from "zod";
+
+// src/server/mcp/shareEntryResources.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+var MAX_SHARE_READ_BYTES = 256 * 1024;
+var SHARE_RESOURCE_URI_TEMPLATE = "share:///{id}";
+var strictUtf8Decoder2 = new TextDecoder("utf-8", { fatal: true });
+function shareResourceUri(id) {
+  return `share:///${encodeURIComponent(id)}`;
+}
+function registerShareEntryResources(server, options) {
+  const template = new ResourceTemplate(SHARE_RESOURCE_URI_TEMPLATE, {
+    list: async (extra) => listShareResources(options, requestContextFromResourceExtra(extra))
+  });
+  const readCallback = async (uri, variables, extra) => readShareResource(options, variables.id, requestContextFromResourceExtra(extra));
+  server.registerResource(
+    "share",
+    template,
+    {
+      title: "Lane W share entry",
+      description: "Same-workspace shareable file reference (AR1). Resolves live, never a blob snapshot."
+    },
+    readCallback
+  );
+}
+function requestContextFromResourceExtra(extra) {
+  return {
+    sessionId: extra?.sessionId,
+    authInfo: extra?.authInfo
+  };
+}
+async function listShareResources(options, request) {
+  const ctx = await options.resolveSessionCtx(request);
+  if (!ctx.workspaceId) return { resources: [] };
+  const entries = await options.store.list(ctx.workspaceId);
+  return {
+    resources: entries.map((entry) => ({
+      uri: shareResourceUri(entry.id),
+      name: entry.id
+    }))
+  };
+}
+async function readShareResource(options, rawId, request) {
+  const id = typeof rawId === "string" ? rawId : Array.isArray(rawId) ? rawId[0] : void 0;
+  if (!id) return notFoundResult(shareResourceUri(""));
+  const uri = shareResourceUri(id);
+  const ctx = await options.resolveSessionCtx(request);
+  if (!ctx.workspaceId) return notFoundResult(uri);
+  const entry = await options.store.get(id);
+  if (!entry || entry.workspaceId !== ctx.workspaceId) {
+    return notFoundResult(uri);
+  }
+  const workspace = await options.resolveWorkspace(ctx);
+  const resolution = await resolveShareEntry(options.store, id, workspace);
+  if (resolution.status === "not_found") return notFoundResult(uri);
+  if (resolution.status === "tombstoned") {
+    return tombstoneResult(uri, resolution.tombstone);
+  }
+  return readShareEntryContents(uri, resolution.entry, workspace);
+}
+function notFoundResult(uri) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify({
+          status: "not_found",
+          error: { code: ErrorCode.enum.AR1_SHARE_NOT_FOUND, message: "share not found" }
+        })
+      }
+    ]
+  };
+}
+function tombstoneResult(uri, tombstone) {
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "application/json",
+        text: JSON.stringify({
+          status: "tombstoned",
+          error: { code: ErrorCode.enum.AR1_SHARE_TOMBSTONED, message: "share target is gone" },
+          id: tombstone.id,
+          workspaceId: tombstone.workspaceId,
+          provenance: tombstone.provenance
+        })
+      }
+    ]
+  };
+}
+async function readShareEntryContents(uri, entry, workspace) {
+  const before = await statShareTarget(workspace, entry.path);
+  assertShareTargetStat(before);
+  assertWithinCap(before.size);
+  if (!workspace.readBinaryFile) {
+    throw new ManagedAgentMcpError(
+      ErrorCode.enum.MCP_AGENT_ARTIFACT_UNAVAILABLE,
+      "share target bytes are unavailable through the authorized workspace"
+    );
+  }
+  const bytes = await workspace.readBinaryFile(entry.path);
+  const after = await statShareTarget(workspace, entry.path);
+  assertShareTargetStat(after);
+  if (!sameStat2(before, after) || bytes.byteLength !== before.size) {
+    throw new ManagedAgentMcpError(ErrorCode.enum.MCP_AGENT_ARTIFACT_UNAVAILABLE, "share target changed while it was being read");
+  }
+  assertWithinCap(bytes.byteLength);
+  const text = decodeUtf83(bytes);
+  const digest = await sha256Bytes(bytes);
+  return {
+    contents: [
+      {
+        uri,
+        mimeType: "text/plain",
+        text,
+        _meta: {
+          status: "ok",
+          digest,
+          byteSize: bytes.byteLength,
+          provenance: entry.provenance
+        }
+      }
+    ]
+  };
+}
+async function statShareTarget(workspace, path4) {
+  try {
+    return await workspace.stat(path4);
+  } catch {
+    throw new ManagedAgentMcpError(ErrorCode.enum.MCP_AGENT_ARTIFACT_UNAVAILABLE, "share target is unavailable");
+  }
+}
+function assertShareTargetStat(stat13) {
+  if (stat13.kind !== "file") {
+    throw new ManagedAgentMcpError(ErrorCode.enum.MCP_AGENT_ARTIFACT_INVALID, "share target must be a file");
+  }
+  if (!Number.isFinite(stat13.size) || stat13.size < 0) {
+    throw new ManagedAgentMcpError(ErrorCode.enum.MCP_AGENT_ARTIFACT_INVALID, "share target size is invalid");
+  }
+}
+function assertWithinCap(byteSize) {
+  if (byteSize > MAX_SHARE_READ_BYTES) {
+    throw new ManagedAgentMcpError(
+      ErrorCode.enum.MCP_AGENT_ARTIFACT_TOO_LARGE,
+      `share target must be ${MAX_SHARE_READ_BYTES} bytes or fewer`
+    );
+  }
+}
+function sameStat2(left, right) {
+  return left.kind === right.kind && left.size === right.size && left.mtimeMs === right.mtimeMs;
+}
+function decodeUtf83(bytes) {
+  try {
+    return strictUtf8Decoder2.decode(bytes);
+  } catch {
+    throw new ManagedAgentMcpError(ErrorCode.enum.MCP_AGENT_ARTIFACT_INVALID, "share target must be well-formed UTF-8");
+  }
+}
+
+// src/server/mcp/managedAgentMcpServer.ts
 var DEFAULT_MAX_BRIEF_SCHEMA_CHARS = 32 * 1024;
 var delegateTaskStatusInputSchema = {
   delegationId: z2.string().min(1)
@@ -9508,6 +9687,13 @@ function createManagedAgentMcpServerWithController(options, controller) {
     name: options.name ?? "boring-managed-agent",
     version: options.version ?? "0.0.0"
   });
+  if (options.shareEntryStore && options.resolveShareSessionCtx && options.resolveShareWorkspace) {
+    registerShareEntryResources(server, {
+      store: options.shareEntryStore,
+      resolveSessionCtx: options.resolveShareSessionCtx,
+      resolveWorkspace: options.resolveShareWorkspace
+    });
+  }
   const registerTool = server.registerTool.bind(server);
   const delegateTaskInputSchema = createDelegateTaskInputSchema(options.maxBriefChars ?? DEFAULT_MAX_BRIEF_SCHEMA_CHARS);
   registerTool(
@@ -11874,7 +12060,7 @@ function piChatRoutes(app, opts, done) {
       if (!service.createSession) throw unsupportedServiceMethod("create Pi chat session");
       return reply.code(201).send(await service.createSession(getRequestContext(request), body));
     } catch (err) {
-      return sendRouteError(reply, err, "create pi chat session failed");
+      return sendRouteError(reply, err, "create pi chat session failed", true);
     }
   });
   app.delete("/api/v1/agent/pi-chat/sessions/:sessionId", async (request, reply) => {
@@ -11886,7 +12072,7 @@ function piChatRoutes(app, opts, done) {
       await service.deleteSession(getRequestContext(request), params.sessionId);
       return reply.code(204).send();
     } catch (err) {
-      return sendRouteError(reply, err, "delete pi chat session failed");
+      return sendRouteError(reply, err, "delete pi chat session failed", true);
     }
   });
   app.get("/api/v1/agent/pi-chat/:sessionId/state", async (request, reply) => {
@@ -11977,7 +12163,7 @@ function piChatRoutes(app, opts, done) {
       const receipt = await service.prompt(getRequestContext(request), params.sessionId, body);
       return reply.code(202).send(receipt);
     } catch (err) {
-      return sendRouteError(reply, err, "prompt rejected");
+      return sendRouteError(reply, err, "prompt rejected", true);
     }
   });
   app.post("/api/v1/agent/pi-chat/:sessionId/followup", async (request, reply) => {
@@ -11990,7 +12176,7 @@ function piChatRoutes(app, opts, done) {
       const receipt = await service.followUp(getRequestContext(request), params.sessionId, body);
       return reply.code(202).send(receipt);
     } catch (err) {
-      return sendRouteError(reply, err, "follow-up rejected");
+      return sendRouteError(reply, err, "follow-up rejected", true);
     }
   });
   app.post("/api/v1/agent/pi-chat/:sessionId/queue/clear", async (request, reply) => {
@@ -12003,7 +12189,7 @@ function piChatRoutes(app, opts, done) {
       const receipt = await service.clearQueue(getRequestContext(request), params.sessionId, body);
       return reply.code(202).send(receipt);
     } catch (err) {
-      return sendRouteError(reply, err, "queue clear rejected");
+      return sendRouteError(reply, err, "queue clear rejected", true);
     }
   });
   app.post("/api/v1/agent/pi-chat/:sessionId/interrupt", async (request, reply) => {
@@ -12016,7 +12202,7 @@ function piChatRoutes(app, opts, done) {
       const receipt = await service.interrupt(getRequestContext(request), params.sessionId, body);
       return reply.code(202).send(receipt);
     } catch (err) {
-      return sendRouteError(reply, err, "interrupt rejected");
+      return sendRouteError(reply, err, "interrupt rejected", true);
     }
   });
   app.post("/api/v1/agent/pi-chat/:sessionId/stop", async (request, reply) => {
@@ -12029,7 +12215,7 @@ function piChatRoutes(app, opts, done) {
       const receipt = await service.stop(getRequestContext(request), params.sessionId, body);
       return reply.code(202).send(receipt);
     } catch (err) {
-      return sendRouteError(reply, err, "stop rejected");
+      return sendRouteError(reply, err, "stop rejected", true);
     }
   });
   done();
@@ -12115,17 +12301,19 @@ function sendReplayRangeError(reply, error) {
     }
   });
 }
-function sendRouteError(reply, err, fallbackMessage) {
+function sendRouteError(reply, err, fallbackMessage, preserveAdmissionError = false) {
   const statusCode = statusCodeFromError(err);
   const parsedCode = ErrorCode.safeParse(err?.code);
-  const code = parsedCode.success ? parsedCode.data : ErrorCode.enum.INTERNAL_ERROR;
-  const message = err instanceof Error ? err.message : fallbackMessage;
+  const admissionError = preserveAdmissionError && err instanceof AgentEffectAdmissionError;
+  const rejectedAdmissionError = !preserveAdmissionError && err instanceof AgentEffectAdmissionError;
+  const code = admissionError ? err.code : parsedCode.success ? parsedCode.data : ErrorCode.enum.INTERNAL_ERROR;
+  const message = !rejectedAdmissionError && err instanceof Error ? err.message : fallbackMessage;
   return reply.code(statusCode).send({
     error: {
       code,
       message,
       retryable: err?.retryable === true ? true : void 0,
-      details: err?.details
+      details: rejectedAdmissionError ? void 0 : err?.details
     }
   });
 }
@@ -12364,7 +12552,7 @@ function meteredCommandBlocked(command) {
 }
 function stableErrorPayload(error, message) {
   const code = error?.code;
-  if (!isErrorCode(code)) return void 0;
+  if (!isErrorCode(code) && !(error instanceof AgentEffectAdmissionError)) return void 0;
   const details = error?.details;
   return {
     error: {
@@ -12412,6 +12600,7 @@ function commandsRoutes(app, opts, done) {
       if (meteringActive) {
         return reply.code(409).send(meteredCommandBlocked(name));
       }
+      await opts.admitEffect?.({ workspaceId: getRequestWorkspaceId(request), requestId: request.id });
       await harness.executeSlashCommand(sessionId, name, args, runContext);
       return reply.code(200).send({ ok: true });
     } catch (error) {
@@ -13310,6 +13499,51 @@ function buildUploadAgentTools(bundle) {
   ];
 }
 
+// src/server/http/routes/deepLink.ts
+var DEFAULT_WORKSPACE_ID4 = "default";
+function getRequestWorkspaceId2(request) {
+  return request.workspaceContext?.workspaceId ?? DEFAULT_WORKSPACE_ID4;
+}
+function sendShareNotFound(reply) {
+  return reply.code(404).send({
+    error: { code: ShareEntryErrorCode.enum.AR1_SHARE_NOT_FOUND, message: "share not found" }
+  });
+}
+var deepLinkRoutes = (app, opts, done) => {
+  async function resolveWorkspace(request) {
+    if (opts.getWorkspace) return await opts.getWorkspace(request);
+    if (opts.workspace) return opts.workspace;
+    throw new Error("deep-link route requires workspace or getWorkspace");
+  }
+  app.get("/a/:id", async (request, reply) => {
+    const { id } = request.params;
+    const requestWorkspaceId = getRequestWorkspaceId2(request);
+    const entry = await opts.store.get(id);
+    if (!entry || entry.workspaceId !== requestWorkspaceId) {
+      return sendShareNotFound(reply);
+    }
+    const workspace = await resolveWorkspace(request);
+    const resolution = await resolveShareEntry(opts.store, id, workspace);
+    switch (resolution.status) {
+      case "not_found":
+        return sendShareNotFound(reply);
+      case "tombstoned":
+        return reply.code(200).send({
+          status: "tombstoned",
+          code: resolution.code,
+          tombstone: resolution.tombstone
+        });
+      case "ok":
+        return reply.code(200).send({
+          status: "ok",
+          workspaceId: resolution.entry.workspaceId,
+          id: resolution.entry.id
+        });
+    }
+  });
+  done();
+};
+
 // src/server/runtime/runtimeBindingLifecycle.ts
 function createRuntimeBindingLifecycle(options) {
   const { app } = options;
@@ -13597,7 +13831,7 @@ function createRuntimeBindingLifecycle(options) {
 
 // src/server/registerAgentRoutes.ts
 var DEFAULT_VERSION2 = "0.1.0-dev";
-var DEFAULT_WORKSPACE_ID4 = "default";
+var DEFAULT_WORKSPACE_ID5 = "default";
 var STANDARD_AGENT_TOOL_NAMES = ["bash", "read", "write", "edit", "find", "grep", "ls"];
 function pluginNameFromPath(path4) {
   const fileName = basename2(path4);
@@ -13617,8 +13851,8 @@ function getAvailableModelProviders() {
     new Set(availableModels.map((model) => model.provider))
   ).sort((a, b) => a.localeCompare(b));
 }
-function getRequestWorkspaceId2(request) {
-  return request.workspaceContext?.workspaceId ?? DEFAULT_WORKSPACE_ID4;
+function getRequestWorkspaceId3(request) {
+  return request.workspaceContext?.workspaceId ?? DEFAULT_WORKSPACE_ID5;
 }
 function promoteRawFileWorkspaceQueryToHeader(request) {
   const pathname = request.url.split("?")[0] ?? request.url;
@@ -13711,7 +13945,7 @@ function createRuntimeReadinessCheck(workspaceId, getRuntimeDependencies) {
   };
 }
 var registerAgentRoutes = async (app, opts) => {
-  const sessionId = opts.sessionId ?? DEFAULT_WORKSPACE_ID4;
+  const sessionId = opts.sessionId ?? DEFAULT_WORKSPACE_ID5;
   const resolvedMode = opts.runtimeModeAdapter?.id ?? opts.mode ?? autoDetectMode();
   const workspaceRoot = opts.workspaceRoot ?? process.cwd();
   const templatePath = opts.templatePath ?? getEnv("BORING_AGENT_TEMPLATE_PATH");
@@ -14039,6 +14273,7 @@ var registerAgentRoutes = async (app, opts) => {
       workdir: root
     }, {
       service: {
+        admitEffect: opts.admitEffect,
         workdir: runtimeBundle.workspace.root,
         workspace: runtimeBundle.workspace
       }
@@ -14280,14 +14515,14 @@ var registerAgentRoutes = async (app, opts) => {
   function getSkillsScopeForRequest(request) {
     let promise = skillsScopeByRequest.get(request);
     if (!promise) {
-      promise = resolveSkillScope(getRequestWorkspaceId2(request), request);
+      promise = resolveSkillScope(getRequestWorkspaceId3(request), request);
       skillsScopeByRequest.set(request, promise);
     }
     return promise;
   }
   async function getBindingForRequest(request, options = {}) {
     if (staticBinding) return staticBinding;
-    return await getOrCreateRuntimeBinding(getRequestWorkspaceId2(request), request, options);
+    return await getOrCreateRuntimeBinding(getRequestWorkspaceId3(request), request, options);
   }
   async function getFilesystemBindingsForRequest(request) {
     const binding = await getBindingForRequest(request);
@@ -14295,7 +14530,7 @@ var registerAgentRoutes = async (app, opts) => {
     const user = request.user;
     return await opts.getFilesystemBindings({
       request,
-      workspaceId: getRequestWorkspaceId2(request),
+      workspaceId: getRequestWorkspaceId3(request),
       workspaceRoot: binding.workspaceRoot,
       userId: user?.id,
       userEmail: user?.email,
@@ -14322,7 +14557,7 @@ var registerAgentRoutes = async (app, opts) => {
   }
   app.addHook("onRequest", async (request, reply) => {
     const user = request.user;
-    let workspaceId = DEFAULT_WORKSPACE_ID4;
+    let workspaceId = DEFAULT_WORKSPACE_ID5;
     promoteRawFileWorkspaceQueryToHeader(request);
     if (opts.getWorkspaceId && !isWorkspaceAgnosticAgentRequest(request, { readyStatusWorkspaceScoped: requestScopedRuntime, modelsWorkspaceScoped })) {
       try {
@@ -14376,6 +14611,12 @@ var registerAgentRoutes = async (app, opts) => {
   await app.register(searchRoutes, {
     getFileSearch: async (request) => (await getBindingForRequest(request)).runtimeBundle.fileSearch
   });
+  if (opts.shareEntryStore) {
+    await app.register(deepLinkRoutes, {
+      store: opts.shareEntryStore,
+      getWorkspace: async (request) => (await getBindingForRequest(request)).runtimeBundle.workspace
+    });
+  }
   await app.register(gitRoutes, {
     getWorkspace: async (request) => {
       const runtimeBundle = (await getBindingForRequest(request)).runtimeBundle;
@@ -14421,12 +14662,13 @@ var registerAgentRoutes = async (app, opts) => {
   });
   await app.register(sessionChangesRoutes, { tracker: sessionChangesTracker });
   app.post("/api/v1/agent/reload", async (request, reply) => {
-    const workspaceId = getRequestWorkspaceId2(request);
+    const workspaceId = getRequestWorkspaceId3(request);
     const binding = await getBindingForRequest(request);
     if (!binding.harness.reloadSession) {
       return reply.status(501).send({ ok: false, error: "Agent harness does not support reload" });
     }
     try {
+      await opts.admitEffect?.({ workspaceId, requestId: request.id });
       await binding.reprovision(request);
       binding.assertActive();
       const hookResult = await opts.beforeReload?.({
@@ -14464,6 +14706,9 @@ var registerAgentRoutes = async (app, opts) => {
       };
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
+      if (error instanceof AgentEffectAdmissionError) {
+        return reply.status(error.statusCode).send({ ok: false, error: { code: error.code, message } });
+      }
       return reply.status(422).send({ ok: false, error: message });
     }
   });
@@ -14477,12 +14722,14 @@ var registerAgentRoutes = async (app, opts) => {
       harness: staticBinding.harness,
       defaultSessionId: sessionId,
       workdir: staticBinding.runtimeBundle.workspace.root,
-      metering: opts.metering
+      metering: opts.metering,
+      admitEffect: opts.admitEffect
     } : {
       defaultSessionId: sessionId,
       getHarness: async (request) => (await getBindingForRequest(request)).harness,
       getWorkdir: async (request) => (await getBindingForRequest(request)).runtimeBundle.workspace.root,
-      metering: opts.metering
+      metering: opts.metering,
+      admitEffect: opts.admitEffect
     }
   );
   await app.register(
@@ -14545,6 +14792,8 @@ export {
   ManagedAgentMcpError,
   ManagedAgentMcpDelegateController,
   createManagedAgentMcpDelegateController,
+  shareResourceUri,
+  registerShareEntryResources,
   createManagedAgentMcpServer,
   createManagedAgentMcpHttpHandler,
   createAgentApp,