@lanes-sh/link 0.7.2 → 0.9.0

package/src/profile/workspace.ts

@@ -1,22 +1,27 @@
 import { existsSync } from 'node:fs';
+import { layout, legacyProfileConfig, LEGACY_WORKSPACE_FILE, PROFILE_FILE } from './layout.ts';
 import { isRemoteWorkspace, readWorkspaceFile, workspaceFiles } from './files.ts';
 import { parseConfig, type LoadedConfig } from './load.ts';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 import { parse as parseYaml } from 'yaml';
 import { ConfigError } from './load.ts';
-import { workspaceSchema, type Config, type WorkspaceConfig } from './schema.ts';
+import {
+  SUPPORTED_CONTRACT,
+  connectionsFileSchema,
+  workspaceSchema,
+  type Config,
+  type ConnectionsFile,
+  type WorkspaceConfig,
+} from './schema.ts';
+import { assertConnectionsUnique, assertNoRenamedProviders } from './connections.ts';
+import { findSecrets, formatSecretFindings } from './secret-detection.ts';
 
 /**
  * Workspace and profile resolution.
  *
- * A workspace is a directory holding one or more profiles:
- *
- *   lanes-link.yaml      workspace settings: contract, default_profile
- *   profiles/
- *     personal.yaml
- *     work.yaml
- *   data/               local state per profile, gitignored
+ * A workspace holds its registry, its accounts, and one directory per profile.
+ * `layout.ts` has the tree.
  *
  * **A command says which profile it means, or it does not run** (ADR-037).
  * `--profile` is the only thing that selects one. `LANES_LINK_PROFILE` and
@@ -24,23 +29,23 @@ import { workspaceSchema, type Config, type WorkspaceConfig } from './schema.ts'
  *
  * The argument this replaces was that persisted selection is how operators act
  * on the wrong thing, and that a *visible* fallback — an exported variable, a
- * key in a file the operator reads, and a line printed before every command —
- * was therefore safe. The first half stands and is why this rule exists at all.
+ * key in a file the operator reads, a line printed before every command — was
+ * therefore safe. The first half stands and is why this rule exists at all.
  * What did not survive is the conclusion: the printed line is a dim grey one,
  * and a fallback made an ignored flag survivable, so `profile add --target
  * cloud` dropping its flag surfaced on the *next* command, from a different
- * source, detached from its cause. A resolver with nothing to fall back to
- * cannot do that.
+ * source, detached from its cause. A resolver with nothing to fall back to cannot.
  *
  * The workspace root is deliberately not part of this and keeps its chain —
- * `LANES_LINK_HOME`, then an ancestor holding `lanes-link.yaml`, then
- * `~/.lanes-link`. Getting it wrong yields "no profiles here" rather than an
+ * `LANES_LINK_HOME`, then an ancestor holding `workspaces.yaml` (or the
+ * `lanes-link.yaml` it was called before contract 4), then `~/.lanes-link`.
+ * Getting it wrong yields "no profiles here" rather than an
  * action against the wrong account, it is the only channel a container has for
  * its bucket (ADR-023), and the ancestor walk is what makes a per-repository
  * workspace work at all.
  */
 
