@agent-surface/core 0.1.0 → 0.2.0

package/dist/index.d.ts

@@ -17,6 +17,35 @@ interface AgentRouteInfo {
     path: string;
     params?: Record<string, string>;
 }
+/**
+ * Concurrency group for an action or procedure reference (D25). Not
+ * model-visible: it is runtime behavior, not planning information.
+ *
+ * - `instance` (default) — every action on the registration shares one FIFO
+ *   queue. Safest: two actions on the same component can never interleave.
+ * - `capability` — one queue per capability, so a slow export does not block
+ *   closing a drawer.
+ * - `key` — one queue per author-chosen key, for actions that contend over
+ *   the same resource across capabilities.
+ * - `parallel` — bounded parallelism; `max` is required and must be ≥ 1.
+ *
+ * `queueDepth` overrides `limits.actionQueueDepth` for this group only.
+ */
+type AgentConcurrency = {
+    mode: "instance";
+    queueDepth?: number;
+} | {
+    mode: "capability";
+    queueDepth?: number;
+} | {
+    mode: "key";
+    key: string;
+    queueDepth?: number;
+} | {
+    mode: "parallel";
+    max: number;
+    queueDepth?: number;
+};
 interface AgentSurfaceLimits {
     maxComponentDescription: number;
     maxCapabilityDescription: number;
@@ -423,6 +452,9 @@ interface AgentActionDefinition<TIn extends JsonValue, TOut extends JsonValue |
     policies?: AgentPolicy[];
     meta?: Record<string, JsonValue>;
     timeoutMs?: number;
+    /** Concurrency group (D25). Default `{mode:"instance"}` — serialize with
+     *  every other action on this component instance. */
+    concurrency?: AgentConcurrency;
 }
 /** Identity helpers that fix generics for record-literal authoring. */
 declare function observation<TOut extends JsonValue>(def: AgentObservationDefinition<TOut>): AgentObservationDefinition<TOut>;
