@zackbart/connecta 0.34.1 → 0.35.0

package/dist/registry.js

@@ -1,28 +1,33 @@
-import { markCatalogFreshness, carryCatalogFreshness } from "./catalog-freshness.js";
+import { authCall, authInvoke } from "./auth/native.js";
+import { Clock, Duration, Effect, Random } from "effect";
 import { activityRequest } from "./activity-request.js";
-import { attachCatalogCache, catalogExpiry, customCatalogFallback, storeCustomCatalogFallback, catalogFetchedAt, invalidateCatalogCache, observeUncachedCatalogRefresh, } from "./catalog-cache.js";
+import { aggregateCallAdmissionSnapshots, ConnectorCallAdmissionController, } from "./call-admission.js";
+import { attachCatalogCache, catalogExpiry, catalogFetchedAt, customCatalogFallback, invalidateCatalogCache, observeUncachedCatalogRefresh, storeCustomCatalogFallback, } from "./catalog-cache.js";
+import { carryCatalogFreshness, markCatalogFreshness } from "./catalog-freshness.js";
+import { MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTES } from "./catalog-limits.js";
 import { CONFIG_DEFAULTS } from "./config-defaults.js";
-import { assertStaticToolNames, hasControlCharacters } from "./tool-name.js";
-import { Clock, Duration, Effect, Random } from "effect";
+import { usesCallerIdentity } from "./connector-caller.js";
+import { canonicalJson } from "./canonical-json.js";
 import { storedCredentialShape } from "./credential-rules.js";
 import { ConnectorCallError } from "./errors.js";
+import { attachOAuthPartition, oauthPartitionIdle } from "./oauth-partition.js";
+import { attachOAuthSealer, vaultOAuthSealer } from "./oauth-sealing.js";
 import { boundedStatus, failureRecord, failureStatus, logFailure, ownStatus } from "./operator-record.js";
-import { ConnectorCallAdmissionController, aggregateCallAdmissionSnapshots, } from "./call-admission.js";
-import { boundedCatalogDrift, catalogReviewOf, classifyCatalog, observeReviewedDrift, observedCatalogDrift, } from "./catalog-drift.js";
-import { MAX_CATALOG_TOOLS, MAX_SERIALIZED_CATALOG_BYTES } from "./catalog-limits.js";
 import { ObservedOutputSchemas } from "./result-shapes.js";
+import { ContinuationBinding, OperationCredentials, ContinuationStorage, operationView, setViewService, duringViewEffect, } from "./runtime/call.js";
+import { hasNativeStorage, registerNativeStorage } from "./runtime/native-storage.js";
+import { provideRegistryPrograms, registryEdgeProgram, registryProgram } from "./runtime/registry.js";
+import { causeError, runEdge } from "./runtime/run.js";
+import { Storage } from "./runtime/services.js";
+import { SharedRead } from "./runtime/shared-read.js";
+import { runOnPartition, storageCompareAndSet, storageDelete, storageGet, storageSet, storageList, } from "./runtime/storage.js";
 import { redactCatalog, sentSecretsFor, sentSecretsForRequest, trackCredentialReads } from "./sent-secrets.js";
 import { GUIDE_SUMMARY_LENGTH, normalizeGuideSummary } from "./skills.js";
-import { attachOAuthSealer, vaultOAuthSealer } from "./oauth-sealing.js";
-import { attachOAuthPartition, oauthPartitionIdle } from "./oauth-partition.js";
-import { attachCaller } from "./connector-caller.js";
+import { jsonCodec, OAUTH_HANDOFF_TTL_SECONDS, oauthHandoffKeys, resultKeys, scopes, stashExpiryKeys, stashLedgerKeys, } from "./storage/keys.js";
+import { assertStaticToolNames, hasControlCharacters } from "./tool-name.js";
+import { carryToolClassification, classifyTool } from "./tool-safety.js";
 import { isWorkspaceAddress } from "./workspace-address.js";
 import { workspaceSubjectOf } from "./workspace-subject.js";
-import { runEdge } from "./runtime/run.js";
-import { SharedRead } from "./runtime/shared-read.js";
-import { runOnPartition, storageCompareAndSet, storageDelete, storageGet, storageSet } from "./runtime/storage.js";
-import { jsonCodec, OAUTH_HANDOFF_TTL_SECONDS, oauthHandoffKeys, resultKeys, scopes, stashLedgerKeys, stashExpiryKeys, } from "./storage/keys.js";
-import { classifyTool } from "./tool-safety.js";
 const ID_RE = /^[a-z0-9_-]+$/;
 const DEFAULT_MAX_RESULT_BYTES = CONFIG_DEFAULTS.calls.maxResultBytes;
 const encoder = new TextEncoder();