-export const WORKSPACE_FILE = 'lanes-link.yaml';
+export const WORKSPACE_FILE = 'workspaces.yaml';
 
 /** A profile, found. Everything a command needs before it has read the config. */
 export interface ProfileSelection {
@@ -95,7 +100,9 @@ export function resolveWorkspaceRoot(options: ResolveOptions = {}): string {
     // `existsSync`, not `Bun.file(path).size`: a missing file reports size 0,
     // so a `>= 0` check would call every candidate a workspace and stop at the
     // first directory it looked at.
-    if (existsSync(join(directory, WORKSPACE_FILE))) return directory;
+    // Either name: a root that cannot be found cannot be migrated.
+    const marker = (name: string): boolean => existsSync(join(directory, name));
+    if (marker(WORKSPACE_FILE) || marker(LEGACY_WORKSPACE_FILE)) return directory;
     const parent = dirname(directory);
     if (parent === directory) break;
     directory = parent;
@@ -105,7 +112,7 @@ export function resolveWorkspaceRoot(options: ResolveOptions = {}): string {
 }
 
 /**
- * Where Lanes Link itself is installed — the directory holding `package.json`,
+ * Where Lanes Link itself is installed — the directory with `package.json`,
  * and with it `skills/` and `docs/`.
  *
  * Not the workspace: this is the code, not the operator's data. Found by
@@ -135,7 +142,7 @@ export function installRoot(from: string): string {
  * workspace stopped being a directory.
  */
 export function profilePath(workspaceRoot: string, profile: string): string {
-  const key = `profiles/${profile}.yaml`;
+  const key = layout.profileConfig(profile);
   return isRemoteWorkspace(workspaceRoot) ? `${workspaceRoot}/${key}` : join(workspaceRoot, key);
 }
 
@@ -144,7 +151,7 @@ export async function loadProfileConfig(
   workspaceRoot: string,
   profile: string,
 ): Promise<LoadedConfig> {
-  const key = `profiles/${profile}.yaml`;
+  const key = layout.profileConfig(profile);
   const text = await readWorkspaceFile(workspaceFiles(workspaceRoot), key);
   const shown = profilePath(workspaceRoot, profile);
 
@@ -152,10 +159,60 @@ export async function loadProfileConfig(
   return parseConfig(text, shown);
 }
 
+/** `connections.yaml` sits beside `lanes-link.yaml`, at the workspace root. */
+export const CONNECTIONS_FILE = 'connections.yaml';
+
+/**
+ * Every account authorised in this workspace (ADR-057).
+ *
+ * Absent is not an error. A workspace that has never connected anything has no
+ * file, and returning an empty set rather than throwing is what lets `profile
+ * add`, `status` and `doctor` answer on a fresh install — the same reasoning
+ * `readWorkspace` uses for returning null.
+ *
+ * Read through the workspace store rather than the filesystem, so a deployed
+ * revision whose root is a bucket URL loads it (ADR-049). That was the exact
+ * bug manifests hit: a filesystem read against a `gs://` root silently found
+ * nothing and every custom provider vanished.
+ */
+export async function readConnections(workspaceRoot: string): Promise<ConnectionsFile> {
+  const path = join(workspaceRoot, CONNECTIONS_FILE);
+  const text = await readWorkspaceFile(workspaceFiles(workspaceRoot), CONNECTIONS_FILE);
+  if (text === null) return { contract: SUPPORTED_CONTRACT, connections: [], oauth_apps: {} };
+
+  const raw = parseYaml(text);
+
+  const secrets = findSecrets(raw);
+  if (secrets.length > 0) {
+    throw new ConfigError(
+      `${path}: ${formatSecretFindings(secrets)}`,
+      secrets.map((finding) => finding.path),
+    );
+  }
+
+  const parsed = connectionsFileSchema.safeParse(raw);
+  if (!parsed.success) {
+    throw new ConfigError(
+      `${path}:\n${parsed.error.issues.map((i) => `  ${i.path.join('.')}: ${i.message}`).join('\n')}`,
+    );
+  }
+
+  assertConnectionsUnique(parsed.data.connections);
+  assertNoRenamedProviders(
+    parsed.data.connections,
+    'lanes link doctor --fix --profile <name> --workspace <name>',
+  );
+  return parsed.data;
+}
+
 export async function readWorkspace(workspaceRoot: string): Promise<WorkspaceConfig | null> {
-  const path = join(workspaceRoot, WORKSPACE_FILE);
-  const text = await readWorkspaceFile(workspaceFiles(workspaceRoot), WORKSPACE_FILE);
+  // New name first: a workspace mid-migration still has the old file, and
+  // preferring it would undo the rename on the next write.
+  const files = workspaceFiles(workspaceRoot);
+  const current = await readWorkspaceFile(files, WORKSPACE_FILE);
+  const text = current ?? (await readWorkspaceFile(files, LEGACY_WORKSPACE_FILE));
   if (text === null) return null;
+  const path = join(workspaceRoot, current === null ? LEGACY_WORKSPACE_FILE : WORKSPACE_FILE);
 
   const parsed = workspaceSchema.safeParse(parseYaml(text));
   if (!parsed.success) {
@@ -168,15 +225,34 @@ export async function readWorkspace(workspaceRoot: string): Promise<WorkspaceCon
 
 export async function listProfiles(workspaceRoot: string): Promise<string[]> {
   try {
-    const entries = await workspaceFiles(workspaceRoot).list('profiles/');
-    return entries
-      .map((entry) => entry.key.slice('profiles/'.length))
-      .filter((name) => name.endsWith('.yaml') && !name.endsWith('.example.yaml'))
-      // Direct children only: a nested directory under `profiles/` is not a
-      // profile, and a bucket listing is flat so it would otherwise look like one.
-      .filter((name) => !name.includes('/'))
-      .map((name) => name.slice(0, -'.yaml'.length))
-      .sort();
+    const root = `${layout.profilesRoot()}/`;
+    const entries = await workspaceFiles(workspaceRoot).list(root);
+
+    // A profile is a *directory* holding a `profile.yaml` (ADR-067), so the
+    // shape matched is `<name>/profile.yaml`. The listing walks each profile's
+    // memory and assets on the way past, which is the price of the declaration
+    // sitting beside the bytes; `audit.log/` is the workspace's, so the largest
+    // collection is not in here.
+    //
+    // **Both shapes**, because every migration enumerates through here: listing
+    // only the new one leaves an unmigrated workspace holding no profiles as
+    // far as its own migration is concerned. Same rule as the marker file.
+    const names = new Set<string>();
+    for (const entry of entries) {
+      const rest = entry.key.slice(root.length);
+      const parts = rest.split('/');
+
+      if (parts.length === 2 && parts[1] === PROFILE_FILE) {
+        names.add(parts[0]!);
+        continue;
+      }
+
+      // Contract 3 and earlier. `.example.yaml` was never a profile.
+      if (parts.length === 1 && rest.endsWith('.yaml') && !rest.endsWith('.example.yaml')) {
+        names.add(rest.slice(0, -'.yaml'.length));
+      }
+    }
+    return [...names].sort();
   } catch {
     return [];
   }
@@ -199,8 +275,23 @@ export async function resolveSelection(options: ResolveOptions = {}): Promise<Pr
   if (!profile) throw noProfileNamed(workspaceRoot, await listProfiles(workspaceRoot), env);
 
   const path = profilePath(workspaceRoot, profile);
-  if (!(await workspaceFiles(workspaceRoot).has(`profiles/${profile}.yaml`))) {
+  const files = workspaceFiles(workspaceRoot);
+
+  if (!(await files.has(layout.profileConfig(profile)))) {
     const available = await listProfiles(workspaceRoot);
+
+    // **It exists, at the path contract 3 kept it.** Without this the refusal
+    // reads "profile personal does not exist. Available: personal" — what a
+    // listing that understands both layouts and a lookup that understands one
+    // produce together — and names no way forward (ADR-051).
+    if (await files.has(legacyProfileConfig(profile))) {
+      throw new ConfigError(
+        `Profile "${profile}" is still laid out the way contract 3 kept it, and nothing reads ` +
+          `that any more.\n  Migrate it with: lanes link doctor --fix --profile ${profile} ` +
+          '--workspace <name>',
+      );
+    }
+
     throw new ConfigError(
       `Profile "${profile}" does not exist (looked for ${path}).\n` +
         (available.length > 0 ? `Available: ${available.join(', ')}` : 'No profiles exist yet.'),
@@ -219,7 +310,7 @@ export function noProfileNamed(
   if (available.length === 0) {
     return new ConfigError(
       `--profile is required, and ${workspaceRoot} holds no profiles yet.\n` +
-        '  Create one with: lanes link profile add <name> --target local',
+        '  Create one with: lanes link profile add <name> --workspace local',
     );
   }
 
@@ -230,7 +321,7 @@ export function noProfileNamed(
       'nothing else selects one.\n\n' +
       `  Profiles in ${workspaceRoot}\n` +
       available.map((name) => `    ${name}`).join('\n') +
-      `\n\n  e.g. lanes link status --profile ${available[0]} --target <target>` +
+      `\n\n  e.g. lanes link status --profile ${available[0]} --workspace <name>` +
       (stale
         ? `\n\n  LANES_LINK_PROFILE=${stale} is set in this shell and is no longer read.\n` +
           '  Unset it, or pass --profile.'

package/src/providers/assets/provider.ts

@@ -72,7 +72,7 @@ const MAX_ASSET_BYTES = 25 * 1024 * 1024;
 const MAX_TEXT_BYTES = 256 * 1024;
 
 export const assetsProvider: ProviderDefinition = defineLocalProvider({
-  id: 'assets',
+  id: 'lanes_assets',
   name: 'Assets',
   version: '1.0.0',
   description:
@@ -104,12 +104,12 @@ export const assetsProvider: ProviderDefinition = defineLocalProvider({
       title: 'Stored file',
       description:
         'One stored file, addressed by its name. Text comes back as text; anything else is described rather than encoded.',
-      uriTemplate: 'assets://file/{name}',
+      uriTemplate: 'lanes-assets://file/{name}',
       redact: keepKeys('uri'),
 
       async list(context) {
         return (await allAssets(context.storage)).map((asset) => ({
-          uri: `assets://file/${encodeURIComponent(asset.name)}`,
+          uri: `lanes-assets://file/${encodeURIComponent(asset.name)}`,
           name: asset.name,
         }));
       },
@@ -171,7 +171,7 @@ export const assetsProvider: ProviderDefinition = defineLocalProvider({
             ...shown.flatMap((asset) => [
               {
                 type: 'resource_link' as const,
-                uri: `assets://file/${encodeURIComponent(asset.name)}`,
+                uri: `lanes-assets://file/${encodeURIComponent(asset.name)}`,
                 name: asset.name,
               },
               { type: 'text' as const, text: describeAsset(asset) },
@@ -194,7 +194,7 @@ export const assetsProvider: ProviderDefinition = defineLocalProvider({
       name: 'get',
       title: 'Read a stored file',
       description:
-        'Return a text file\'s contents. A binary file is described instead — name, type, size, digest — because encoding it here is the cost this provider exists to avoid. The resource assets://file/{name} is the same content.',
+        'Return a text file\'s contents. A binary file is described instead — name, type, size, digest — because encoding it here is the cost this provider exists to avoid. The resource lanes-assets://file/{name} is the same content.',
       inputSchema: z.object({ name: z.string().min(1).describe('The file name') }),
       redact: keepKeys('name'),
       async handler({ name }, context) {
@@ -271,7 +271,7 @@ export const assetsProvider: ProviderDefinition = defineLocalProvider({
             },
             {
               type: 'resource_link',
-              uri: `assets://file/${encodeURIComponent(assetName)}`,
+              uri: `lanes-assets://file/${encodeURIComponent(assetName)}`,
               name: assetName,
             },
           ],

package/src/providers/custom/index.ts

@@ -12,5 +12,5 @@
  * connectivity type; `load.ts` reads and validates them.
  */
 
-export { loadProfileProviders, parseManifest, type LoadedManifest } from './load.ts';
+export { loadWorkspaceProviders, parseManifest, type LoadedManifest } from './load.ts';
 export { manifestTemplate } from './template.ts';

package/src/providers/custom/load.ts

@@ -38,14 +38,13 @@ export interface LoadedManifest {
   readonly path: string;
 }
 
-export async function loadProfileProviders(
+export async function loadWorkspaceProviders(
   workspaceRoot: string,
-  profile: string,
   /** Injected for tests. A bucket is the case this exists to cover. */
   store?: BlobStore,
 ): Promise<LoadedManifest[]> {
   const files = store ?? workspaceFiles(workspaceRoot);
-  const directory = layout.providers(profile);
+  const directory = layout.providers();
 
   let keys: string[];
   try {

package/src/providers/entities/provider.ts

@@ -58,7 +58,7 @@ const DESCRIPTION =
   'so more than one means ask rather than take the first.';
 
 export const entitiesProvider: ProviderDefinition = defineLocalProvider({
-  id: 'entities',
+  id: 'lanes_entities',
   name: 'Entities',
   version: '1.0.0',
   description: DESCRIPTION,
@@ -99,14 +99,14 @@ export const entitiesProvider: ProviderDefinition = defineLocalProvider({
       name: 'entity',
       title: 'Entity',
       description: 'One declared entity, addressed by its id.',
-      uriTemplate: 'entities://entity/{id}',
+      uriTemplate: 'lanes-entities://entity/{id}',
       mimeType: 'text/markdown',
       redact: keepKeys('uri'),
 
       async list(context) {
         const catalogue = await openCatalogue(context.storage);
         return catalogue.entities.map((entity) => ({
-          uri: `entities://entity/${encodeURIComponent(entity.id)}`,
+          uri: `lanes-entities://entity/${encodeURIComponent(entity.id)}`,
           name: entity.name,
         }));
       },
@@ -230,7 +230,7 @@ export const entitiesProvider: ProviderDefinition = defineLocalProvider({
               { type: 'text', text: renderCandidates(matches, criteria, context.connection.key) },
               ...matches.candidates.map((one) => ({
                 type: 'resource_link' as const,
-                uri: `entities://entity/${encodeURIComponent(one.entity.id)}`,
+                uri: `lanes-entities://entity/${encodeURIComponent(one.entity.id)}`,
                 name: one.entity.name,
               })),
             ],
@@ -244,7 +244,7 @@ export const entitiesProvider: ProviderDefinition = defineLocalProvider({
           content: [
             {
               type: 'resource_link' as const,
-              uri: `entities://entity/${encodeURIComponent(found.id)}`,
+              uri: `lanes-entities://entity/${encodeURIComponent(found.id)}`,
               name: found.name,
             },
             { type: 'text', text: renderEntity(found, catalogue, file?.body ?? '') },
@@ -259,7 +259,7 @@ export const entitiesProvider: ProviderDefinition = defineLocalProvider({
       title: 'Read one entity',
       description:
         'Return one entity by id, with its relationships and everything pointing at it. The resource ' +
-        'entities://entity/{id} is the same content; this exists for clients that do not read resources.',
+        'lanes-entities://entity/{id} is the same content; this exists for clients that do not read resources.',
       inputSchema: z.object({ id: z.string().min(1).describe('Entity id') }),
       redact: keepKeys('id'),
       async handler({ id }, context) {

package/src/providers/entities/writes.ts

@@ -120,7 +120,7 @@ export const writeCapabilities: readonly Capability[] = [
               type: 'text',
               text: `${existing === null ? 'Declared' : 'Updated'} "${id}" on ${context.connection.key}.`,
             },
-            { type: 'resource_link', uri: `entities://entity/${id}`, name },
+            { type: 'resource_link', uri: `lanes-entities://entity/${id}`, name },
           ],
         };
       },

package/src/providers/identity/provider.ts

@@ -65,7 +65,7 @@ export function createIdentityProvider(options: IdentityProviderOptions): Provid
   const entries = options.entries ?? [];
 
   return defineLocalProvider({
-    id: 'identity',
+    id: 'lanes_identity',
     name: 'Identity',
     version: '1.0.0',
     description:
@@ -128,7 +128,7 @@ function render(
     // Both flags, spelled out. They are required (ADR-037), so a command
     // missing either is one the owner pastes and watches refuse — and this is
     // handed to an agent, which relays it verbatim.
-    const where = `--profile ${profile}${target ? ` --target ${target}` : ''}`;
+    const where = `--profile ${profile}${target ? ` --workspace ${target}` : ''}`;
     return (
       `Profile "${profile}" declares no identity.\n\n` +
       'Nothing here says what name or address to use, so do not invent one — ask. ' +

package/src/providers/memory/provider.ts

@@ -172,7 +172,7 @@ function slugify(title: string): string {
 }
 
 export const memoryProvider: ProviderDefinition = defineLocalProvider({
-  id: 'memory',
+  id: 'lanes_memory',
   name: 'Memory',
   version: '1.0.0',
   description:
@@ -212,7 +212,7 @@ export const memoryProvider: ProviderDefinition = defineLocalProvider({
       name: 'entry',
       title: 'Memory entry',
       description: 'One stored memory entry, addressed by its id.',
-      uriTemplate: 'memory://entry/{id}',
+      uriTemplate: 'lanes-memory://entry/{id}',
       mimeType: 'text/markdown',
       // The address is worth recording and the content is not — the same trade
       // `gmail.get_message` makes with a message id.
@@ -220,7 +220,7 @@ export const memoryProvider: ProviderDefinition = defineLocalProvider({
 
       async list(context) {
         return (await allEntries(context.storage)).map((entry) => ({
-          uri: `memory://entry/${encodeURIComponent(entry.id)}`,
+          uri: `lanes-memory://entry/${encodeURIComponent(entry.id)}`,
           name: entry.title,
         }));
       },
@@ -242,7 +242,7 @@ export const memoryProvider: ProviderDefinition = defineLocalProvider({
       name: 'get',
       title: 'Read a memory entry',
       description:
-        'Return one entry by id. The resource memory://entry/{id} is the same content; this exists for clients that do not read resources.',
+        'Return one entry by id. The resource lanes-memory://entry/{id} is the same content; this exists for clients that do not read resources.',
       inputSchema: z.object({
         id: z.string().min(1).describe('Entry id'),
       }),
@@ -272,8 +272,26 @@ export const memoryProvider: ProviderDefinition = defineLocalProvider({
         tag: z.string().optional().describe('Restrict to entries carrying this tag'),
         limit: z.number().int().min(1).max(50).optional().describe(`Maximum results (default ${DEFAULT_LIMIT})`),
       }),
-      // Nothing kept: a memory query is as revealing as a Gmail search query,
-      // and frequently more so — it is the owner's own material being asked for.
+      // Kept, and this reverses the rule the rest of this file follows.
+      //
+      // The old comment here read "a memory query is as revealing as a Gmail
+      // search query, and frequently more so", which is true and is an argument
+      // about the wrong thing. A search term is not the owner's material: it is
+      // what an *agent* went looking for in that material, which is precisely
+      // the question this log exists to answer. Withholding it leaves a record
+      // saying memory was searched, twice, and matched nothing, with no way to
+      // tell a calendar lookup from a rummage through someone's medical notes.
+      //
+      // The body stays withheld either way — `entry` and `get` keep only `uri`
+      // and `id`, so what was *found* is still not in here. This records the
+      // question, not the answer.
+      //
+      // The reason for the old rule was `audit/fanout.ts`: a workspace may ship
+      // copies to stdout or an OTLP collector, and those leave the machine. That
+      // is a real exposure and it is the operator's to weigh, which is what a
+      // declared sink is. It is not a reason to withhold from the durable log on
+      // the operator's own disk.
+      redact: keepKeys('query', 'tag', 'limit'),
       async handler({ query, tag, limit }, context) {
         const needle = query.toLowerCase();
         const entries = await allEntries(context.storage);
@@ -308,7 +326,7 @@ export const memoryProvider: ProviderDefinition = defineLocalProvider({
           content: matches.flatMap(({ entry, snippet }) => [
             {
               type: 'resource_link' as const,
-              uri: `memory://entry/${encodeURIComponent(entry.id)}`,
+              uri: `lanes-memory://entry/${encodeURIComponent(entry.id)}`,
               name: entry.title,
             },
             {
@@ -352,7 +370,7 @@ export const memoryProvider: ProviderDefinition = defineLocalProvider({
         return {
           content: [
             { type: 'text', text: `Stored memory entry "${entryId}" on ${context.connection.key}.` },
-            { type: 'resource_link', uri: `memory://entry/${entryId}`, name: title },
+            { type: 'resource_link', uri: `lanes-memory://entry/${entryId}`, name: title },
           ],
         };
       },

package/src/providers/setup/plan.ts

@@ -137,7 +137,7 @@ export function planFor(
   // missing either is one that refuses, or worse, writes a credential into a
   // store the endpoint that asked for it does not read.
   const command =
-    `lanes link connect ${manifest.id} --profile ${context.profile} --target ${context.target}` +
+    `lanes link connect ${manifest.id} --profile ${context.profile} --workspace ${context.target}` +
     (needsId ? ' --id <name>' : connectionId ? ` --id ${connectionId}` : '');
 
   return {

package/src/providers/setup/provider.ts

@@ -92,7 +92,7 @@ export function createSetupProvider(options: SetupProviderOptions): ProviderDefi
   });
 
   return defineLocalProvider({
-    id: 'setup',
+    id: 'lanes_setup',
     name: 'Setup',
     version: '1.0.0',
     description:
@@ -147,7 +147,7 @@ export function createSetupProvider(options: SetupProviderOptions): ProviderDefi
           'The console steps, the values needed, and the exact command that connects it. ' +
           'Use this to tell the owner what to run — do not compose the command yourself.',
         inputSchema: z.object({
-          id: z.string().min(1).describe('Provider id, as listed by setup_overview — e.g. "notion"'),
+          id: z.string().min(1).describe('Provider id, as listed by lanes_setup_overview — e.g. "notion"'),
           connection: z
             .string()
             .optional()
@@ -167,7 +167,7 @@ export function createSetupProvider(options: SetupProviderOptions): ProviderDefi
                 {
                   type: 'text',
                   text:
-                    `No provider "${id}". Call setup_overview for the ids this endpoint knows.`,
+                    `No provider "${id}". Call lanes_setup_overview for the ids this endpoint knows.`,
                 },
               ],
               isError: true,

package/src/providers/skills/provider.ts

@@ -110,7 +110,7 @@ export function createSkillsProvider(options: SkillsProviderOptions): ProviderDe
   const manage = options.store ? managementCapabilities(options.store, options.onChange) : [];
 
   return defineLocalProvider({
-    id: 'skills',
+    id: 'lanes_skills',
     name: 'Skills',
     version: '1.0.0',
     description:
@@ -246,7 +246,7 @@ function managementCapabilities(
           content: [
             {
               type: 'text',
-              text: `Stored skill "${skill.name}" on ${context.connection.key}. It is available as the prompt "skills_${skill.name}" where policy allows it.`,
+              text: `Stored skill "${skill.name}" on ${context.connection.key}. It is available as the prompt "lanes_skills_${skill.name}" where policy allows it.`,
             },
           ],
         };

package/src/providers/slack/index.ts

@@ -105,12 +105,12 @@ export const slack = defineProvider({
       'Open "OAuth & Permissions" and add the scopes you need under USER TOKEN SCOPES — not Bot Token Scopes; the MCP server reads the user token. The full set this provider asks for in the browser is listed in https://lanes.sh/docs/link/slack.',
       'Choose "Install to Workspace" and approve. A Slack admin may have to approve it for you.',
       'Copy the "User OAuth Token". It starts with xoxp- — not the bot token, which starts with xoxb- and will not work here.',
-      'The token does not expire unless you enable token rotation on the app. If you rotate or reinstall, run: lanes link connect slack --profile personal --target local --auth pasted_token --replace.',
+      'The token does not expire unless you enable token rotation on the app. If you rotate or reinstall, run: lanes link connect slack --profile personal --workspace local --auth pasted_token --replace.',
     ],
     troubleshooting:
       'Slack refused the token. The usual causes are a bot token (xoxb-) pasted where the user token (xoxp-) belongs, ' +
       'a scope missing from USER TOKEN SCOPES, or an app that was reinstalled since — reinstalling mints a new token. ' +
-      'Copy the User OAuth Token from https://api.slack.com/apps and re-run: lanes link connect slack --profile personal --target local --auth pasted_token --replace.',
+      'Copy the User OAuth Token from https://api.slack.com/apps and re-run: lanes link connect slack --profile personal --workspace local --auth pasted_token --replace.',
     prompts: [
       {
         key: 'token',

package/src/providers/tasks/provider.ts

@@ -57,7 +57,7 @@ function matches(task: Task, needle: string): boolean {
 }
 
 export const tasksProvider: ProviderDefinition = defineLocalProvider({
-  id: 'tasks',
+  id: 'lanes_tasks',
   name: 'Tasks',
   version: '1.0.0',
   description:
@@ -92,13 +92,13 @@ export const tasksProvider: ProviderDefinition = defineLocalProvider({
       name: 'task',
       title: 'Task',
       description: 'One task, addressed by its id.',
-      uriTemplate: 'tasks://task/{id}',
+      uriTemplate: 'lanes-tasks://task/{id}',
       mimeType: 'text/markdown',
       redact: keepKeys('uri'),
 
       async list(context) {
         return (await allTasks(context.storage)).map((task) => ({
-          uri: `tasks://task/${encodeURIComponent(task.id)}`,
+          uri: `lanes-tasks://task/${encodeURIComponent(task.id)}`,
           name: task.title,
         }));
       },
@@ -170,7 +170,7 @@ export const tasksProvider: ProviderDefinition = defineLocalProvider({
             ...shown.flatMap((task) => [
               {
                 type: 'resource_link' as const,
-                uri: `tasks://task/${encodeURIComponent(task.id)}`,
+                uri: `lanes-tasks://task/${encodeURIComponent(task.id)}`,
                 name: task.title,
               },
               { type: 'text' as const, text: `${task.id}  ${line(task)}` },
@@ -193,7 +193,7 @@ export const tasksProvider: ProviderDefinition = defineLocalProvider({
       name: 'get',
       title: 'Read a task',
       description:
-        'Return one task by id, notes included. The resource tasks://task/{id} is the same content; this exists for clients that do not read resources.',
+        'Return one task by id, notes included. The resource lanes-tasks://task/{id} is the same content; this exists for clients that do not read resources.',
       inputSchema: z.object({ id: z.string().min(1).describe('Task id') }),
       redact: keepKeys('id'),
       async handler({ id }, context) {
@@ -261,7 +261,7 @@ export const tasksProvider: ProviderDefinition = defineLocalProvider({
               type: 'text',
               text: `${existing ? 'Replaced' : 'Added'} task "${taskId}" on ${context.connection.key}.`,
             },
-            { type: 'resource_link', uri: `tasks://task/${taskId}`, name: title },
+            { type: 'resource_link', uri: `lanes-tasks://task/${taskId}`, name: title },
           ],
         };
       },

package/src/providers/vault/provider.ts

@@ -92,7 +92,7 @@ export function createVaultProvider(options: VaultProviderOptions): ProviderDefi
   }));
 
   return defineLocalProvider({
-    id: 'vault',
+    id: 'lanes_vault',
     name: 'Vault',
     version: '1.0.0',
     description: