@lanes-sh/link 0.7.2 → 0.8.0

package/src/cli/main.ts

@@ -1,6 +1,10 @@
 import { connect } from './commands/connect/index.ts';
 import { connectCustom } from './commands/connect/custom/index.ts';
-import { disconnect, relabel } from './commands/connection.ts';
+import { disconnect } from './commands/connection.ts';
+import { grantConnectionTo, revokeConnectionFrom } from './commands/grant.ts';
+import { connectionList } from './commands/connection-list.ts';
+import { membersAdd, membersList, membersRemove } from './commands/members.ts';
+import { relabel } from './commands/relabel.ts';
 import {
   attachFile,
   auditTail,
@@ -11,6 +15,7 @@ import {
   desktop,
   doctor,
   outputs,
+  pair,
   plan,
   policyList,
   policyRule,
@@ -26,13 +31,23 @@ import { syncTargets } from './commands/sync.ts';
 import { targetList, targetShow, targetUse } from './commands/target.ts';
 import { identityAdd, identityList, identityRemove } from './commands/identity.ts';
 import { setupPlan } from './commands/setup.ts';
-import { mcpAdd, mcpList, mcpStdio, skillDocument } from './commands/mcp.ts';
+import { installInstructions, mcpAdd, mcpList, mcpStdio, skillDocument } from './commands/mcp.ts';
 import { deploy } from '#deployments/deploy.ts';
 import { secretsList, secretsPush, secretsSet } from './commands/secrets.ts';
 import { knowledgeShow, knowledgeUse } from './commands/knowledge.ts';
 import { dispatchOwner } from './dispatch-owner.ts';
 import { update } from './commands/update.ts';
-import { all, customFlags, globalFlags, knowledgeFlags, ownerFlags, parseArgv, text } from './argv.ts';
+import {
+  all,
+  customFlags,
+  globalFlags,
+  knowledgeFlags,
+  ownerFlags,
+  parseArgv,
+  text,
+} from './argv.ts';
+import type { GlobalFlags } from './runtime.ts';
+import type { OwnerFlags } from './commands/owner/shared.ts';
 import { assertKnownFlags } from './selection.ts';
 import { requireSelection } from './selection-require.ts';
 import { PROGRAM, USAGE } from './usage.ts';
@@ -57,8 +72,12 @@ export async function run(argv: readonly string[]): Promise<void> {
   const { command, flags } = parseArgv(argv);
   const [first, second, ...rest] = command;
 
-  const global = globalFlags(flags);
-  const owner = ownerFlags(flags, argv);
+  // Both are read *after* `requireSelection`, which is what resolves
+  // `default_workspace` onto `flags` (ADR-061). Capturing them before it would
+  // hand every command an undefined workspace on the path the default exists to
+  // serve — the flag would be resolved and nothing would be looking.
+  let global: GlobalFlags;
+  let owner: OwnerFlags;
 
   const show = flags['show'] === true;
   const raw = flags['raw'] === true;
@@ -77,6 +96,9 @@ export async function run(argv: readonly string[]): Promise<void> {
   assertKnownFlags(first, second, flags);
   await requireSelection(first, second, flags);
 
+  global = globalFlags(flags);
+  owner = ownerFlags(flags, argv);
+
   switch (first) {
     case 'connect':
       // A nested switch rather than an `if`, so `selection.test.ts` sees
@@ -117,6 +139,20 @@ export async function run(argv: readonly string[]): Promise<void> {
           });
       }
 
+    // The command connecting no longer implies. A connection belongs to the
+    // workspace (ADR-057), so which profiles may reach it is a separate say.
+    case 'connection':
+      if (second !== 'list' && second !== undefined) {
+        throw new Error(`Unknown: ${PROGRAM} connection ${second}`);
+      }
+      return connectionList({ ...global, json });
+
+    case 'grant':
+      return grantConnectionTo(second, { ...global, json });
+
+    case 'revoke':
+      return revokeConnectionFrom(second, { ...global, json });
+
     case 'setup':
       if (second !== 'plan' && second !== undefined) {
         throw new Error(`Unknown: ${PROGRAM} setup ${second}`);
@@ -127,27 +163,46 @@ export async function run(argv: readonly string[]): Promise<void> {
       switch (second) {
         case 'add':
           if (!rest[0]) {
-            throw new Error(`Usage: ${PROGRAM} profile add <name> --target <name>`);
+            throw new Error(`Usage: ${PROGRAM} profile add <name> --workspace <name>`);
           }
           return profileAdd(rest[0], {
             // One target, not a list. A profile declared every target it could
             // run on under contract 1, which is why this read the repeated flag
             // out of argv; it lives in exactly one now (ADR-052), so a second
             // --target would be naming a second place to put the same file.
-            targets: [text(flags, 'target')!],
+            targets: [text(flags, 'workspace')!],
             nonInteractive: flags['non-interactive'] === true,
             json,
           });
         case 'list':
         case undefined:
-          return profileList(text(flags, 'target')!, { json });
+          return profileList(text(flags, 'workspace')!, { json });
         case 'default':
           if (!rest[0]) throw new Error(`Usage: ${PROGRAM} profile default <name>`);
           return profileDefault(rest[0]);
+        case 'members': {
+          const [action, subject] = rest;
+          switch (action) {
+            case 'add':
+              return membersAdd(subject, {
+                ...global,
+                json,
+                me: flags['me'] === true,
+                role: text(flags, 'role'),
+              });
+            case 'remove':
+              return membersRemove(subject, { ...global, json });
+            case 'list':
+            case undefined:
+              return membersList({ ...global, json });
+            default:
+              throw new Error(`Unknown: ${PROGRAM} profile members ${action}`);
+          }
+        }
         case 'remove':
           if (!rest[0]) {
             throw new Error(
-              `Usage: ${PROGRAM} profile remove <name> [--target t] [--dry-run] [--yes]`,
+              `Usage: ${PROGRAM} profile remove <name> [--workspace <name>] [--dry-run] [--yes]`,
             );
           }
           return profileRemove(rest[0], {
@@ -160,18 +215,22 @@ export async function run(argv: readonly string[]): Promise<void> {
           throw new Error(`Unknown: ${PROGRAM} profile ${second}`);
       }
 
+    // `target` was the old word for the same thing (ADR-061). Kept as its own
+    // case rather than aliased, so `selection.test.ts` sees both spellings and
+    // neither can default quietly.
     case 'target':
+    case 'workspace':
       switch (second) {
         case 'list':
         case undefined:
           return targetList({ ...global, json, urls: flags['urls'] === true });
         case 'use':
-          if (!rest[0]) throw new Error(`Usage: ${PROGRAM} target use <name>`);
+          if (!rest[0]) throw new Error(`Usage: ${PROGRAM} workspace use <name>`);
           return targetUse(rest[0]);
         case 'show':
           return targetShow(rest[0], { ...global, json });
         default:
-          throw new Error(`Unknown: ${PROGRAM} target ${second}`);
+          throw new Error(`Unknown: ${PROGRAM} workspace ${second}`);
       }
 
     case 'identity': {
@@ -206,11 +265,15 @@ export async function run(argv: readonly string[]): Promise<void> {
           const [capability] = rest;
           if (!capability) {
             throw new Error(
-              `Usage: ${PROGRAM} policy ${second} <capability>\n` +
-                `  e.g. ${PROGRAM} policy ${second} gmail.send_message, or gmail.* for the whole provider`,
+              `Usage: ${PROGRAM} policy ${second} <capability> --connection <provider>.<id>\n` +
+                `  e.g. ${PROGRAM} policy ${second} gmail.send_message --connection gmail.personal,\n` +
+                `       or gmail.* for everything that connection's provider offers`,
             );
           }
-          return policyRule(second, capability, global);
+          return policyRule(second, capability, {
+            ...global,
+            ...(typeof flags.connection === 'string' ? { connection: flags.connection } : {}),
+          });
         }
         default:
           throw new Error(`Unknown: ${PROGRAM} policy ${second}`);
@@ -227,6 +290,14 @@ export async function run(argv: readonly string[]): Promise<void> {
           throw new Error(`Unknown: ${PROGRAM} token ${second}`);
       }
 
+    case 'pair':
+      return pair({
+        ...global,
+        print: flags['print'] === true,
+        rotate: flags['rotate'] === true,
+        yes: flags['yes'] === true,
+      });
+
     case 'audit':
       if (second === 'verify') return auditVerify(global);
       if (second !== 'tail' && second !== undefined) {
@@ -340,7 +411,10 @@ export async function run(argv: readonly string[]): Promise<void> {
             dryRun: flags['dry-run'] === true,
             force: flags['force'] === true,
             noSkill: flags['no-skill'] === true,
+            headless: flags['headless'] === true,
           });
+        case 'install-instructions':
+          return installInstructions({ ...(text(flags, 'client') ? { client: text(flags, 'client') } : {}) });
         case 'stdio':
           return mcpStdio({ ...global, ...(flags['only'] === true ? { only: true } : {}) });
         case 'list':
@@ -398,6 +472,7 @@ export async function run(argv: readonly string[]): Promise<void> {
       switch (second) {
         case undefined:
         case 'targets':
+        case 'workspaces':
           return syncTargets({
             ...global,
             dryRun: flags['dry-run'] === true,

package/src/cli/migrate-plan.ts

@@ -1,4 +1,5 @@
-import { ConfigError, layout, isRemoteWorkspace, type LegacyTarget, type WorkspaceTarget } from '#profile';
+import {
+  DATA_DIR, ConfigError, layout, isRemoteWorkspace, type LegacyTarget, type WorkspaceTarget } from '#profile';
 import { deployedWorkspace } from '#deployments/upload.ts';
 
 /**
@@ -88,7 +89,7 @@ export function toEntry(
   // produces `gs://b` pointing at `gs://b`. That is a loop, and `openTarget`
   // refuses it — which made `deploy` unable to run against the bucket it had
   // just migrated, on the one command the refusal names as the fix.
-  if (remote && remote !== workspaceRoot) return { workspace: remote };
+  if (remote && remote !== workspaceRoot) return { at: remote };
 
   // **A filesystem target is dropped from a remote workspace.**
   //
@@ -105,8 +106,13 @@ export function toEntry(
   const storagePath = declared.storage.path;
   const credentialsPath = declared.credentials.path;
 
-  const defaultStorage = `./${layout.blobs(profile)}`;
-  const defaultCredentials = `./${layout.credentials(profile)}`;
+  // The **contract-1** defaults, spelled out rather than taken from `layout`.
+  // This function reads a contract-1 profile, where every path was per profile,
+  // and `layout` describes where things live *now* — workspace-level since
+  // ADR-057. Asking it would compare a contract-1 path against a contract-3
+  // default and refuse every profile that had written the ordinary one.
+  const defaultStorage = `./${DATA_DIR}/${profile}`;
+  const defaultCredentials = `./${DATA_DIR}/${profile}/credentials.enc`;
 
   refuseCustomPath(name, profile, workspaceRoot, 'storage.path', storagePath, defaultStorage);
   refuseCustomPath(
@@ -149,12 +155,12 @@ function refuseCustomPath(
       `  A target is declared once for the whole workspace now (ADR-052), so it cannot hold a\n` +
       `  different path per profile. The default it would get is ${expected}.\n\n` +
       `  Move the data there and delete the line, or keep this profile in a workspace of its\n` +
-      `  own: LANES_LINK_HOME=${workspaceRoot}/<somewhere> lanes link profile add ${profile} --target ${target}`,
+      `  own: LANES_LINK_HOME=${workspaceRoot}/<somewhere> lanes link profile add ${profile} --workspace ${target}`,
   );
 }
 
 export function summarise(entry: WorkspaceTarget): string {
-  if (entry.workspace !== undefined) return `points at ${entry.workspace}`;
+  if (entry.at !== undefined) return `points at ${entry.at}`;
   const parts = [entry.credentials?.adapter, entry.storage?.adapter].filter(Boolean);
   return `${parts.join(' + ')}${entry.deploy ? `, deploys ${entry.deploy.service}` : ''}`;
 }

package/src/cli/output.ts

@@ -1,3 +1,4 @@
+import { wasDefaulted } from './selection-require.ts';
 import type { Resolution } from '#profile';
 
 /**
@@ -126,16 +127,48 @@ export function announceProfile(selection: {
   print(style.dim(`profile ${style.bold(selection.profile)}  ${selection.workspaceRoot}`));
 }
 
+/**
+ * The line every command prints before its output.
+ *
+ * It names the workspace, and whether that workspace was *typed* or came from
+ * `default_workspace`. The provenance is not decoration: ADR-037 removed sticky
+ * selection because "the dotfile nothing prints" is how an operator runs a
+ * command against the wrong thing, and ADR-061 gives the default back only on
+ * the condition that it announces itself. Dropping the `(default)` marker for
+ * tidiness would reverse that decision.
+ */
 export function announce(resolution: Resolution): void {
+  const provenance = wasDefaulted(resolution.target) ? ' (default)' : '';
+
   print(
     style.dim(
       `profile ${style.bold(resolution.profile)}  ` +
-        `target ${style.bold(resolution.target)}  ` +
+        `workspace ${style.bold(resolution.target)}${provenance}  ` +
         `${resolution.workspaceRoot}`,
     ),
   );
 }
 
+/**
+ * The same line, for a command whose subject is the workspace.
+ *
+ * It names no profile, and that is the point rather than a saving. A
+ * workspace-level command still opens a runtime, and a runtime carries a
+ * profile — so `announce` would print whichever one happened to be picked, and
+ * a reader would take it for the thing being acted on. The audit log is one
+ * chain for the whole workspace; saying `profile personal` above it describes a
+ * log that does not exist.
+ */
+export function announceWorkspace(resolution: Resolution): void {
+  const provenance = wasDefaulted(resolution.target) ? ' (default)' : '';
+
+  print(
+    style.dim(
+      `workspace ${style.bold(resolution.target)}${provenance}  ${resolution.workspaceRoot}`,
+    ),
+  );
+}
+
 /**
  * Print a machine-readable result, or fall through to the human rendering.
  *

package/src/cli/publish.ts

@@ -53,7 +53,8 @@ export async function publishAndNotify(input: {
   readonly config: Config;
   readonly workspaceRoot: string;
   readonly target: string;
-  readonly profile: string;
+  /** Every profile the edit touched. See `publishWorkspace`. */
+  readonly profile: string | readonly string[];
   readonly credentials: SecretStore;
 }): Promise<PublishOutcome> {
   let published: string | null = null;
@@ -98,6 +99,8 @@ export async function publishProfileEdit(input: {
   readonly resolution: { readonly workspaceRoot: string; readonly profile: string };
   readonly config: Config;
   readonly target: string;
+  /** Every profile the edit touched, where it reached more than the one named. */
+  readonly touched?: readonly string[] | undefined;
 }): Promise<PublishOutcome> {
   const credentials = await openSecretStoreFor(
     input.config,
@@ -109,7 +112,7 @@ export async function publishProfileEdit(input: {
     config: input.config,
     workspaceRoot: input.resolution.workspaceRoot,
     target: input.target,
-    profile: input.resolution.profile,
+    profile: input.touched ?? input.resolution.profile,
     credentials,
   });
 }

package/src/cli/runtime/open.ts

@@ -6,11 +6,17 @@ import type { BlobStore } from '#stores/blobs';
 import type { AnyConnector, ProviderManifest } from '#connectivity';
 import { RateLimiter, allowedConnections } from '#policy';
 import {
+  assertGrantsResolve,
   layout,
   listProfiles,
+  readConnections,
+  selectConnections,
+  soleGrantFor,
   workspacePath,
   type Config,
+  type ConnectionConfig,
   type Resolution,
+  type SelectedConnection,
   type TargetConfig,
 } from '#profile';
 import { ProviderRegistry, toPolicyDocument } from '#registry';
@@ -33,6 +39,10 @@ import { resolveProfile, type GlobalFlags } from './select.ts';
 import { buildRegistryWithWorkspace, readSkillsForStart, reloadSkills } from './registry.ts';
 import { discoveryProbe } from './discovery.ts';
 import { openVault } from './vault.ts';
+import { EMPTY_SKILL_STORE, skillStore } from './stores.ts';
+import type { Runtime } from './types.ts';
+
+export type { Runtime } from './types.ts';
 
 /**
  * Assembling a profile's runtime from its declared target.
@@ -43,86 +53,20 @@ import { openVault } from './vault.ts';
  * nothing at the application layer.
  */
 
-export interface Runtime {
-  readonly resolution: Resolution;
-  readonly config: Config;
-  readonly target: string;
-  /**
-   * The target's adapter set, from the workspace that declares it.
-   *
-   * Here because the config no longer carries it. Every caller that used to
-   * reach `config.targets[target]` — for a `deploy` block, a storage adapter, a
-   * knowledge repository — reads this instead, and reads it without following
-   * the pointer a second time (ADR-052).
-   */
-  readonly declared: TargetConfig;
-  readonly state: RuntimeState;
-  /** The durable log, for reading. Copies, if any, are write-only and not here. */
-  readonly audit: AuditReader;
-  readonly credentials: SecretStore;
-  readonly storage: BlobStore;
-  /** Where skills are kept — `data/<profile>/skills.d/` locally. */
-  readonly skills: BlobStore;
-  /**
-   * Present only when this target keeps memory and skills in a repository.
-   *
-   * Nothing on the dispatch path reads it: `storage` and `skills` above are
-   * already pointed at the right bytes, which is the whole design. It is here
-   * so `target show` and `doctor` can say where those bytes are without
-   * re-reading the config, and so the migration can reach the repository it is
-   * committing to.
-   */
-  readonly knowledge?: KnowledgeStores | undefined;
-  /** The vault's own store, so `lanes link vault` reaches the same bytes MCP does. */
-  readonly vault: VaultStore;
-  readonly registry: ProviderRegistry;
-  /**
-   * Re-read the skills into the registry when they have changed on the store.
-   *
-   * Cheap and idempotent — one `list()`, and a rebuild only when the listing
-   * differs from the last one. The caller decides how often to ask.
-   */
-  refreshSkills(): Promise<void>;
-  readonly dispatcher: Dispatcher;
-  readonly authenticator: BearerAuthenticator;
-  /** Same factory the dispatcher uses, exposed for commands that probe upstream. */
-  connectorFor(providerId: string, connectionId: string): AnyConnector | undefined;
-  /**
-   * Same authorizer the dispatcher uses, for the same reason `connectorFor` is here.
-   *
-   * A command that probes upstream needs the credential on the request, and it
-   * must not learn how to put it there — that is one switch on the resolved
-   * shape (`connectivity/auth/authorize.ts`) and a second copy would be a
-   * second answer. `settleIdentity` is the caller: it asks a provider whose
-   * account was just authorised, over whatever method that provider declares.
-   */
-  authorizeRequest(providerId: string, connectionId: string, request: Request): Promise<Request>;
-  /** A provider's manifest, so an omitted `credential_ref` can be derived from it. */
-  manifestFor(providerId: string): ProviderManifest | undefined;
-  close(): Promise<void>;
-}
-
 /**
- * Where this profile's skills live, in either target.
- *
- * Locally `data/<profile>/skills.d/`; deployed, the same key under the bucket
- * prefix. Going through the store rather than a filesystem path is what gives a
- * deployment skills at all — a path is baked into a container image at build
- * time and an object key is not, so before ADR-014 a deployed instance could
- * only ever serve the skills that existed when its image was built.
+ * The accounts a profile reaches, as most callers want them.
  *
- * **Per profile**, which reverses ADR-012 §1. Policy gating `skills.<name>`
- * was the whole isolation story while the bytes were shared, and it is a weak
- * one: it decides who may *run* a procedure, not who may read that it exists or
- * what it says. A skill written for work names work's accounts and work's
- * people. ADR-030.
- *
- * An explicit area, matching `openState` and `openAudit` — a profile that
- * declares its own `storage.path` moves its provider blobs, not the reserved
- * roots beside them.
+ * `runtime.connections` pairs each with the grant governing it, which is what
+ * policy and the setup surface need. Everything else — probing credentials,
+ * listing accounts, reconciling state — wants the rows alone, and unwrapping
+ * them at twenty call sites is twenty chances to reach for
+ * `workspaceConnections` by mistake and answer for accounts this profile was
+ * never granted.
  */
-function skillStore(storage: StorageFactory, profile: string): BlobStore {
-  return storage(layout.skills(profile));
+export function grantedConnections(
+  runtime: Pick<Runtime, 'connections'>,
+): ConnectionConfig[] {
+  return runtime.connections.map(({ connection }) => connection);
 }
 
 /**
@@ -152,6 +96,15 @@ export async function openRuntime(
   const root = resolved.workspaceRoot;
   const adapters: TargetInput = { declared, config, root, target };
 
+  // The workspace's accounts, and the check that this profile's grants name
+  // real ones (ADR-057). Read here rather than inside `resolveProfile` because
+  // it is a property of the workspace rather than of the selection, and because
+  // a command that only wants to know which profiles exist should not have to
+  // parse every connection to find out.
+  const connectionsFile = await readConnections(root);
+  assertGrantsResolve(config, connectionsFile.connections);
+  const selected = selectConnections(config, connectionsFile.connections);
+
   // Credentials first: an S3 key pair is itself a credential reference, so the
   // credential store has to exist before the blob store that names it. State
   // and the log then ride that blob store rather than opening backends of
@@ -174,7 +127,7 @@ export async function openRuntime(
   // own roots on the target's own storage and are untouched.
   const knowledge = await openKnowledge(adapters, credentials, options.fetch);
   const storage = knowledge ? routeBlobStore(storageFor(), knowledgeRoutes(knowledge)) : storageFor();
-  const state = openState(storageFor, config.instance.profile);
+  const state = openState(storageFor);
 
   // The durable log, plus any copies the target declares. `sink` is what
   // dispatch writes to; `audit` is what `tail` and `verify` read, and those are
@@ -187,7 +140,18 @@ export async function openRuntime(
     (message) => logger.warn(message),
   );
 
-  const skills = knowledge?.skills ?? skillStore(storageFor, config.instance.profile);
+  // Rooted at the skills connection this profile grants, not at the profile
+  // (ADR-059). At most one can be granted, which is what makes this a lookup
+  // rather than a choice — `load.ts` refuses a second one, for the reason a
+  // prompt has no argument to route on.
+  //
+  // `EMPTY_SKILLS` when none is granted: a profile that denies `skills.*` has
+  // no store to open, and handing it the workspace root instead would serve
+  // every other profile's procedures.
+  const skillsConnection = soleGrantFor(config, 'skills');
+  const skills =
+    knowledge?.skills ??
+    (skillsConnection === undefined ? undefined : skillStore(storageFor, skillsConnection));
 
   // The vault's own store, beside the credential store and never it: a separate
   // document, a separate key, and a separate environment variable
@@ -208,6 +172,7 @@ export async function openRuntime(
   let registry: ProviderRegistry;
   let fingerprint = '';
   const refreshSkills = async (): Promise<void> => {
+    if (skills === undefined) return;
     fingerprint = await reloadSkills(registry, skills, fingerprint, refreshSkills);
   };
 
@@ -226,23 +191,18 @@ export async function openRuntime(
   // registered into. Per call rather than a snapshot, so a policy the runtime
   // was opened with is re-evaluated rather than remembered.
   const reachable = (): ReadonlyArray<{ key: string; provider: string; account: string }> =>
-    config.connections
-      .filter((connection) =>
+    selected
+      .filter(({ ref, connection }) =>
         registry
           .capabilities()
           .some(
             ({ id }) =>
               id.startsWith(`${connection.provider}.`) &&
-              allowedConnections(
-                id,
-                [`${connection.provider}.${connection.id}`],
-                principal,
-                policy,
-              ).length > 0,
+              allowedConnections(id, [ref], principal, policy).length > 0,
           ),
       )
-      .map((connection) => ({
-        key: `${connection.provider}.${connection.id}`,
+      .map(({ ref, connection }) => ({
+        key: ref,
         provider: connection.provider,
         account: connection.account,
         ...(connection.label ? { label: connection.label } : {}),
@@ -253,14 +213,14 @@ export async function openRuntime(
   // tolerated when the store is a repository: a local directory that will not
   // read is a real fault worth failing on, exactly as it always was.
   const loaded = await readSkillsForStart(
-    skills,
+    skills ?? EMPTY_SKILL_STORE,
     knowledge !== undefined,
     (message) => logger.warn(message),
-    ` --profile ${config.instance.profile} --target ${target}`,
+    ` --profile ${config.instance.profile} --workspace ${target}`,
   );
 
-  registry = await buildRegistryWithWorkspace(root, config.instance.profile, {
-    skillStore: skills,
+  registry = await buildRegistryWithWorkspace(root, {
+    ...(skills ? { skillStore: skills } : {}),
     skills: loaded.skills,
     onSkillsChanged: refreshSkills,
     vault: { store: vaultStore, items: await vaultStore.ids() },
@@ -269,7 +229,7 @@ export async function openRuntime(
       target,
       profiles: await listProfiles(root),
       catalogue: PROVIDER_MANIFESTS,
-      ownClients: Object.keys(config.oauth_apps),
+      ownClients: Object.keys(connectionsFile.oauth_apps),
       reachable,
     },
     // Straight off the config: unlike `reachable`, nothing has to be filtered
@@ -329,14 +289,16 @@ export async function openRuntime(
     credentials,
     // From the connection row, which is where a per-connection setting has
     // always lived. One lookup behind both, so they cannot disagree.
-    connectionConfig: (provider, id) => row(config, provider, id)?.config,
-    isDeclared: (provider, id) => row(config, provider, id) !== undefined,
+    connectionConfig: (provider, id) => row(connectionsFile.connections, provider, id)?.config,
+    isDeclared: (provider, id) => row(connectionsFile.connections, provider, id) !== undefined,
   });
   const authorizeRequest = requestAuthorizer(registry, credentials);
   let closed = false;
 
   const dispatcher = new Dispatcher({
     config,
+    connections: connectionsFile.connections,
+    oauthApps: Object.keys(connectionsFile.oauth_apps),
     registry,
     connectorFor,
     authorizeRequest,
@@ -354,6 +316,9 @@ export async function openRuntime(
     config,
     target,
     declared,
+    connections: selected,
+    workspaceConnections: connectionsFile.connections,
+    ownClients: Object.keys(connectionsFile.oauth_apps),
     state,
     audit,
     credentials,
@@ -390,5 +355,5 @@ export async function openRuntime(
   };
 }
 
-const row = (config: Config, provider: string, id: string) =>
-  config.connections.find((connection) => connection.provider === provider && connection.id === id);
+const row = (connections: readonly ConnectionConfig[], provider: string, id: string) =>
+  connections.find((connection) => connection.provider === provider && connection.id === id);

package/src/cli/runtime/registry.ts

@@ -3,7 +3,7 @@ import type { ProviderDefinition } from '#connectivity';
 import { ConfigError } from '#profile';
 import { ProviderRegistry } from '#registry';
 import { RESERVED_BY_GRAMMAR } from '../commands/connect/custom/spec.ts';
-import { loadProfileProviders } from '#providers/custom/index.ts';
+import { loadWorkspaceProviders } from '#providers/custom/index.ts';
 import { loadProfileSkills, type LoadedSkill } from '#providers/skills/store.ts';
 import { exampleProvider } from '#providers/example/provider.ts';
 import {
@@ -138,21 +138,20 @@ export function buildRegistry(owner: OwnerLayerOptions = {}): ProviderRegistry {
  * overriding it — an operator shadowing `gmail` by accident would be very hard
  * to diagnose from the outside.
  *
- * The profile is a parameter rather than read from a config here because two of
- * the three callers do not have one: `deploy` walks every profile in turn, and
- * `profile remove` is holding the name of the one being deleted. Passing it
- * makes "which profile's manifests" a question the caller has already answered.
+ * No profile parameter any more. Manifests moved to the workspace with the
+ * connections they describe (ADR-057), so "which profile's manifests" stopped
+ * being a question — and with it the whole reason `deploy` had to rebuild a
+ * registry per profile to collect credential refs.
  */
 export async function buildRegistryWithWorkspace(
   root: string,
-  profile: string,
   owner: OwnerLayerOptions = {},
 ): Promise<ProviderRegistry> {
   const skills =
     owner.skills ?? (owner.skillStore ? await loadProfileSkills(owner.skillStore) : []);
   const registry = buildRegistry({ ...owner, skills });
 
-  for (const { manifest, path } of await loadProfileProviders(root, profile)) {
+  for (const { manifest, path } of await loadWorkspaceProviders(root)) {
     if (registry.has(manifest.id)) {
       throw new ConfigError(
         `${path}: provider "${manifest.id}" is already built in. Rename it, or remove the file to use the built-in.`,