@hachej/boring-agent 0.1.83 → 0.1.85

package/dist/shared/index.js

@@ -1,17 +1,24 @@
 import {
   AgentDefinitionValidationError,
   AgentDeploymentValidationError,
+  InMemoryShareEntryStore,
   OpaqueRefSchema,
+  OpaqueShareLocatorIdSchema,
   SchemaValidationError,
   Sha256DigestSchema,
+  ShareEntryErrorCode,
+  ShareEntryProvenanceSchema,
+  ShareEntryV1Schema,
+  ShareEntryValidationError,
   createAgentAssetDigest,
   createAgentDefinitionDigest,
   createAgentDeploymentDigest,
   formatPath,
+  resolveShareEntry,
   validateAgentDefinition,
   validateAgentDeployment,
   validateTool
-} from "../chunk-WODTQBXR.js";
+} from "../chunk-YONTHCD7.js";
 import {
   AGENT_NOT_IMPLEMENTED_UNTIL_T1,
   AgentNotImplementedError,
@@ -48,7 +55,7 @@ import {
   extractToolUiMetadata,
   isToolUiMetadata,
   sanitizeToolUiMetadata2 as sanitizeToolUiMetadata
-} from "../chunk-DC3S7SZG.js";
+} from "../chunk-6O5ADR57.js";
 import {
   noopTelemetry,
   safeCapture
@@ -62,7 +69,7 @@ import {
   ERROR_CODES,
   ErrorCode,
   ErrorLogFieldsSchema
-} from "../chunk-PG2WOJ22.js";
+} from "../chunk-HDIRWHJB.js";
 
 // src/shared/config-schema.ts
 import { z } from "zod";