@@ -74,7 +79,7 @@ export function isValidMaxResultBytes(value) {
 export function resolveMaxResultBytes(value, inherited) {
     return value !== undefined && isValidMaxResultBytes(value) ? value : inherited;
 }
-/** Freeze registry-owned facts so review digest memoization remains valid. */
+/** Freeze registry-owned catalog facts before caching. */
 function frozenFacts(tools) {
     const pending = [tools];
     while (pending.length > 0) {
@@ -88,7 +93,7 @@ function frozenFacts(tools) {
     return tools;
 }
 function namespaced(storage, prefix) {
-    return {
+    const edge = {
         capabilities: storage.capabilities,
         get: (k) => storage.get(prefix + k),
         set: (k, v, o) => storage.set(prefix + k, v, o),
@@ -96,6 +101,18 @@ function namespaced(storage, prefix) {
         list: async (keyPrefix) => (await storage.list(prefix + keyPrefix)).map((key) => key.slice(prefix.length)),
         compareAndSet: (k, expected, next, o) => storage.compareAndSet(prefix + k, expected, next, o),
     };
+    return hasNativeStorage(storage)
+        ? registerNativeStorage(edge, {
+            // Select against the underlying current methods at dispatch. A
+            // namespace created during a decoration regains the native path when
+            // that decoration is restored, without capturing stale capabilities.
+            get: (key) => storageGet(prefix + key).pipe(Effect.provideService(Storage, storage)),
+            set: (key, value, options) => storageSet(prefix + key, value, options).pipe(Effect.provideService(Storage, storage)),
+            delete: (key) => storageDelete(prefix + key).pipe(Effect.provideService(Storage, storage)),
+            list: (keyPrefix) => storageList(prefix + keyPrefix).pipe(Effect.provideService(Storage, storage), Effect.map((keys) => keys.map((key) => key.slice(prefix.length)))),
+            compareAndSet: (key, expected, next, options) => storageCompareAndSet(prefix + key, expected, next, options).pipe(Effect.provideService(Storage, storage)),
+        })
+        : edge;
 }
 const MAX_PERSONAL_REGISTRIES = 1_024;
 const MAX_ABSENT_GRANT_WARNINGS = 1_024;
@@ -231,6 +248,7 @@ export class Registry {
     catalogAccess = new Map();
     /** Bounded tokens isolating count-only observations by catalog identity. */
     catalogObservationPartitions = new Map();
+    overrideWarningCatalogs = new WeakMap();
     observedOutputSchemas;
     /** Result-size guard cap threaded to the meta-tools. */
     maxResultBytes;
@@ -271,11 +289,6 @@ export class Registry {
                     `normalization; the discovery bound is ${GUIDE_SUMMARY_LENGTH}. ` +
                     "Shorten it or omit it to derive one.");
             }
-            // Validated here, before any request (INV-11), and read once per
-            // connector object.
-            if (catalogReviewOf(c) && c.staticTools) {
-                throw new Error(`Connector "${c.id}" declares both staticTools and a classification; ` + "annotate static tools directly.");
-            }
             this.connectors.set(c.id, c);
             if (c.callAdmission !== undefined) {
                 this.callAdmission.set(c.id, new ConnectorCallAdmissionController(c.id, c.callAdmission));
@@ -288,8 +301,8 @@ export class Registry {
         Object.freeze(this.classification);
         for (const [id, overrides] of Object.entries(this.classification)) {
             for (const [name, verdict] of Object.entries(overrides)) {
-                if (!name || (verdict !== "read" && verdict !== "write")) {
-                    throw new Error(`ConnectaConfig.classification.${id}.${name}: expected "read" or "write"`);
+                if (!name || (verdict !== "read" && verdict !== "write" && verdict !== "hidden")) {
+                    throw new Error(`ConnectaConfig.classification.${id}.${name}: expected "read", "write", or "hidden"`);
                 }
             }
             const connector = this.connectors.get(id);
@@ -326,6 +339,7 @@ export class Registry {
             ...this.opts,
             classification: Object.fromEntries(Object.entries(this.classification).filter(([id]) => this.connectors.get(id)?.authScope === "personal")),
             storage: namespaced(this.opts.storage, scopes.principal(principalKey)),
+            rootStorage: this.opts.rootStorage ?? this.opts.storage,
             credentialOwner: principalKey,
             catalogStorage: this.opts.catalogStorage ?? this.opts.storage,
             constructionChecks: false,
@@ -373,45 +387,14 @@ export class Registry {
         const quoted = JSON.stringify(key).replace(/[\u2028\u2029]/g, (ch) => `\\u${ch.charCodeAt(0).toString(16)}`);
         this.opts.logger.warn(`a pool grants ${quoted} but connector "${connectorId}" lists no such tool; the grant is unreachable`);
     }
-    async storeOAuthHandoff(connectorId, state, principalKey) {
-        const key = oauthHandoffKeys.handoff(connectorId, await sha256Hex(state));
-        for (let attempt = 0; attempt < 32; attempt++) {
-            const existing = await this.opts.storage.get(key);
-            if (existing && existing !== principalKey) {
-                throw new Error(`Connector "${connectorId}" reused one OAuth state across principals`);
-            }
-            // Bind ownership atomically, including renewal of the same owner's
-            // handoff. Two owners reading a miss must not overwrite each other.
-            if (await this.opts.storage.compareAndSet(key, existing, principalKey, {
-                ttlSeconds: OAUTH_HANDOFF_TTL_SECONDS,
-            }))
-                return;
-        }
-        throw new Error(`OAuth handoff for "${connectorId}" is busy; retry authorization`);
+    storeOAuthHandoff(connectorId, state, principalKey) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "storeOAuthHandoff", connectorId, state, principalKey));
     }
-    async oauthCallbackView(connectorId, state) {
-        if (!state)
-            return null;
-        const principalKey = await this.opts.storage.get(oauthHandoffKeys.handoff(connectorId, await sha256Hex(state)));
-        const connector = this.connectors.get(connectorId);
-        if (!connector || !principalKey)
-            return null;
-        return {
-            registry: connector.authScope === "personal"
-                ? this.scoped({
-                    connectorIds: [connectorId],
-                    subjectKey: principalKey,
-                    principalKey,
-                })
-                : this,
-            principalKey,
-        };
+    oauthCallbackView(connectorId, state) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "oauthCallbackView", connectorId, state));
     }
-    async consumeOAuthHandoff(connectorId, state, principalKey) {
-        if (!state)
-            return false;
-        const key = oauthHandoffKeys.handoff(connectorId, await sha256Hex(state));
-        return this.opts.storage.compareAndSet(key, principalKey, null);
+    consumeOAuthHandoff(connectorId, state, principalKey) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "consumeOAuthHandoff", connectorId, state, principalKey));
     }
     /**
      * Refuse an unusable result cap at construction, like every other
@@ -465,18 +448,22 @@ export class Registry {
         return this.connectors.has(id);
     }
     contextFor(id, baseUrl, requestScope = {}, callOptions = {}, scope) {
-        const credentialConfig = this.connectors.get(id)?.credential;
+        const connector = this.connectors.get(id);
+        const credentialConfig = connector?.credential;
         let credentialAccess;
+        let credentialProgram;
         if (this.opts.credentialVault && credentialConfig) {
             const vault = this.opts.credentialVault;
-            const readValues = async () => {
-                const values = await vault.getAll(id, this.opts.credentialOwner);
+            credentialProgram = Effect.tryPromise({
+                try: () => vault.getAll(id, this.opts.credentialOwner),
+                catch: (error) => error,
+            }).pipe(Effect.flatMap((values) => {
                 const shape = storedCredentialShape(credentialConfig, values);
-                if (shape.state === "mismatch") {
-                    throw new ConnectorCallError("auth_required", shape.message);
-                }
-                return values;
-            };
+                return shape.state === "mismatch"
+                    ? Effect.fail(new ConnectorCallError("auth_required", shape.message))
+                    : Effect.succeed(values);
+            }));
+            const readValues = () => runEdge(credentialProgram);
             credentialAccess = {
                 get: async (field = "value") => {
                     const values = await readValues();
@@ -485,7 +472,7 @@ export class Registry {
                 getAll: readValues,
             };
         }
-        const context = {
+        const context = operationView({
             storage: namespaced(this.opts.storage, scopes.connector(id)),
             logger: this.opts.logger,
             baseUrl,
@@ -494,8 +481,16 @@ export class Registry {
             ...(credentialAccess ? { credential: credentialAccess } : {}),
             requestScope,
             ...callOptions,
-        };
-        attachCaller(context, scope?.caller);
+        }, scope?.caller);
+        setViewService(context, OperationCredentials, credentialProgram);
+        setViewService(context, ContinuationStorage, this.opts.rootStorage ?? this.opts.storage);
+        const owner = this.opts.credentialOwner ?? null;
+        setViewService(context, ContinuationBinding, {
+            connection: id,
+            // Include every admitted input a subject mapping can inspect, including
+            // the pool owner for an agent. This value enters only the HMAC claims.
+            principal: connector && usesCallerIdentity(connector) ? canonicalJson([owner, scope?.caller ?? null]) : owner,
+        });
         attachCatalogCache(context, {
             storage: this.opts.catalogStorage ?? this.opts.storage,
             partition: this.catalogPartition(scope),
@@ -564,17 +559,6 @@ export class Registry {
         }
         return partition;
     }
-    catalogDriftOf(connector, baseUrl, scope) {
-        const partition = this.catalogObservationPartition(connector.id, baseUrl, scope);
-        const observed = partition ? observedCatalogDrift(connector, partition) : undefined;
-        // Plugin reports cannot establish a reviewed baseline or schema coverage
-        // that this registry has not checked. Personal plugin seams have no subject
-        // parameter and must never bypass the partition above.
-        const fallback = !observed && !catalogReviewOf(connector) && connector.authScope !== "personal"
-            ? connector.catalogDrift?.()
-            : undefined;
-        return boundedCatalogDrift(observed ?? (fallback ? { ...fallback, reviewedBaseline: false } : undefined));
-    }
     /** Reject queued/future downstream admission; active permits release safely. */
     closeCallAdmission() {
         this.callAdmissionClosed = true;
@@ -602,88 +586,7 @@ export class Registry {
      * stop waiting after 15 seconds. Storage TTL reclaims the rows.
      */
     stashResult(id, chunks, ttlSeconds, partition = scopes.results) {
-        return runOnPartition(Effect.gen({ self: this }, function* () {
-            const maxBytes = this.opts.results?.maxStashBytes ?? CONFIG_DEFAULTS.results.maxStashBytes;
-            const maxEntries = this.opts.results?.maxStashEntries ?? CONFIG_DEFAULTS.results.maxStashEntries;
-            // The paging envelope is ASCII, so its string length is its stored byte count.
-            const bytes = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-            if (bytes > maxBytes || maxEntries === 0)
-                return false;
-            const keys = chunks.map((_, index) => partition + resultKeys.chunk(id, index));
-            // IDs belong to reservations, not reusable result IDs or subjects.
-            const charge = crypto.randomUUID();
-            const ttlMs = ttlSeconds * 1000;
-            if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0)
-                return false;
-            const booking = yield* swapStashLedger((live, now) => {
-                // A committed CAS with a lost response is already our booking, even
-                // at full capacity. Reuse its deadline instead of adding a second slot.
-                const own = live.find((entry) => entry[0] === charge);
-                if (own)
-                    return { result: own[2] };
-                const used = live.reduce((sum, entry) => sum + entry[1], 0);
-                if (live.length >= maxEntries || used + bytes > maxBytes)
-                    return { result: undefined };
-                const deadline = now + STASH_WRITE_TIMEOUT_MS + ttlMs;
-                if (!Number.isSafeInteger(deadline))
-                    return { result: undefined };
-                return { entries: [...live, [charge, bytes, deadline]], result: deadline };
-            });
-            if (booking.status === "exhausted" || booking.result === undefined)
-                return false;
-            const deadline = booking.result;
-            const writeDeadline = deadline - ttlMs;
-            const chunkExpiry = deadline - STASH_WRITE_TIMEOUT_MS;
-            const owns = (entry) => entry[0] === charge;
-            const settle = swapStashLedger((live) => live.some((entry) => owns(entry) && entry[2] > chunkExpiry)
-                ? {
-                    entries: live.map((entry) => (owns(entry) ? [charge, bytes, Math.min(entry[2], chunkExpiry)] : entry)),
-                    result: undefined,
-                }
-                : { result: undefined });
-            let pendingWrite = false;
-            // A rejected or timed-out driver call may still commit after deletion.
-            // Only a confirmed write response clears pendingWrite.
-            const release = completeStash(Effect.gen(function* () {
-                const deleted = yield* Effect.gen(function* () {
-                    for (const key of keys)
-                        yield* storageDelete(key);
-                    return true;
-                }).pipe(Effect.catch(() => Effect.succeed(false)));
-                if (pendingWrite)
-                    return;
-                if (deleted) {
-                    const released = yield* swapStashLedger((live) => live.some(owns)
-                        ? { entries: live.filter((entry) => !owns(entry)), result: undefined }
-                        : { result: undefined });
-                    if (released.status === "applied")
-                        return;
-                }
-                yield* settle;
-            }));
-            // Trailing chunks first, then the header. The caller receives no result
-            // ID after failure or timeout, including a late header commit.
-            const remaining = Math.max(0, writeDeadline - (yield* Clock.currentTimeMillis));
-            const written = yield* Effect.gen(function* () {
-                for (let index = keys.length - 1; index >= 0; index--) {
-                    const before = yield* Clock.currentTimeMillis;
-                    if (before >= writeDeadline || before >= chunkExpiry)
-                        return false;
-                    pendingWrite = true;
-                    yield* storageSet(keys[index], chunks[index], { expiresAtMs: chunkExpiry }).pipe(Effect.tap(() => Effect.sync(() => {
-                        pendingWrite = false;
-                    })));
-                    if ((yield* Clock.currentTimeMillis) >= writeDeadline)
-                        return false;
-                }
-                return true;
-            }).pipe(Effect.timeoutOrElse({ duration: Duration.millis(remaining), orElse: () => Effect.succeed(false) }), Effect.onError(() => release.pipe(Effect.ignore)));
-            if (!written)
-                yield* release;
-            else
-                yield* completeStash(settle);
-            return written;
-        }), this.opts);
+        return runOnPartition(registryEdgeProgram(Registry.prototype, this, "stashResult", id, chunks, ttlSeconds, partition), this.opts);
     }
     /**
      * Storage namespaced to the root result partition, kept separate from any
@@ -692,7 +595,7 @@ export class Registry {
     resultIdentity() {
         return { subject: null, principal: null, endpoint: "/mcp", origin: null };
     }
-    recheckResultAccess(_address, _classification, _signal, _access) {
+    recheckResultAccess(_dependencies, _classification, _signal) {
         return Promise.resolve(true);
     }
     resultsStorage() {
@@ -701,11 +604,8 @@ export class Registry {
     credentialUiAvailable() {
         return Boolean(this.opts.credentialUi);
     }
-    async bindOAuthHandoff(id, authorizationUrl, principalKey) {
-        const state = new URL(authorizationUrl).searchParams.get("state");
-        if (!state || !principalKey)
-            throw new Error("OAuth requires state and an initiating user");
-        await this.storeOAuthHandoff(id, state, principalKey);
+    bindOAuthHandoff(id, authorizationUrl, principalKey) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "bindOAuthHandoff", id, authorizationUrl, principalKey));
     }
     observedOutputSchema(connectorId, definition) {
         return this.observedOutputSchemas.get(connectorId, definition);
@@ -741,56 +641,43 @@ export class Registry {
                 ...(connector.authScope === "personal" ? { personal: true } : {}),
             }, activityRequest(ctx.requestScope));
     }
-    async loadDownstreamTools(id, baseUrl, requestScope, callOptions = {}, scope) {
-        const connector = this.connectors.get(id);
-        if (!connector)
-            throw new Error(`Unknown connector "${id}"`);
-        if (connector.staticTools)
-            return { tools: markCatalogFreshness(connector.staticTools, Infinity), verification: undefined };
-        const ctx = this.contextFor(id, baseUrl, requestScope, callOptions, scope);
-        let listed;
-        try {
-            listed = await connector.listTools(ctx);
-        }
-        catch (error) {
-            const fallback = error instanceof ConnectorCallError && error.code === "unavailable"
-                ? await customCatalogFallback(ctx, id).catch(() => undefined)
-                : undefined;
-            if (!fallback)
-                throw sentSecretsForRequest(ctx.requestScope ?? ctx).redact(error);
-            listed = fallback;
-        }
-        const tools = redactCatalog(ctx, listed).map(({ classification: _ignored, ...fact }) => fact);
-        if (tools.length > MAX_CATALOG_TOOLS ||
-            encoder.encode(JSON.stringify(tools)).byteLength > MAX_SERIALIZED_CATALOG_BYTES) {
-            throw new ConnectorCallError("connector_call_failed", "Downstream catalog exceeds the complete-catalog ceiling.", { retryable: false });
-        }
-        const facts = frozenFacts(structuredClone(tools));
-        const accepted = this.acceptToolNames(facts);
-        const review = catalogReviewOf(connector);
-        const verification = await observeReviewedDrift(connector, review, accepted, this.opts.logger, this.catalogObservationPartition(id, baseUrl, scope, true), facts.length - accepted.length);
-        if (catalogFetchedAt(ctx) === undefined) {
-            try {
-                await storeCustomCatalogFallback(ctx, id, facts);
-            }
-            catch (error) {
-                logFailure(this.opts.logger, "catalog refresh observation failed", failureRecord({ connector: id }, error));
-            }
-            try {
-                await observeUncachedCatalogRefresh(ctx, id, facts);
+    loadDownstreamTools(id, baseUrl, requestScope, callOptions = {}, scope) {
+        return Effect.gen({ self: this }, function* () {
+            const connector = this.connectors.get(id);
+            if (!connector)
+                throw new Error(`Unknown connector "${id}"`);
+            if (connector.staticTools)
+                return markCatalogFreshness(connector.staticTools, Infinity);
+            const ctx = this.contextFor(id, baseUrl, requestScope, callOptions, scope);
+            const listed = yield* authInvoke(connector, "listTools", [ctx]).pipe(Effect.catch((error) => Effect.gen(function* () {
+                const fallback = error instanceof ConnectorCallError && error.code === "unavailable"
+                    ? yield* authCall(customCatalogFallback, [ctx, id]).pipe(Effect.catch(() => Effect.succeed(undefined)))
+                    : undefined;
+                return fallback
+                    ? fallback
+                    : yield* Effect.fail(sentSecretsForRequest(ctx.requestScope ?? ctx).redact(error));
+            })));
+            const tools = redactCatalog(ctx, listed).map(({ classification: _ignored, ...fact }) => fact);
+            if (tools.length > MAX_CATALOG_TOOLS ||
+                encoder.encode(JSON.stringify(tools)).byteLength > MAX_SERIALIZED_CATALOG_BYTES) {
+                throw new ConnectorCallError("connector_call_failed", "Downstream catalog exceeds the complete-catalog ceiling.", { retryable: false });
             }
-            catch (error) {
-                logFailure(this.opts.logger, "catalog refresh observation failed", failureRecord({ connector: id }, error));
+            const facts = frozenFacts(structuredClone(tools));
+            const accepted = this.acceptToolNames(facts);
+            if (catalogFetchedAt(ctx) === undefined) {
+                for (const observe of [storeCustomCatalogFallback, observeUncachedCatalogRefresh]) {
+                    yield* authCall(observe, [ctx, id, facts]).pipe(Effect.catch((error) => Effect.sync(() => logFailure(this.opts.logger, "catalog refresh observation failed", failureRecord({ connector: id }, error)))));
+                }
             }
-        }
-        this.catalogObservedAt.set(id, catalogFetchedAt(ctx) ?? Date.now());
-        const provenance = catalogExpiry(ctx);
-        const freshUntil = provenance && !provenance.staleFallback ? provenance.expiresAt : 0;
-        this.catalogAccess.set(id, {
-            state: freshUntil > Date.now() ? "fresh" : "stale",
-            observedAt: new Date().toISOString(),
+            this.catalogObservedAt.set(id, catalogFetchedAt(ctx) ?? Date.now());
+            const provenance = catalogExpiry(ctx);
+            const freshUntil = provenance && !provenance.staleFallback ? provenance.expiresAt : 0;
+            this.catalogAccess.set(id, {
+                state: freshUntil > Date.now() ? "fresh" : "stale",
+                observedAt: new Date().toISOString(),
+            });
+            return markCatalogFreshness(accepted, freshUntil);
         });
-        return { tools: markCatalogFreshness(accepted, freshUntil), verification };
     }
     /** The served catalog excludes control-character names; raw caches stay complete. */
     acceptToolNames(tools) {
@@ -799,30 +686,28 @@ export class Registry {
     }
     /**
      * One connector's catalog as served: the cached downstream facts, classified
-     * on every read by the connector's `classification`, into fresh objects.
-     * Safety is derived here and nowhere else, so no cache layer can carry a
-     * stale verdict — from an older review, an older release, or a stale
-     * fallback — and nothing a caller or decorator does to a served tool reaches
-     * the next read.
+     * on every read by annotations and deployment overrides, into fresh objects.
+     * No cache or caller mutation can carry a stale verdict into the next read.
      */
-    async loadTools(id, baseUrl, requestScope, callOptions = {}, scope) {
-        const { tools, verification } = await this.loadDownstreamTools(id, baseUrl, requestScope, callOptions, scope);
-        const connector = this.connectors.get(id);
-        if (!connector)
-            throw new Error(`Unknown connector "${id}"`);
-        const accepted = this.acceptToolNames(tools);
-        const overrides = this.classification[id];
-        this.validateClassification(id, accepted, overrides);
-        const review = catalogReviewOf(connector);
-        return carryCatalogFreshness(tools, review
-            ? await classifyCatalog(review, id, accepted, this.opts.logger, overrides, verification)
-            : accepted.map((tool) => this.publishUnreviewedTool(id, tool)));
-    }
-    publishUnreviewedTool(id, tool) {
+    loadTools(id, baseUrl, requestScope, callOptions = {}, scope) {
+        return Effect.gen({ self: this }, function* () {
+            const tools = yield* this.loadDownstreamTools(id, baseUrl, requestScope, callOptions, scope);
+            const connector = this.connectors.get(id);
+            if (!connector)
+                throw new Error(`Unknown connector "${id}"`);
+            const accepted = this.acceptToolNames(tools);
+            const overrides = this.classification[id];
+            this.validateClassification(id, accepted, overrides, this.catalogObservationPartition(id, baseUrl, scope, true));
+            const visible = accepted.filter((tool) => overrides?.[tool.name] !== "hidden");
+            const served = visible.map((tool) => this.publishTool(id, tool));
+            return carryCatalogFreshness(tools, served);
+        });
+    }
+    publishTool(id, tool) {
         const override = this.classification[id]?.[tool.name];
-        return {
+        return carryToolClassification(tool, {
             ...structuredClone(tool),
-            classification: classifyTool(tool, override),
+            classification: classifyTool(tool, override === "hidden" ? undefined : override),
             ...(override !== undefined
                 ? {
                     annotations: {
@@ -832,65 +717,42 @@ export class Registry {
                     },
                 }
                 : {}),
-        };
+        });
     }
     /** Construction-only view for the secret-free static config description. */
     describeStaticTools(id) {
         const tools = this.connectors.get(id)?.staticTools;
-        return tools?.map((tool) => this.publishUnreviewedTool(id, tool));
+        return tools
+            ?.filter((tool) => this.classification[id]?.[tool.name] !== "hidden")
+            .map((tool) => this.publishTool(id, tool));
     }
-    validateClassification(id, tools, overrides) {
+    validateClassification(id, tools, overrides, partition) {
+        if (!overrides)
+            return;
+        if (partition) {
+            const catalog = JSON.stringify(tools);
+            if (this.overrideWarningCatalogs.get(partition) === catalog)
+                return;
+            this.overrideWarningCatalogs.set(partition, catalog);
+        }
         const known = new Set(tools.map((tool) => tool.name));
         for (const name of Object.keys(overrides ?? {})) {
-            if (!known.has(name))
+            if (known.has(name))
+                continue;
+            if (this.connectors.get(id)?.staticTools) {
                 throw new Error(`ConnectaConfig.classification: connector "${id}" has no tool "${name}"`);
+            }
+            // Only deployment-authored names, never downstream text. JSON quoting
+            // prevents control characters from forging operator log lines.
+            const quoted = JSON.stringify(`${id}.${name}`).replace(/[\u2028\u2029]/g, (ch) => `\\u${ch.charCodeAt(0).toString(16)}`);
+            this.opts.logger.warn(`classification override ${quoted} is dormant because the runtime catalog lists no such tool`);
         }
     }
-    async getTools(id, baseUrl, requestScope, callOptions = {}, scope) {
-        const connector = this.connectors.get(id);
-        if (!connector)
-            throw new Error(`Unknown connector "${id}"`);
-        if (!requestScope) {
-            return this.loadTools(id, baseUrl, requestScope, callOptions, scope);
-        }
-        let loads = this.requestCatalogLoads.get(requestScope);
-        if (!loads) {
-            loads = new Map();
-            this.requestCatalogLoads.set(requestScope, loads);
-        }
-        const requestLoads = loads;
-        const key = JSON.stringify([id, scope?.principalKey, scope?.subjectKey, scope?.caller]);
-        let load = requestLoads.get(key);
-        if (!load) {
-            const started = new SharedRead((signal) => this.loadTools(id, baseUrl, requestScope, { ...callOptions, signal }, scope), 
-            // Settled or cancelled, the read leaves the map before any caller
-            // resumes, so the next one asks the caches afresh.
-            () => {
-                if (requestLoads.get(key) === started)
-                    requestLoads.delete(key);
-                if (requestLoads.size === 0) {
-                    this.requestCatalogLoads.delete(requestScope);
-                }
-            });
-            requestLoads.set(key, started);
-            load = started;
-        }
-        return runEdge(load.join(callOptions.signal));
+    getTools(id, baseUrl, requestScope, callOptions = {}, scope) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "getTools", id, baseUrl, requestScope, callOptions, scope));
     }
-    async credentialDriftFor(id) {
-        const credential = this.connectors.get(id)?.credential;
-        const vault = this.opts.credentialVault;
-        if (!credential || !vault)
-            return undefined;
-        try {
-            const values = await vault.getAll(id, this.opts.credentialOwner);
-            const shape = storedCredentialShape(credential, values);
-            return shape.state === "mismatch" ? shape.message : undefined;
-        }
-        catch (error) {
-            logFailure(this.opts.logger, "credential shape read failed", failureRecord({ connector: id }, error));
-            return undefined;
-        }
+    credentialDriftFor(id) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "credentialDriftFor", id));
     }
     /** Age of a complete cache entry; reads never refresh it. */
     catalogAgeMs(id) {
@@ -898,76 +760,225 @@ export class Registry {
         return observedAt === undefined ? null : Math.max(0, Date.now() - observedAt);
     }
     /** Pure lookup shared by status probes and operator catalog refreshes. */
-    withCatalogObservations(id, baseUrl, status, scope) {
+    withCatalogObservations(id, _baseUrl, status, _scope) {
         const connector = this.connectors.get(id);
         if (!connector)
             return ownStatus({ state: "error", message: "Unknown connector" });
-        const report = this.catalogDriftOf(connector, baseUrl, scope);
         const access = this.catalogAccess.get(id);
         // Connector.status is an open plugin seam. Rebuild its public fields so
         // it cannot smuggle payload or another partition's observations (INV-6).
-        return Object.assign(boundedStatus(status), {
-            ...(report ? { catalogDrift: report } : {}),
-            ...(access ? { catalogAccess: { ...access } } : {}),
-        });
+        return Object.assign(boundedStatus(status), access ? { catalogAccess: { ...access } } : {});
     }
     /** Best-effort connector status for the operator UI. */
-    async statusFor(id, baseUrl, requestScope = {}, callOptions = {}, scope) {
-        const connector = this.connectors.get(id);
-        if (!connector)
-            return ownStatus({ state: "error", message: "Unknown connector" });
-        const ctx = this.contextFor(id, baseUrl, requestScope, callOptions, scope);
-        // Whatever the state turns out to be, it carries the drift the last
-        // refresh saw. Reading it is a lookup, not a probe: a connector that has
-        // listed nothing yet reports nothing, and status never lists on its own to
-        // make the field appear.
-        // The report is rebuilt rather than spread through: what the seam returned
-        // is third-party output, and status is read by the operator UI and copied
-        // into responses.
-        const withObservations = (status) => this.withCatalogObservations(id, baseUrl, status, scope);
-        // Credential declarations own their readiness even when a static catalog
-        // or a plugin status would otherwise report success. Never probe an empty slot.
-        if (connector.credential) {
-            try {
-                const values = (await this.opts.credentialVault?.getAll(id, this.opts.credentialOwner)) ?? null;
-                const shape = storedCredentialShape(connector.credential, values);
-                if (shape.state === "missing")
-                    return withObservations(ownStatus({ state: "credential_required" }));
-                if (shape.state === "mismatch")
-                    return withObservations(ownStatus({ state: "auth_required" }));
-            }
-            catch (err) {
-                return withObservations(failureStatus(id, err));
-            }
-        }
-        if (connector.status) {
-            try {
-                return withObservations(await connector.status(ctx));
-            }
-            catch (err) {
-                return withObservations(failureStatus(id, err));
-            }
-        }
-        try {
-            await this.getTools(id, baseUrl, requestScope, callOptions, scope);
-            return withObservations({ state: "ok" });
-        }
-        catch (err) {
-            return withObservations(failureStatus(id, err));
-        }
+    statusFor(id, baseUrl, requestScope = {}, callOptions = {}, scope) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "statusFor", id, baseUrl, requestScope, callOptions, scope));
     }
     /** Rotate the storage generation; in-flight old readers cannot republish it. */
     invalidate(id) {
         void this.invalidateStored(id);
     }
-    async invalidateStored(id) {
-        this.catalogObservedAt.delete(id);
-        try {
-            await invalidateCatalogCache(this.opts.catalogStorage ?? this.opts.storage, id);
-        }
-        catch (error) {
-            logFailure(this.opts.logger, "catalog invalidation failed", failureRecord({ connector: id }, error));
-        }
+    invalidateStored(id) {
+        return runEdge(registryEdgeProgram(Registry.prototype, this, "invalidateStored", id));
+    }
+    static {
+        provideRegistryPrograms(Registry.prototype, {
+            stashResult: (self, id, chunks, ttlSeconds, partition = scopes.results) => Effect.gen({ self }, function* () {
+                const maxBytes = this.opts.results?.maxStashBytes ?? CONFIG_DEFAULTS.results.maxStashBytes;
+                const maxEntries = this.opts.results?.maxStashEntries ?? CONFIG_DEFAULTS.results.maxStashEntries;
+                // The paging envelope is ASCII, so its string length is its stored byte count.
+                const bytes = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+                if (bytes > maxBytes || maxEntries === 0)
+                    return false;
+                const keys = chunks.map((_, index) => partition + resultKeys.chunk(id, index));
+                // IDs belong to reservations, not reusable result IDs or subjects.
+                const charge = crypto.randomUUID();
+                const ttlMs = ttlSeconds * 1000;
+                if (!Number.isSafeInteger(ttlMs) || ttlMs <= 0)
+                    return false;
+                const booking = yield* swapStashLedger((live, now) => {
+                    // A committed CAS with a lost response is already our booking, even
+                    // at full capacity. Reuse its deadline instead of adding a second slot.
+                    const own = live.find((entry) => entry[0] === charge);
+                    if (own)
+                        return { result: own[2] };
+                    const used = live.reduce((sum, entry) => sum + entry[1], 0);
+                    if (live.length >= maxEntries || used + bytes > maxBytes)
+                        return { result: undefined };
+                    const deadline = now + STASH_WRITE_TIMEOUT_MS + ttlMs;
+                    if (!Number.isSafeInteger(deadline))
+                        return { result: undefined };
+                    return { entries: [...live, [charge, bytes, deadline]], result: deadline };
+                });
+                if (booking.status === "exhausted" || booking.result === undefined)
+                    return false;
+                const deadline = booking.result;
+                const writeDeadline = deadline - ttlMs;
+                const chunkExpiry = deadline - STASH_WRITE_TIMEOUT_MS;
+                const owns = (entry) => entry[0] === charge;
+                const settle = swapStashLedger((live) => live.some((entry) => owns(entry) && entry[2] > chunkExpiry)
+                    ? {
+                        entries: live.map((entry) => owns(entry) ? [charge, bytes, Math.min(entry[2], chunkExpiry)] : entry),
+                        result: undefined,
+                    }
+                    : { result: undefined });
+                let pendingWrite = false;
+                // A rejected or timed-out driver call may still commit after deletion.
+                // Only a confirmed write response clears pendingWrite.
+                const release = completeStash(Effect.gen(function* () {
+                    const deleted = yield* Effect.gen(function* () {
+                        for (const key of keys)
+                            yield* storageDelete(key);
+                        return true;
+                    }).pipe(Effect.catch(() => Effect.succeed(false)));
+                    if (pendingWrite)
+                        return;
+                    if (deleted) {
+                        const released = yield* swapStashLedger((live) => live.some(owns)
+                            ? { entries: live.filter((entry) => !owns(entry)), result: undefined }
+                            : { result: undefined });
+                        if (released.status === "applied")
+                            return;
+                    }
+                    yield* settle;
+                }));
+                // Trailing chunks first, then the header. The caller receives no result
+                // ID after failure or timeout, including a late header commit.
+                const remaining = Math.max(0, writeDeadline - (yield* Clock.currentTimeMillis));
+                const written = yield* Effect.gen(function* () {
+                    for (let index = keys.length - 1; index >= 0; index--) {
+                        const before = yield* Clock.currentTimeMillis;
+                        if (before >= writeDeadline || before >= chunkExpiry)
+                            return false;
+                        pendingWrite = true;
+                        yield* storageSet(keys[index], chunks[index], { expiresAtMs: chunkExpiry }).pipe(Effect.tap(() => Effect.sync(() => {
+                            pendingWrite = false;
+                        })));
+                        if ((yield* Clock.currentTimeMillis) >= writeDeadline)
+                            return false;
+                    }
+                    return true;
+                }).pipe(Effect.timeoutOrElse({ duration: Duration.millis(remaining), orElse: () => Effect.succeed(false) }), Effect.onError(() => release.pipe(Effect.ignore)));
+                if (!written)
+                    yield* release;
+                else
+                    yield* completeStash(settle);
+                return written;
+            }).pipe(Effect.provideService(Storage, self.opts.storage)),
+            recheckResultAccess: () => Effect.succeed(true),
+            storeOAuthHandoff: (self, connectorId, state, principalKey) => Effect.gen(function* () {
+                const key = oauthHandoffKeys.handoff(connectorId, yield* Effect.tryPromise({ try: () => sha256Hex(state), catch: (error) => error }));
+                for (let attempt = 0; attempt < 32; attempt++) {
+                    const existing = yield* storageGet(key);
+                    if (existing && existing !== principalKey)
+                        throw new Error(`Connector "${connectorId}" reused one OAuth state across principals`);
+                    if (yield* storageCompareAndSet(key, existing, principalKey, { ttlSeconds: OAUTH_HANDOFF_TTL_SECONDS }))
+                        return;
+                }
+                throw new Error(`OAuth handoff for "${connectorId}" is busy; retry authorization`);
+            }).pipe(Effect.provideService(Storage, self.opts.storage)),
+            oauthCallbackView: (self, connectorId, state) => Effect.gen(function* () {
+                if (!state)
+                    return null;
+                const digest = yield* Effect.tryPromise({ try: () => sha256Hex(state), catch: (error) => error });
+                const principalKey = yield* storageGet(oauthHandoffKeys.handoff(connectorId, digest));
+                const connector = self.connectors.get(connectorId);
+                if (!connector || !principalKey)
+                    return null;
+                return {
+                    registry: connector.authScope === "personal"
+                        ? self.scoped({ connectorIds: [connectorId], subjectKey: principalKey, principalKey })
+                        : self,
+                    principalKey,
+                };
+            }).pipe(Effect.provideService(Storage, self.opts.storage)),
+            consumeOAuthHandoff: (self, connectorId, state, principalKey) => Effect.gen(function* () {
+                if (!state)
+                    return false;
+                const digest = yield* Effect.tryPromise({ try: () => sha256Hex(state), catch: (error) => error });
+                return yield* storageCompareAndSet(oauthHandoffKeys.handoff(connectorId, digest), principalKey, null);
+            }).pipe(Effect.provideService(Storage, self.opts.storage)),
+            bindOAuthHandoff: (self, id, authorizationUrl, principalKey) => Effect.gen(function* () {
+                const state = new URL(authorizationUrl).searchParams.get("state");
+                if (!state || !principalKey)
+                    throw new Error("OAuth requires state and an initiating user");
+                yield* registryProgram(self, "storeOAuthHandoff", id, state, principalKey);
+            }),
+            getTools: (self, id, baseUrl, requestScope, callOptions = {}, scope) => Effect.suspend(() => {
+                if (!self.connectors.has(id))
+                    return Effect.fail(new Error(`Unknown connector "${id}"`));
+                const owner = self.contextFor(id, baseUrl, requestScope, callOptions, scope);
+                return duringViewEffect(owner, (signal) => {
+                    if (!requestScope)
+                        return self.loadTools(id, baseUrl, owner.requestScope, { ...callOptions, signal }, scope);
+                    let loads = self.requestCatalogLoads.get(requestScope);
+                    if (!loads) {
+                        loads = new Map();
+                        self.requestCatalogLoads.set(requestScope, loads);
+                    }
+                    const requestLoads = loads;
+                    const key = JSON.stringify([id, scope?.principalKey, scope?.subjectKey, scope?.caller]);
+                    let load = requestLoads.get(key);
+                    if (!load) {
+                        const started = new SharedRead((signal) => self.loadTools(id, baseUrl, requestScope, { ...callOptions, signal }, scope), () => {
+                            if (requestLoads.get(key) === started)
+                                requestLoads.delete(key);
+                            if (requestLoads.size === 0)
+                                self.requestCatalogLoads.delete(requestScope);
+                        }, requestScope);
+                        requestLoads.set(key, started);
+                        load = started;
+                    }
+                    return load.join(signal);
+                });
+            }),
+            credentialDriftFor: (self, id) => Effect.gen(function* () {
+                const credential = self.connectors.get(id)?.credential;
+                const vault = self.opts.credentialVault;
+                if (!credential || !vault)
+                    return undefined;
+                return yield* Effect.tryPromise({
+                    try: () => vault.getAll(id, self.opts.credentialOwner),
+                    catch: (error) => error,
+                }).pipe(Effect.map((values) => {
+                    const shape = storedCredentialShape(credential, values);
+                    return shape.state === "mismatch" ? shape.message : undefined;
+                }), Effect.catchCause((cause) => Effect.sync(() => {
+                    logFailure(self.opts.logger, "credential shape read failed", failureRecord({ connector: id }, causeError(cause)));
+                    return undefined;
+                })));
+            }),
+            statusFor: (self, id, baseUrl, requestScope = {}, callOptions = {}, scope) => Effect.suspend(() => {
+                const connector = self.connectors.get(id);
+                if (!connector)
+                    return Effect.succeed(ownStatus({ state: "error", message: "Unknown connector" }));
+                const ctx = self.contextFor(id, baseUrl, requestScope, callOptions, scope);
+                const withObservations = (status) => self.withCatalogObservations(id, baseUrl, status, scope);
+                return duringViewEffect(ctx, () => Effect.gen(function* () {
+                    if (connector.credential) {
+                        const values = yield* Effect.tryPromise({
+                            try: () => self.opts.credentialVault?.getAll(id, self.opts.credentialOwner) ?? Promise.resolve(null),
+                            catch: (error) => error,
+                        });
+                        const shape = storedCredentialShape(connector.credential, values);
+                        if (shape.state === "missing")
+                            return withObservations(ownStatus({ state: "credential_required" }));
+                        if (shape.state === "mismatch")
+                            return withObservations(ownStatus({ state: "auth_required" }));
+                    }
+                    if (connector.status)
+                        return withObservations(yield* authInvoke(connector, "status", [ctx]));
+                    yield* registryProgram(self, "getTools", id, baseUrl, requestScope, callOptions, scope);
+                    return withObservations({ state: "ok" });
+                })).pipe(Effect.catchCause((cause) => Effect.succeed(withObservations(failureStatus(id, causeError(cause, ctx.signal))))));
+            }),
+            invalidateStored: (self, id) => Effect.suspend(() => {
+                self.catalogObservedAt.delete(id);
+                return Effect.tryPromise({
+                    try: () => invalidateCatalogCache(self.opts.catalogStorage ?? self.opts.storage, id),
+                    catch: (error) => error,
+                }).pipe(Effect.catch((error) => Effect.sync(() => logFailure(self.opts.logger, "catalog invalidation failed", failureRecord({ connector: id }, error)))));
+            }),
+        });
     }
 }
 class ScopedRegistryView {
@@ -1033,27 +1044,8 @@ class ScopedRegistryView {
         const connector = this.getConnector(parsed.connectorId);
         return connector ? { connector, toolName: parsed.toolName } : null;
     }
-    async getTools(...args) {
-        const registry = this.registryFor(args[0]);
-        if (!registry) {
-            throw new Error(`Unknown connector "${args[0]}"`);
-        }
-        const tools = await registry.getTools(args[0], args[1], args[2], args[3], this.scope);
-        const granted = this.scope.toolAccess?.get(args[0]);
-        if (!granted)
-            return tools;
-        // Every consumer — search, describe, call_tool, and a program's
-        // connecta.call — resolves through this list, so an ungranted tool is
-        // indistinguishable from one the connector never had.
-        const visible = tools.filter((tool) => granted.has(tool.name));
-        if (visible.length < granted.size) {
-            const present = new Set(tools.map((tool) => tool.name));
-            for (const name of granted) {
-                if (!present.has(name))
-                    this.root.noteAbsentGrant(args[0], name);
-            }
-        }
-        return carryCatalogFreshness(tools, visible);
+    getTools(...args) {
+        return runEdge(registryEdgeProgram(ScopedRegistryView.prototype, this, "getTools", ...args));
     }
     contextFor(...args) {
         const registry = this.registryFor(args[0]);
@@ -1079,15 +1071,14 @@ class ScopedRegistryView {
             origin: this.scope.origin ?? null,
         };
     }
-    recheckResultAccess(address, classification, signal, access) {
-        return this.scope.currentResultAccess?.(address, classification, signal, access) ?? Promise.resolve(true);
+    recheckResultAccess(dependencies, classification, signal) {
+        return this.scope.currentResultAccess?.(dependencies, classification, signal) ?? Promise.resolve(true);
     }
     resultsStorage() {
         return this.scope.subjectKey ? this.root.scopedStorage(this.scope.subjectKey) : this.root.resultsStorage();
     }
     credentialDriftFor(id) {
-        const registry = this.registryFor(id);
-        return registry ? registry.credentialDriftFor(id) : Promise.resolve(undefined);
+        return runEdge(registryEdgeProgram(ScopedRegistryView.prototype, this, "credentialDriftFor", id));
     }
     observedOutputSchema(connectorId, definition) {
         return this.registryFor(connectorId)?.observedOutputSchema(connectorId, definition);
@@ -1099,23 +1090,65 @@ class ScopedRegistryView {
         return this.registryFor(id)?.catalogAgeMs(id) ?? null;
     }
     statusFor(...args) {
-        const registry = this.registryFor(args[0]);
-        return registry
-            ? registry.statusFor(args[0], args[1], args[2], args[3], this.scope)
-            : Promise.resolve({ state: "error", message: "Unknown connector" });
+        return runEdge(registryEdgeProgram(ScopedRegistryView.prototype, this, "statusFor", ...args));
     }
     withCatalogObservations(id, baseUrl, status) {
         return (this.registryFor(id)?.withCatalogObservations(id, baseUrl, status, this.scope) ??
             ownStatus({ state: "error", message: "Unknown connector" }));
     }
     invalidateStored(id) {
-        const registry = this.registryFor(id);
-        return registry ? registry.invalidateStored(id) : Promise.resolve();
+        return runEdge(registryEdgeProgram(ScopedRegistryView.prototype, this, "invalidateStored", id));
     }
     credentialUiAvailable() {
         return this.root.credentialUiAvailable();
     }
     async bindOAuthHandoff(id, authorizationUrl, principalKey) {
-        await this.root.bindOAuthHandoff(id, authorizationUrl, principalKey ?? this.scope.principalKey);
+        return runEdge(registryEdgeProgram(ScopedRegistryView.prototype, this, "bindOAuthHandoff", id, authorizationUrl, principalKey));
+    }
+    static {
+        provideRegistryPrograms(ScopedRegistryView.prototype, {
+            stashResult: (self, id, chunks, ttlSeconds) => registryProgram(self.root, "stashResult", id, chunks, ttlSeconds, self.scope.subjectKey ? scopes.subject(self.scope.subjectKey) : scopes.results),
+            recheckResultAccess: (self, dependencies, classification, signal) => Effect.tryPromise({
+                try: () => self.scope.currentResultAccess?.(dependencies, classification, signal) ?? Promise.resolve(true),
+                catch: (error) => error,
+            }),
+            getTools: (self, ...args) => Effect.gen(function* () {
+                const registry = self.registryFor(args[0]);
+                if (!registry) {
+                    throw new Error(`Unknown connector "${args[0]}"`);
+                }
+                const tools = yield* registryProgram(registry, "getTools", args[0], args[1], args[2], args[3], self.scope);
+                const granted = self.scope.toolAccess?.get(args[0]);
+                if (!granted)
+                    return tools;
+                // Every consumer — search, describe, call_tool, and a program's
+                // connecta.call — resolves through this list, so an ungranted tool is
+                // indistinguishable from one the connector never had.
+                const visible = tools.filter((tool) => granted.has(tool.name));
+                if (visible.length < granted.size) {
+                    const present = new Set(tools.map((tool) => tool.name));
+                    for (const name of granted) {
+                        if (!present.has(name))
+                            self.root.noteAbsentGrant(args[0], name);
+                    }
+                }
+                return carryCatalogFreshness(tools, visible);
+            }),
+            credentialDriftFor: (self, id) => Effect.suspend(() => {
+                const registry = self.registryFor(id);
+                return registry ? registryProgram(registry, "credentialDriftFor", id) : Effect.succeed(undefined);
+            }),
+            statusFor: (self, ...args) => Effect.suspend(() => {
+                const registry = self.registryFor(args[0]);
+                return registry
+                    ? registryProgram(registry, "statusFor", args[0], args[1], args[2], args[3], self.scope)
+                    : Effect.succeed({ state: "error", message: "Unknown connector" });
+            }),
+            invalidateStored: (self, id) => Effect.suspend(() => {
+                const registry = self.registryFor(id);
+                return registry ? registryProgram(registry, "invalidateStored", id) : Effect.succeed(undefined);
+            }),
+            bindOAuthHandoff: (self, id, authorizationUrl, principalKey) => registryProgram(self.root, "bindOAuthHandoff", id, authorizationUrl, principalKey ?? self.scope.principalKey),
+        });
     }
 }