@@ -468,6 +500,10 @@ interface AgentProcedureBindingRuntimeConfig {
     /** Contextual description appended to the manifest description. */
     describe?: () => string;
     meta?: Record<string, JsonValue>;
+    /** Concurrency group (D25). Default: one group per procedure identity per
+     *  referencing registration — conservative, and it never couples a domain
+     *  call to unrelated view actions. */
+    concurrency?: AgentConcurrency;
 }
 interface AgentProcedureBinding<TIn extends object = object, TOut = unknown> {
     readonly kind: "procedure-binding";
@@ -771,7 +807,23 @@ interface AgentToolsetOptions {
      * its transport-timeout story, docs/09 §confirmation-topology).
      */
     confirmations?: "wait" | "two-phase";
+    /**
+     * Component-type prefixes this consumer may discover. D27: this is a
+     * **floor** — in "meta" mode a model-supplied `scope` can only narrow it
+     * further, never widen it. Not an authority boundary: `invoke` does not
+     * check scope in either mode (docs/09 §scope-is-discovery-only).
+     */
     scope?: string[];
+    /**
+     * [Experimental] Snapshot truncation budget for `surface_discover`.
+     * "meta" mode only — there the `truncated` marker rides in the payload the
+     * model reads. In "direct" mode a budget would silently drop tools with no
+     * signal to anyone, so it is rejected rather than half-honored.
+     */
+    budget?: {
+        maxComponents?: number;
+        maxBytes?: number;
+    };
 }
 interface AgentTool {
     /** Wire-safe name (docs/09 §wire-names), ≤ 64 chars. */
@@ -793,4 +845,4 @@ declare function createAgentToolset(registry: AgentSurfaceRegistry, options: Age
 /** Deep equality over JsonValue (order-sensitive for arrays, docs/06 rule 2). */
 declare function jsonDeepEqual(a: JsonValue | undefined, b: JsonValue | undefined): boolean;
 
-export { AGENT_CAPABILITY_ERROR_CODES, type AgentActionContext, type AgentActionDefinition, type AgentActionDescriptor, type AgentAuthorizationContext, type AgentCapabilityDescriptorUnion, type AgentCapabilityErrorCode, type AgentCapabilityErrorPayload, type AgentComponentDefinition, type AgentComponentDescriptor, type AgentConsumer, type AgentEffect, type AgentEnvironment, type AgentErrorRetry, type AgentInvocation, type AgentInvocationPolicyContext, type AgentInvocationResult, type AgentObservationDefinition, type AgentObservationDescriptor, type AgentPlane, type AgentPolicy, type AgentPolicyContext, type AgentProcedureBinding, type AgentProcedureBindingRuntimeConfig, type AgentProcedureDescriptor, type AgentProcedureEffect, type AgentProcedureExecutor, type AgentProcedureRefDescriptor, type AgentReadContext, type AgentRegistrationHandle, type AgentRouteInfo, type AgentSchema, AgentSchemaError, type AgentSchemaIssue, AgentSurfaceDefinitionError, type AgentSurfaceDefinitionErrorCode, AgentSurfaceError, type AgentSurfaceEvent, type AgentSurfaceLimits, type AgentSurfaceRegistry, type AgentSurfaceSnapshot, type AgentTool, type AgentToolset, type AgentToolsetOptions, type AuditEvent, type AuditSink, CONFIRMATION_ESCALATION, type ConfirmationController, type ConfirmationEscalation, DEFAULT_LIMITS, type DiscoveryDecision, type InvokeOptions, type JsonSchema, type JsonValue, MAX_ID_LENGTH, MAX_WIRE_NAME_LENGTH, type ParsedCapabilityId, type PendingConfirmation, type PreconditionFailure, type ProcedureCallInfo, type RegistrationCandidate, type RegistryOptions, type SnapshotContext, type StandardSchemaV1, type Unsubscribe, action, audit, authenticated, composeInvokeChain, consoleAuditSink, createAgentSurfaceRegistry, createAgentToolset, decodeWireName, defineAgentComponent, emptyObjectSchema, encodeWireName, encodeWireNameForInstance, environment, evaluateDiscovery, formatDomainCapabilityId, formatViewCapabilityId, fromJsonSchema, fromStandardSchema, hasPermission, isAgentSurfaceError, isValidCapabilityName, isValidComponentType, isValidInstanceId, jsonDeepEqual, memoryAuditSink, observation, parseCapabilityId, rateLimit, requireConfirmation, tenantBoundary, validateComponentDefinition, validateJsonSchemaDocument, validateValueAgainstSchema };
+export { AGENT_CAPABILITY_ERROR_CODES, type AgentActionContext, type AgentActionDefinition, type AgentActionDescriptor, type AgentAuthorizationContext, type AgentCapabilityDescriptorUnion, type AgentCapabilityErrorCode, type AgentCapabilityErrorPayload, type AgentComponentDefinition, type AgentComponentDescriptor, type AgentConcurrency, type AgentConsumer, type AgentEffect, type AgentEnvironment, type AgentErrorRetry, type AgentInvocation, type AgentInvocationPolicyContext, type AgentInvocationResult, type AgentObservationDefinition, type AgentObservationDescriptor, type AgentPlane, type AgentPolicy, type AgentPolicyContext, type AgentProcedureBinding, type AgentProcedureBindingRuntimeConfig, type AgentProcedureDescriptor, type AgentProcedureEffect, type AgentProcedureExecutor, type AgentProcedureRefDescriptor, type AgentReadContext, type AgentRegistrationHandle, type AgentRouteInfo, type AgentSchema, AgentSchemaError, type AgentSchemaIssue, AgentSurfaceDefinitionError, type AgentSurfaceDefinitionErrorCode, AgentSurfaceError, type AgentSurfaceEvent, type AgentSurfaceLimits, type AgentSurfaceRegistry, type AgentSurfaceSnapshot, type AgentTool, type AgentToolset, type AgentToolsetOptions, type AuditEvent, type AuditSink, CONFIRMATION_ESCALATION, type ConfirmationController, type ConfirmationEscalation, DEFAULT_LIMITS, type DiscoveryDecision, type InvokeOptions, type JsonSchema, type JsonValue, MAX_ID_LENGTH, MAX_WIRE_NAME_LENGTH, type ParsedCapabilityId, type PendingConfirmation, type PreconditionFailure, type ProcedureCallInfo, type RegistrationCandidate, type RegistryOptions, type SnapshotContext, type StandardSchemaV1, type Unsubscribe, action, audit, authenticated, composeInvokeChain, consoleAuditSink, createAgentSurfaceRegistry, createAgentToolset, decodeWireName, defineAgentComponent, emptyObjectSchema, encodeWireName, encodeWireNameForInstance, environment, evaluateDiscovery, formatDomainCapabilityId, formatViewCapabilityId, fromJsonSchema, fromStandardSchema, hasPermission, isAgentSurfaceError, isValidCapabilityName, isValidComponentType, isValidInstanceId, jsonDeepEqual, memoryAuditSink, observation, parseCapabilityId, rateLimit, requireConfirmation, tenantBoundary, validateComponentDefinition, validateJsonSchemaDocument, validateValueAgainstSchema };

package/dist/index.js

@@ -645,7 +645,8 @@ var ACTION_KEYS = /* @__PURE__ */ new Set([
   "execute",
   "policies",
   "meta",
-  "timeoutMs"
+  "timeoutMs",
+  "concurrency"
 ]);
 var VIEW_EFFECTS = /* @__PURE__ */ new Set(["local-state", "navigation"]);
 var SERVER_EFFECTS = /* @__PURE__ */ new Set([
@@ -666,6 +667,29 @@ function checkMeta(meta, where, limits) {
     fail("LIMIT_EXCEEDED", `${where}: meta exceeds ${limits.maxMetaBytes} bytes`);
   }
 }
+function checkConcurrency(concurrency, where) {
+  if (concurrency === void 0) return;
+  if (typeof concurrency !== "object" || concurrency === null) {
+    fail("INVALID_DEFINITION", `${where}: concurrency must be an object`);
+  }
+  const { mode } = concurrency;
+  if (!["instance", "capability", "key", "parallel"].includes(mode)) {
+    fail("INVALID_DEFINITION", `${where}: invalid concurrency mode "${String(mode)}"`);
+  }
+  if (mode === "key" && (typeof concurrency.key !== "string" || concurrency.key.length === 0)) {
+    fail("INVALID_DEFINITION", `${where}: concurrency mode "key" requires a non-empty key`);
+  }
+  if (mode === "parallel" && (typeof concurrency.max !== "number" || !Number.isInteger(concurrency.max) || concurrency.max < 1)) {
+    fail(
+      "INVALID_DEFINITION",
+      `${where}: concurrency mode "parallel" requires an integer max \u2265 1 (unbounded parallelism is not offered)`
+    );
+  }
+  const depth = concurrency.queueDepth;
+  if (depth !== void 0 && (!Number.isInteger(depth) || depth < 0)) {
+    fail("INVALID_DEFINITION", `${where}: concurrency queueDepth must be a non-negative integer`);
+  }
+}
 function checkSchema(schema, where, limits) {
   if (schema === void 0) return;
   if (typeof schema !== "object" || schema === null || typeof schema.parse !== "function" || typeof schema.jsonSchema !== "object") {
@@ -774,6 +798,7 @@ function validateComponentDefinition(def, limits, opts) {
     checkSchema(act.input, `${where} input`, limits);
     checkSchema(act.output, `${where} output`, limits);
     checkMeta(act.meta, where, limits);
+    checkConcurrency(act.concurrency, where);
   }
   const procedures = def.procedures ?? [];
   if (procedures.length > 0 && !opts.hasProcedureExecutor) {
@@ -803,6 +828,7 @@ function validateComponentDefinition(def, limits, opts) {
       fail("INVALID_DEFINITION", `procedure "${ref.path}": invalid confirmation escalation`);
     }
     checkMeta(binding.config.meta, `procedure "${ref.path}"`, limits);
+    checkConcurrency(binding.config.concurrency, `procedure "${ref.path}"`);
   }
 }
 
@@ -1354,7 +1380,8 @@ function normalizeRegistration(def, id) {
       auditLevel: act.audit ?? "metadata",
       meta: act.meta ? jsonClone(act.meta) : void 0,
       timeoutMs: act.timeoutMs,
-      policies: [...act.policies ?? []]
+      policies: [...act.policies ?? []],
+      concurrency: act.concurrency
     });
   }
   const hasView = observations.size > 0 || actions.size > 0;
@@ -1386,7 +1413,8 @@ function normalizeRegistration(def, id) {
       auditLevel: defaultAuditFor(effect),
       meta: binding.config.meta ? jsonClone(binding.config.meta) : void 0,
       policies: [...binding.config.policies ?? []],
-      contextLink: binding.contextLink ?? (hasView ? { type: def.type, instanceId } : void 0)
+      contextLink: binding.contextLink ?? (hasView ? { type: def.type, instanceId } : void 0),
+      concurrency: binding.config.concurrency
     };
   });
   return {
@@ -1410,9 +1438,27 @@ function normalizeRegistration(def, id) {
     enabled: def.enabled !== false,
     availabilityOverrides: /* @__PURE__ */ new Map(),
     inFlight: /* @__PURE__ */ new Set(),
-    actionQueue: { running: false, waiting: [] }
+    concurrencyGroups: /* @__PURE__ */ new Map()
   };
 }