@@ -131,6 +138,10 @@ var PI_AGENT_RUNTIME_CAPABILITIES = {
 // src/shared/agent-consumption.ts
 import { z as z2 } from "zod";
 var nonEmptyString = z2.string().min(1);
+function isOpaqueLocatorId(value) {
+  return value.trim() === value && !/[\0-\x1f\x7f]/.test(value) && !value.includes("/") && !value.includes("\\") && !value.includes(":") && value !== "." && value !== "..";
+}
+var OpaqueLocatorIdSchema = z2.string().min(1, "must be a non-empty opaque id").max(256, "must be at most 256 characters").refine(isOpaqueLocatorId, 'must be an opaque platform-owned id (no path separators, scheme, or "..")');
 var TASK_STATES = [
   "submitted",
   "working",
@@ -173,11 +184,19 @@ var AgentRefSchema = z2.object({
 function agentRefEquals(a, b) {
   return a.agentId === b.agentId && (a.deploymentId ?? null) === (b.deploymentId ?? null);
 }
+var ARTIFACT_LOCATOR_KINDS = ["workspace-file"];
+var WorkspaceFileLocatorSchema = z2.object({
+  kind: z2.literal("workspace-file"),
+  workspaceId: OpaqueLocatorIdSchema,
+  fileId: OpaqueLocatorIdSchema,
+  digest: Sha256DigestSchema
+}).strict();
+var ArtifactLocatorSchema = z2.discriminatedUnion("kind", [WorkspaceFileLocatorSchema]);
 var ArtifactRefSchema = z2.object({
   artifactId: nonEmptyString,
   name: z2.string().optional(),
   mimeType: nonEmptyString,
-  uri: nonEmptyString
+  locator: ArtifactLocatorSchema
 }).strict();
 var PartSchema = z2.discriminatedUnion("type", [
   z2.object({ type: z2.literal("text"), text: z2.string() }).strict(),
@@ -189,6 +208,7 @@ var AgentMessageSchema = z2.object({
   parts: z2.array(PartSchema),
   ts: nonEmptyString
 }).strict();
+var AGENT_TASK_SCHEMA_VERSION = "2";
 var AgentTaskSchema = z2.object({
   id: nonEmptyString,
   contextId: nonEmptyString,
@@ -197,7 +217,7 @@ var AgentTaskSchema = z2.object({
   artifacts: z2.array(ArtifactRefSchema),
   principal: PrincipalRefSchema,
   actor: AgentRefSchema.optional(),
-  schemaVersion: z2.literal("1"),
+  schemaVersion: z2.literal(AGENT_TASK_SCHEMA_VERSION),
   createdAt: nonEmptyString,
   updatedAt: nonEmptyString
 }).strict();
@@ -224,6 +244,65 @@ var AgentConsumptionValidationError = class extends SchemaValidationError {
     this.name = "AgentConsumptionValidationError";
   }
 };
+var LegacyArtifactRefSchema = z2.object({
+  artifactId: nonEmptyString,
+  name: z2.string().optional(),
+  mimeType: nonEmptyString,
+  uri: nonEmptyString
+}).strict();
+var LegacyPartSchema = z2.discriminatedUnion("type", [
+  z2.object({ type: z2.literal("text"), text: z2.string() }).strict(),
+  z2.object({ type: z2.literal("file"), file: LegacyArtifactRefSchema }).strict(),
+  z2.object({ type: z2.literal("data"), mimeType: nonEmptyString, data: z2.unknown() }).strict()
+]);
+var LegacyAgentMessageSchema = z2.object({
+  role: z2.enum(["consumer", "agent"]),
+  parts: z2.array(LegacyPartSchema),
+  ts: nonEmptyString
+}).strict();
+var LegacyAgentTaskSchema = z2.object({
+  id: nonEmptyString,
+  contextId: nonEmptyString,
+  state: TaskStateSchema,
+  messages: z2.array(LegacyAgentMessageSchema),
+  artifacts: z2.array(LegacyArtifactRefSchema),
+  principal: PrincipalRefSchema,
+  actor: AgentRefSchema.optional(),
+  schemaVersion: z2.literal("1"),
+  createdAt: nonEmptyString,
+  updatedAt: nonEmptyString
+}).strict();
+function collectLegacyArtifactUris(raw) {
+  const uris = [];
+  for (const artifact of raw.artifacts) uris.push(artifact.uri);
+  for (const message of raw.messages) {
+    for (const part of message.parts) {
+      if (part.type === "file") uris.push(part.file.uri);
+    }
+  }
+  return uris;
+}
+function parseAgentTaskEdgeCompat(raw) {
+  const v2 = AgentTaskSchema.safeParse(raw);
+  if (v2.success) return { valid: true, value: v2.data };
+  const legacy = LegacyAgentTaskSchema.safeParse(raw);
+  if (legacy.success) {
+    const uris = collectLegacyArtifactUris(legacy.data);
+    const issues = uris.length > 0 ? uris.map((uri, index) => ({
+      code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_LEGACY_ARTIFACT_REJECTED,
+      field: `artifacts[${index}].uri`,
+      message: `schemaVersion '1' artifact uri '${uri}' has no typed ArtifactLocator translation and is refused before any storage/network effect`
+    })) : [
+      {
+        code: AgentConsumptionErrorCode.enum.AGENT_CONSUMPTION_LEGACY_ARTIFACT_REJECTED,
+        field: "schemaVersion",
+        message: "schemaVersion '1' is no longer accepted; publish schemaVersion '2' with a typed ArtifactLocator"
+      }
+    ];
+    return { valid: false, issues };
+  }
+  return { valid: false, issues: schemaMismatchIssues(v2.error.issues) };
+}
 var ConsumptionGuardsSchema = z2.object({
   maxDepth: z2.number().int().positive(),
   inputRequiredTimeoutMs: z2.number().int().positive()
@@ -262,6 +341,8 @@ function assertWithinConsumptionDepth(chain, guards) {
 }
 export {
   AGENT_NOT_IMPLEMENTED_UNTIL_T1,
+  AGENT_TASK_SCHEMA_VERSION,
+  ARTIFACT_LOCATOR_KINDS,
   AgentConsumptionErrorCode,
   AgentConsumptionValidationError,
   AgentDefinitionErrorCode,
@@ -274,6 +355,7 @@ export {
   AgentTaskSchema,
   ApiErrorPayloadSchema,
   ApiErrorResponseSchema,
+  ArtifactLocatorSchema,
   ArtifactRefSchema,
   BoringChatMessageSchema,
   BoringChatPartSchema,
@@ -290,8 +372,10 @@ export {
   ErrorLogFieldsSchema,
   FollowUpPayloadSchema,
   FollowUpReceiptSchema,
+  InMemoryShareEntryStore,
   InterruptPayloadSchema,
   OpaqueRefSchema,
+  OpaqueShareLocatorIdSchema,
   PI_AGENT_RUNTIME_CAPABILITIES,
   PartSchema,
   PiChatEventSchema,
@@ -307,6 +391,10 @@ export {
   QueuedUserMessageSchema,
   RuntimeModeSchema,
   Sha256DigestSchema,
+  ShareEntryErrorCode,
+  ShareEntryProvenanceSchema,
+  ShareEntryV1Schema,
+  ShareEntryValidationError,
   StopPayloadSchema,
   StopReceiptSchema,
   TASK_STATES,
@@ -315,6 +403,7 @@ export {
   ToolUiMetadataSchema,
   WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT,
   WORKSPACE_COMMAND_NOTIFY_EVENT,
+  WorkspaceFileLocatorSchema,
   agentRefEquals,
   assertNoConsumptionCycle,
   assertValidTransition,
@@ -328,6 +417,8 @@ export {
   isValidTaskTransition,
   isWithinConsumptionDepth,
   noopTelemetry,
+  parseAgentTaskEdgeCompat,
+  resolveShareEntry,
   safeCapture,
   sanitizeToolUiMetadata,
   sessionStreamPath,

package/dist/workspaceAgentDispatcher-Dv0DocrE.d.ts

@@ -0,0 +1,314 @@
+import { z } from 'zod';
+import { p as AgentDefinitionErrorCode, q as AgentDeploymentErrorCode, D as InterruptReceipt, j as StopReceipt } from './piChatEvent-CUTKRaZD.js';
+import { a as Workspace } from './sandbox-DthfJaOB.js';
+import { p as AgentSendInput, j as AgentEvent } from './harness-RhGbdGWY.js';
+
+interface SandboxHandleRecord {
+    workspaceId: string;
+    sandboxId: string;
+    snapshotId?: string;
+    createdAt: string;
+    lastUsedAt: string;
+}
+interface SandboxHandleStore {
+    get(workspaceId: string): Promise<SandboxHandleRecord | null>;
+    put(record: SandboxHandleRecord): Promise<void>;
+    delete(workspaceId: string): Promise<void>;
+    list(): Promise<SandboxHandleRecord[]>;
+}
+
+interface FileSearch {
+    search(glob: string, limit?: number): Promise<string[]>;
+}
+
+type Sha256Digest = `sha256:${string}`;
+
+interface AgentSchemaIssue<Code extends string> {
+    code: Code;
+    field: string;
+    message: string;
+}
+type AgentSchemaValidationResult<T, Code extends string> = {
+    valid: true;
+    value: T;
+} | {
+    valid: false;
+    issues: AgentSchemaIssue<Code>[];
+};
+declare abstract class SchemaValidationError<Code extends string> extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly field: string;
+    readonly validationCode: Code;
+    constructor(issue: AgentSchemaIssue<Code>);
+}
+
+interface AgentDefinition {
+    schemaVersion: 1;
+    definitionId: string;
+    version: string;
+    label?: string;
+    instructionsRef: string;
+    capabilityRequirements?: string[];
+    toolRefs?: string[];
+    skillRefs?: string[];
+    mcpServerRefs?: string[];
+}
+interface AgentDefinitionReference {
+    definitionId: string;
+    version: string;
+    digest: Sha256Digest;
+}
+interface AgentDeployment {
+    deploymentId: string;
+    version: string;
+    agentId: string;
+    definition: AgentDefinitionReference;
+}
+interface AgentDefinitionDigestAsset {
+    path: string;
+    digest: Sha256Digest;
+    content: string;
+}
+type CompiledAgentDefinition = {
+    readonly [Key in keyof AgentDefinition]: AgentDefinition[Key] extends readonly string[] | undefined ? readonly string[] | undefined : AgentDefinition[Key];
+};
+interface CompiledAgentBundle {
+    readonly definition: CompiledAgentDefinition;
+    readonly definitionDigest: Sha256Digest;
+    readonly assets: readonly Readonly<AgentDefinitionDigestAsset>[];
+}
+declare const OpaqueRefSchema: z.ZodEffects<z.ZodString, string, string>;
+declare const Sha256DigestSchema: z.ZodEffects<z.ZodString, `sha256:${string}`, string>;
+declare function validateAgentDefinition(raw: unknown): AgentSchemaValidationResult<AgentDefinition, AgentDefinitionErrorCode>;
+declare function validateAgentDeployment(raw: unknown): AgentSchemaValidationResult<AgentDeployment, AgentDeploymentErrorCode>;
+declare function createAgentAssetDigest(content: string): Promise<Sha256Digest>;
+declare class AgentDefinitionValidationError extends SchemaValidationError<AgentDefinitionErrorCode> {
+    constructor(issue: AgentSchemaIssue<AgentDefinitionErrorCode>);
+}
+declare class AgentDeploymentValidationError extends SchemaValidationError<AgentDeploymentErrorCode> {
+    constructor(issue: AgentSchemaIssue<AgentDeploymentErrorCode>);
+}
+declare function createAgentDefinitionDigest(input: {
+    definition: CompiledAgentDefinition;
+    assets: readonly AgentDefinitionDigestAsset[];
+}): Promise<Sha256Digest>;
+declare function createAgentDeploymentDigest(deployment: AgentDeployment): Promise<Sha256Digest>;
+
+declare const OpaqueShareLocatorIdSchema: z.ZodEffects<z.ZodString, string, string>;
+interface ShareEntryProvenance {
+    producerPrincipalRef: string;
+    createdAt: string;
+}
+declare const ShareEntryProvenanceSchema: z.ZodObject<{
+    producerPrincipalRef: z.ZodString;
+    createdAt: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    createdAt: string;
+    producerPrincipalRef: string;
+}, {
+    createdAt: string;
+    producerPrincipalRef: string;
+}>;
+/**
+ * Lane W same-workspace share entry (AR1-001-SPEC.md §3.1): a live reference
+ * to a file in the SAME workspace the consumer already belongs to. No blob
+ * capture — nothing crosses a workspace boundary. `path` is SERVER-INTERNAL
+ * and MUST NOT be emitted in any URL/API/audit surface a later bead builds.
+ */
+interface ShareEntryV1 {
+    schemaVersion: 1;
+    id: string;
+    workspaceId: string;
+    /** SERVER-INTERNAL live path; never emitted in URL/API/audit. */
+    path: string;
+    provenance: ShareEntryProvenance;
+}
+declare const ShareEntryV1Schema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    id: z.ZodEffects<z.ZodString, string, string>;
+    workspaceId: z.ZodEffects<z.ZodString, string, string>;
+    path: z.ZodString;
+    provenance: z.ZodObject<{
+        producerPrincipalRef: z.ZodString;
+        createdAt: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        createdAt: string;
+        producerPrincipalRef: string;
+    }, {
+        createdAt: string;
+        producerPrincipalRef: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    path: string;
+    id: string;
+    workspaceId: string;
+    schemaVersion: 1;
+    provenance: {
+        createdAt: string;
+        producerPrincipalRef: string;
+    };
+}, {
+    path: string;
+    id: string;
+    workspaceId: string;
+    schemaVersion: 1;
+    provenance: {
+        createdAt: string;
+        producerPrincipalRef: string;
+    };
+}>;
+/**
+ * Refusal codes for Lane W share resolution (AR1-001-SPEC.md §3.3/§5).
+ * Graduated into the public {@link ErrorCode}/`ERROR_CODES` registry (and
+ * `docs/ERROR_CODES.md`) by AR1-003, the first runtime route
+ * (`GET /a/:id`, `server/http/routes/deepLink.ts`) that surfaces these over
+ * an API boundary — following the same registry precedent used for
+ * `MCP_AGENT_ARTIFACT_*` (graduated when `managedAgentDelegate.ts` started
+ * surfacing them). These are the ONLY two AR1-specific codes for Lane W:
+ * "Access denial is the existing generic membership denial, not an AR1
+ * code" (spec §3.3) — this module does not invent a third.
+ */
+declare const ShareEntryErrorCode: z.ZodEnum<["AR1_SHARE_NOT_FOUND", "AR1_SHARE_TOMBSTONED"]>;
+type ShareEntryErrorCode = z.infer<typeof ShareEntryErrorCode>;
+/**
+ * Input-validation failures for {@link ShareEntryStore.create}. Deliberately
+ * NOT an `AR1_*` code (the spec's §5 table names exactly two Lane W codes for
+ * resolution outcomes; this reuses the existing generic `CONFIG_INVALID`
+ * taxonomy for malformed create-input, the same way `SchemaValidationError`
+ * subclasses elsewhere in this package do).
+ */
+declare const ShareEntryValidationCode: z.ZodEnum<["SHARE_ENTRY_INPUT_INVALID"]>;
+type ShareEntryValidationCode = z.infer<typeof ShareEntryValidationCode>;
+declare class ShareEntryValidationError extends Error {
+    readonly code: "CONFIG_INVALID";
+    readonly field: string;
+    constructor(issue: AgentSchemaIssue<ShareEntryValidationCode>);
+}
+interface CreateShareEntryInput {
+    workspaceId: string;
+    /** SERVER-INTERNAL live path. Never persist/return this in a public surface. */
+    path: string;
+    provenance: {
+        producerPrincipalRef: string;
+        /** Defaults to the store's creation time when omitted. */
+        createdAt?: string;
+    };
+}
+interface ShareEntryStore {
+    /** Validates `input`, mints a fresh opaque `id`, and persists the entry. */
+    create(input: CreateShareEntryInput): Promise<ShareEntryV1>;
+    get(id: string): Promise<ShareEntryV1 | null>;
+    delete(id: string): Promise<void>;
+    /** Lists entries scoped to one workspace (never leaks across workspaces). */
+    list(workspaceId: string): Promise<ShareEntryV1[]>;
+}
+/**
+ * In-memory reference implementation. Lane W has no durability requirement
+ * beyond "the repo's existing persistence seam" named by this bead (a simple
+ * keyed-record store, mirroring `SandboxHandleStore`/`SessionStore` in this
+ * same package) — a durable adapter is a swap-in behind the same interface
+ * when a later bead needs one; this store does not invent a new store
+ * technology.
+ */
+declare class InMemoryShareEntryStore implements ShareEntryStore {
+    private readonly entries;
+    create(input: CreateShareEntryInput): Promise<ShareEntryV1>;
+    get(id: string): Promise<ShareEntryV1 | null>;
+    delete(id: string): Promise<void>;
+    list(workspaceId: string): Promise<ShareEntryV1[]>;
+}
+/** Redacted, path-free projection of a tombstoned entry (spec §3.3/§1: no path in any error surface). */
+interface ShareEntryTombstone {
+    id: string;
+    workspaceId: string;
+    provenance: ShareEntryProvenance;
+}
+type ShareEntryResolution = {
+    status: 'ok';
+    entry: ShareEntryV1;
+} | {
+    status: 'not_found';
+    code: typeof ShareEntryErrorCode.enum.AR1_SHARE_NOT_FOUND;
+} | {
+    status: 'tombstoned';
+    code: typeof ShareEntryErrorCode.enum.AR1_SHARE_TOMBSTONED;
+    tombstone: ShareEntryTombstone;
+};
+/**
+ * Resolves a share entry against the CURRENT state of the workspace file
+ * (live-reference semantics, spec §3.2 — deliberately not a snapshot). The
+ * caller must already have resolved and authorized `workspace` for
+ * `entry.workspaceId`; this function performs no membership check itself
+ * (spec §3.3: "Access denial is the existing generic membership denial, not
+ * an AR1 code").
+ *
+ * - No such entry -> `not_found` (`AR1_SHARE_NOT_FOUND`).
+ * - Entry exists but the target file is gone -> `tombstoned`
+ *   (`AR1_SHARE_TOMBSTONED`), carrying provenance + last-known metadata and
+ *   NEVER the path (never a bare 404, never source state).
+ * - Entry exists and the target file stats successfully -> `ok`, with the
+ *   full (server-internal) entry for the caller to act on.
+ *
+ * Any `workspace.stat` rejection (not just a "does not exist" error) is
+ * treated as "target gone" — the spec's fail-safe is to render a tombstone,
+ * never a bare 404; a later bead may narrow this to distinguish stat
+ * failure causes if that proves necessary.
+ */
+declare function resolveShareEntry(store: ShareEntryStore, id: string, workspace: Workspace): Promise<ShareEntryResolution>;
+
+/**
+ * Browser CustomEvent name dispatched on `window` after the workspace's
+ * agent-plugin hot reload subscriber commits a registry change (load,
+ * unload, or error).
+ *
+ * Declared in `@hachej/boring-agent` (not `@hachej/boring-workspace`)
+ * so the agent's ChatPanel — which listens for this event to refresh
+ * its slash-command palette / banner state — can import it without
+ * creating a workspace → agent → workspace cycle. Workspace's
+ * `useAgentPluginHotReload` imports the same constant.
+ */
+declare const WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT = "boring-ui:agent-plugins-reloaded";
+/**
+ * One per plugin that loaded successfully but whose server-side surfaces
+ * (Fastify routes / agent tools) still hold pre-reload code. Shared
+ * between the agent's /reload HTTP route + the ChatPanel banner so the
+ * agent layer has ONE declaration of this wire shape. Mirrors what the
+ * workspace's `collectRestartWarnings()` emits (workspace owns the
+ * canonical `PluginRestartWarning` type; we redeclare here only because
+ * the agent layer must not depend on workspace).
+ */
+interface PluginRestartWarning {
+    id: string;
+    surfaces: string[];
+    message: string;
+}
+/**
+ * Browser CustomEvent name dispatched on `window` when a `showNotification`
+ * UI command arrives from the server (e.g. from a plugin slash command that
+ * calls `notify()`). `PiChatPanel` listens for this to show the
+ * `CommandRunStatus` banner above the composer.
+ */
+declare const WORKSPACE_COMMAND_NOTIFY_EVENT = "boring-ui:command-notify";
+/**
+ * Payload carried by `WORKSPACE_COMMAND_NOTIFY_EVENT`. Maps directly to
+ * what `uiCommandDispatcher` extracts from the `showNotification` command.
+ */
+interface CommandNotifyPayload {
+    message: string;
+    tone: 'success' | 'error' | 'info' | 'warn';
+    /** Name of the command that triggered the notification (without leading slash). */
+    command?: string;
+}
+
+interface WorkspaceAgentDispatcherContext {
+    workspaceId: string;
+    userId: string;
+}
+type WorkspaceAgentDispatcherSendInput = Omit<AgentSendInput, 'ctx'>;
+interface WorkspaceAgentDispatcher {
+    send(input: WorkspaceAgentDispatcherSendInput): AsyncIterable<AgentEvent>;
+    interrupt(sessionId: string): Promise<InterruptReceipt>;
+    stop(sessionId: string): Promise<StopReceipt>;
+}
+
+export { type AgentDeployment as A, WORKSPACE_COMMAND_NOTIFY_EVENT as B, type CompiledAgentBundle as C, type WorkspaceAgentDispatcherSendInput as D, createAgentAssetDigest as E, type FileSearch as F, createAgentDefinitionDigest as G, createAgentDeploymentDigest as H, InMemoryShareEntryStore as I, resolveShareEntry as J, validateAgentDefinition as K, validateAgentDeployment as L, OpaqueRefSchema as O, type PluginRestartWarning as P, type SandboxHandleStore as S, type WorkspaceAgentDispatcherContext as W, type SandboxHandleRecord as a, type Sha256Digest as b, type ShareEntryStore as c, type WorkspaceAgentDispatcher as d, SchemaValidationError as e, type AgentSchemaIssue as f, type AgentSchemaValidationResult as g, type AgentDefinition as h, type AgentDefinitionDigestAsset as i, type AgentDefinitionReference as j, AgentDefinitionValidationError as k, AgentDeploymentValidationError as l, type CommandNotifyPayload as m, type CompiledAgentDefinition as n, type CreateShareEntryInput as o, OpaqueShareLocatorIdSchema as p, Sha256DigestSchema as q, ShareEntryErrorCode as r, type ShareEntryProvenance as s, ShareEntryProvenanceSchema as t, type ShareEntryResolution as u, type ShareEntryTombstone as v, type ShareEntryV1 as w, ShareEntryV1Schema as x, ShareEntryValidationError as y, WORKSPACE_AGENT_PLUGINS_RELOADED_EVENT as z };

package/docs/ERROR_CODES.md

@@ -86,6 +86,8 @@ All API failures must use the response envelope:
 | `PROVISIONING_ARTIFACT_FAILED` | Runtime-mode adapter failed to prepare/upload install artifact | 500 | retry | error | stable (public API) |
 | `ERR_NOT_IMPLEMENTED_UNTIL_T1` | Headless core method exists but the durable T1 implementation has not landed yet | 501 | retry-after-upgrade | warn | stable (public API) |
 | `INTERNAL_ERROR` | Catch-all internal failure | 500 | report-bug | error | internal (may change) |
+| `AR1_SHARE_NOT_FOUND` | `GET /a/:id` deep link: no such Lane W share entry, or the entry belongs to a workspace the requester is not authorized/scoped to (identical response either way — no existence oracle) | 404 | user-fix | warn | stable (public API) |
+| `AR1_SHARE_TOMBSTONED` | `GET /a/:id` deep link: share entry exists but its target file is gone; response renders provenance + last-known metadata, never a bare 404 | 200 | user-fix | warn | stable (public API) |
 
 ## Readiness error details
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-agent",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "type": "module",
   "license": "MIT",
   "description": "Pane-embeddable coding agent. Ships direct/local/vercel-sandbox execution modes behind one interface.",
@@ -84,7 +84,7 @@
     "use-stick-to-bottom": "^1.1.6",
     "yaml": "^2.9.0",
     "zod": "^3.25.76",
-    "@hachej/boring-ui-kit": "0.1.83"
+    "@hachej/boring-ui-kit": "0.1.85"
   },
   "devDependencies": {
     "@antithesishq/bombadil": "0.6.1",