+function concurrencyGroupFor(cap, limits) {
+  const declared = cap.kind === "action" ? cap.concurrency : cap.concurrency;
+  const fallbackDepth = limits.actionQueueDepth;
+  if (declared === void 0) {
+    return cap.kind === "action" ? { key: "instance", max: 1, depth: fallbackDepth } : { key: `proc:${cap.capabilityId}`, max: 1, depth: fallbackDepth };
+  }
+  const depth = declared.queueDepth ?? fallbackDepth;
+  switch (declared.mode) {
+    case "instance":
+      return { key: "instance", max: 1, depth };
+    case "capability":
+      return { key: `cap:${cap.capabilityId}`, max: 1, depth };
+    case "key":
+      return { key: `key:${declared.key}`, max: 1, depth };
+    case "parallel":
+      return { key: `par:${cap.capabilityId}`, max: declared.max, depth };
+  }
+}
 function liveAvailabilityHooks(reg, cap) {
   if (cap.kind === "observation") {
     const live = reg.definition.observations?.[cap.name];
@@ -2000,7 +2046,7 @@ async function executeAction(internals, args, cap) {
       }
     }
     const queueStart = internals.now();
-    const slot = await acquireActionSlot(internals, reg);
+    const slot = await acquireActionSlot(internals, reg, cap);
     args.setTimings({ queueWaitMs: internals.now() - queueStart });
     if (slot === "overflow") {
       return finalize({ status: "error", error: queueFull(250) });
@@ -2034,7 +2080,7 @@ async function executeAction(internals, args, cap) {
       args.setAuditPayload(void 0, output.value);
       return finalize({ status: "ok", output: output.value });
     } finally {
-      releaseActionSlot(reg);
+      releaseActionSlot(internals, reg, cap);
     }
   };
   return runInvokePolicies(args, parsedInput, run);
@@ -2102,40 +2148,50 @@ async function executeProcedure(internals, args, cap) {
       effect: cap.effect
     });
     if ("error" in confirmation) return finalize({ status: "error", error: confirmation.error });
-    const executor = internals.executor;
-    if (!executor) {
-      return finalize({ status: "error", error: executionFailed("transport") });
+    const queueStart = internals.now();
+    const slot = await acquireActionSlot(internals, reg, cap);
+    args.setTimings({ queueWaitMs: internals.now() - queueStart });
+    if (slot === "overflow") {
+      return finalize({ status: "error", error: queueFull(250) });
+    }
+    try {
+      const executor = internals.executor;
+      if (!executor) {
+        return finalize({ status: "error", error: executionFailed("transport") });
+      }
+      const timeoutMs = options?.timeoutMs ?? internals.limits.procedureTimeoutMs;
+      const executeStart = internals.now();
+      const outcome = await executeWithGuards(internals, reg, {
+        invocationId,
+        capabilityId: cap.capabilityId,
+        timeoutMs,
+        externalSignal: options?.signal,
+        idempotent: cap.idempotent,
+        run: (signal) => executor.execute({
+          path: cap.path,
+          input: effective,
+          info: {
+            invocationId,
+            consumer,
+            signal,
+            ...confirmation.evidence ? { confirmation: confirmation.evidence } : {}
+          }
+        }),
+        procedureErrors: true
+      });
+      args.setTimings({ executionMs: internals.now() - executeStart });
+      if (!outcome.ok) return finalize({ status: "error", error: outcome.payload });
+      const output = settleOutput(
+        internals,
+        outcome.value,
+        cap.outputJsonSchema ? fromJsonSchema(cap.outputJsonSchema) : void 0
+      );
+      if ("error" in output) return finalize({ status: "error", error: output.error });
+      args.setAuditPayload(void 0, output.value);
+      return finalize({ status: "ok", output: output.value });
+    } finally {
+      releaseActionSlot(internals, reg, cap);
     }
-    const timeoutMs = options?.timeoutMs ?? internals.limits.procedureTimeoutMs;
-    const executeStart = internals.now();
-    const outcome = await executeWithGuards(internals, reg, {
-      invocationId,
-      capabilityId: cap.capabilityId,
-      timeoutMs,
-      externalSignal: options?.signal,
-      idempotent: cap.idempotent,
-      run: (signal) => executor.execute({
-        path: cap.path,
-        input: effective,
-        info: {
-          invocationId,
-          consumer,
-          signal,
-          ...confirmation.evidence ? { confirmation: confirmation.evidence } : {}
-        }
-      }),
-      procedureErrors: true
-    });
-    args.setTimings({ executionMs: internals.now() - executeStart });
-    if (!outcome.ok) return finalize({ status: "error", error: outcome.payload });
-    const output = settleOutput(
-      internals,
-      outcome.value,
-      cap.outputJsonSchema ? fromJsonSchema(cap.outputJsonSchema) : void 0
-    );
-    if ("error" in output) return finalize({ status: "error", error: output.error });
-    args.setAuditPayload(void 0, output.value);
-    return finalize({ status: "ok", output: output.value });
   };
   return runInvokePolicies(args, effective, run);
 }
@@ -2384,21 +2440,32 @@ function executeWithGuards(internals, reg, opts) {
     }
   });
 }
-async function acquireActionSlot(internals, reg) {
-  if (!reg.actionQueue.running) {
-    reg.actionQueue.running = true;
+async function acquireActionSlot(internals, reg, cap) {
+  const { key, max, depth } = concurrencyGroupFor(cap, internals.limits);
+  let group = reg.concurrencyGroups.get(key);
+  if (!group) {
+    group = { running: 0, max, depth, waiting: [] };
+    reg.concurrencyGroups.set(key, group);
+  }
+  if (group.running < group.max) {
+    group.running += 1;
     return "ok";
   }
-  if (reg.actionQueue.waiting.length >= internals.limits.actionQueueDepth) {
+  if (group.waiting.length >= group.depth) {
+    if (group.running === 0 && group.waiting.length === 0) reg.concurrencyGroups.delete(key);
     return "overflow";
   }
-  await new Promise((resolve) => reg.actionQueue.waiting.push(resolve));
+  await new Promise((resolve) => group.waiting.push(resolve));
   return "ok";
 }
-function releaseActionSlot(reg) {
-  const next = reg.actionQueue.waiting.shift();
-  if (next) next();
-  else reg.actionQueue.running = false;
+function releaseActionSlot(internals, reg, cap) {
+  const { key } = concurrencyGroupFor(cap, internals.limits);
+  const group = reg.concurrencyGroups.get(key);
+  if (!group) return;
+  const next = group.waiting.shift();
+  if (!next) group.running -= 1;
+  else next();
+  if (group.running === 0 && group.waiting.length === 0) reg.concurrencyGroups.delete(key);
 }
 function acquireObservationSlot(internals, consumerKey) {
   const adm = internals.observationAdmission;
@@ -2943,6 +3010,11 @@ function createAgentToolset(registry, options) {
       "createAgentToolset: declare a topology ('embedded' | 'remote') or an explicit confirmations mode ('wait' | 'two-phase'). Embedded loops default to 'wait', remote loops to 'two-phase' (docs/09 \xA7confirmation-topology)."
     );
   }
+  if (options.budget !== void 0 && mode !== "meta") {
+    throw new Error(
+      "createAgentToolset: `budget` applies to mode 'meta' only \u2014 in 'direct' mode it would silently drop tools. Pass a `scope` to bound a direct catalog instead (docs/09 \xA7meta-tools-mode)."
+    );
+  }
   const confirmationsMode = options.confirmations ?? (options.topology === "remote" ? "two-phase" : "wait");
   const listeners = /* @__PURE__ */ new Set();
   const pendingWaits = /* @__PURE__ */ new Set();
@@ -2960,15 +3032,16 @@ function createAgentToolset(registry, options) {
       pendingWaits.delete(controller);
     }
   }
-  async function invokeThroughSurface(entry, input, toolCallId) {
-    const invocationId = toolCallId ?? `inv_${randomBase62(12)}`;
+  async function invokeThroughSurface(entry, input, toolCallId, overrides) {
+    const invocationId = overrides?.invocationId ?? toolCallId ?? `inv_${randomBase62(12)}`;
     const base = {
       invocationId,
       capabilityId: entry.capabilityId,
       ...entry.instanceId !== void 0 ? { instanceId: entry.instanceId } : {},
-      registrationId: entry.registrationId,
+      ...entry.registrationId !== void 0 ? { registrationId: entry.registrationId } : {},
       surfaceVersion: entry.surfaceVersion,
-      ...input !== void 0 ? { input } : {}
+      ...input !== void 0 ? { input } : {},
+      ...overrides?.confirmationId !== void 0 ? { confirmationId: overrides.confirmationId } : {}
     };
     let result = await registry.invoke(base, { consumer: options.consumer });
     if (confirmationsMode === "wait" && result.status === "error" && result.error.code === "CONFIRMATION_REQUIRED") {
@@ -3065,16 +3138,19 @@ function createAgentToolset(registry, options) {
           additionalProperties: false
         },
         async execute(input) {
-          const scope = input?.scope;
+          const requested = input?.scope;
+          const effective = intersectScope(options.scope, requested);
           const snapshot = registry.snapshot({
             consumer: options.consumer,
-            ...scope ? { scope } : options.scope ? { scope: options.scope } : {}
+            ...effective.scope ? { scope: effective.scope } : {},
+            ...options.budget ? { budget: options.budget } : {}
           });
+          const projected = effective.empty ? { ...snapshot, components: [], procedures: [] } : snapshot;
           return {
             status: "ok",
             invocationId: `inv_${randomBase62(12)}`,
             capabilityId: "meta:surface.discover",
-            output: JSON.parse(JSON.stringify(snapshot)),
+            output: JSON.parse(JSON.stringify(projected)),
             surfaceVersion: snapshot.surfaceVersion
           };
         }
@@ -3094,10 +3170,12 @@ function createAgentToolset(registry, options) {
         async execute(input, call) {
           const req = input;
           const snapshot = snapshotFor();
+          const registrationId = findRegistrationId(snapshot, req.capabilityId, req.instanceId);
           return invokeThroughSurface(
             {
               capabilityId: req.capabilityId,
-              registrationId: findRegistrationId(snapshot, req.capabilityId, req.instanceId) ?? "",
+              // Unresolved → let the registry answer (AS-ADAPTER-003).
+              ...registrationId !== void 0 ? { registrationId } : {},
               ...req.instanceId !== void 0 ? { instanceId: req.instanceId } : {},
               surfaceVersion: snapshot.surfaceVersion,
               kind: "observation"
@@ -3125,36 +3203,22 @@ function createAgentToolset(registry, options) {
         async execute(input, call) {
           const req = input;
           const snapshot = snapshotFor();
-          const invocationId = req.invocationId ?? call.toolCallId ?? `inv_${randomBase62(12)}`;
-          let result = await registry.invoke(
+          const registrationId = findRegistrationId(snapshot, req.capabilityId, req.instanceId);
+          return invokeThroughSurface(
             {
-              invocationId,
               capabilityId: req.capabilityId,
+              ...registrationId !== void 0 ? { registrationId } : {},
               ...req.instanceId !== void 0 ? { instanceId: req.instanceId } : {},
-              ...findRegistrationId(snapshot, req.capabilityId, req.instanceId) ? { registrationId: findRegistrationId(snapshot, req.capabilityId, req.instanceId) } : {},
               surfaceVersion: snapshot.surfaceVersion,
-              ...req.input !== void 0 ? { input: req.input } : {},
-              ...req.confirmationId !== void 0 ? { confirmationId: req.confirmationId } : {}
+              kind: "action"
             },
-            { consumer: options.consumer }
+            req.input,
+            call.toolCallId,
+            {
+              ...req.invocationId !== void 0 ? { invocationId: req.invocationId } : {},
+              ...req.confirmationId !== void 0 ? { confirmationId: req.confirmationId } : {}
+            }
           );
-          if (confirmationsMode === "wait" && result.status === "error" && result.error.code === "CONFIRMATION_REQUIRED" && typeof result.error.details?.confirmationId === "string") {
-            const confirmationId = result.error.details.confirmationId;
-            await waitForConfirmation(confirmationId);
-            if (disposed) return result;
-            result = await registry.invoke(
-              {
-                invocationId,
-                capabilityId: req.capabilityId,
-                ...req.instanceId !== void 0 ? { instanceId: req.instanceId } : {},
-                surfaceVersion: snapshot.surfaceVersion,
-                ...req.input !== void 0 ? { input: req.input } : {},
-                confirmationId
-              },
-              { consumer: options.consumer }
-            );
-          }
-          return result;
         }
       }
     ];
@@ -3178,6 +3242,7 @@ function createAgentToolset(registry, options) {
   const unsubscribe = registry.subscribe((event) => {
     if (disposed || event.type !== "surface-changed") return;
     cachedVersion = void 0;
+    if (mode === "meta") return;
     const tools = computeTools();
     const signature = signatureOf(tools);
     if (signature === cachedSignature) return;
@@ -3210,6 +3275,21 @@ function createAgentToolset(registry, options) {
     }
   };
 }
+function intersectScope(floor, requested) {
+  const hasFloor = floor !== void 0 && floor.length > 0;
+  if (requested === void 0 || requested.length === 0) {
+    return hasFloor ? { scope: floor, empty: false } : { empty: false };
+  }
+  if (!hasFloor) return { scope: requested, empty: false };
+  const out = /* @__PURE__ */ new Set();
+  for (const f of floor) {
+    for (const r of requested) {
+      if (r === f || r.startsWith(`${f}.`)) out.add(r);
+      else if (f.startsWith(`${r}.`)) out.add(f);
+    }
+  }
+  return out.size > 0 ? { scope: [...out], empty: false } : { empty: true };
+}
 function findRegistrationId(snapshot, capabilityId, instanceId) {
   const matches = [];
   for (const component of snapshot.components) {