@lanes-sh/link 0.8.0 → 0.9.0

package/src/profile/load.ts

@@ -39,8 +39,12 @@ export interface LoadedConfig {
  *  3. Schema shape.
  *  4. Referential integrity, which needs a well-formed document to check.
  */
-export function validateConfig(raw: unknown, source = '<config>'): Config {
-  const config = validateConfigShape(raw, source);
+export function validateConfig(
+  raw: unknown,
+  source = '<config>',
+  contract = SUPPORTED_CONTRACT,
+): Config {
+  const config = validateConfigShape(raw, source, contract);
   assertReferentialIntegrity(config, source);
   return config;
 }
@@ -58,12 +62,16 @@ export function validateConfig(raw: unknown, source = '<config>'): Config {
  * through `validateConfig`, and the split exists so that the one command whose
  * job is to fix a refusal is not blocked by it.
  */
-export function validateConfigShape(raw: unknown, source = '<config>'): Config {
+export function validateConfigShape(
+  raw: unknown,
+  source = '<config>',
+  contract = SUPPORTED_CONTRACT,
+): Config {
   if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
     throw new ConfigError(`${source}: expected a YAML mapping at the top level`);
   }
 
-  assertSupportedContract(raw, source);
+  assertSupportedContract(raw, source, contract);
 
   const secrets = findSecrets(raw);
   if (secrets.length > 0) {
@@ -88,7 +96,17 @@ export function validateConfigShape(raw: unknown, source = '<config>'): Config {
  * risks reading a document as more permissive than the operator wrote it, and
  * refusing to start is always the safer failure.
  */
-function assertSupportedContract(raw: object, source: string): void {
+/**
+ * The contract this document must declare.
+ *
+ * `expected` is `SUPPORTED_CONTRACT` everywhere except inside a migration,
+ * which writes intermediate shapes on the way to the newest one — contract 1 to
+ * 2 to 3 to 4, saving at each step. Refusing those would mean a migration
+ * cannot use `ConfigDocument` at all and has to write YAML past the validator,
+ * losing the secret-shaped-value check that is the reason the validator runs on
+ * every save. A step that declares which contract it is producing keeps both.
+ */
+function assertSupportedContract(raw: object, source: string, expected: number): void {
   const contract = (raw as { contract?: unknown }).contract;
 
   if (typeof contract !== 'number' || !Number.isInteger(contract)) {
@@ -97,14 +115,20 @@ function assertSupportedContract(raw: object, source: string): void {
     );
   }
 
-  if (contract !== SUPPORTED_CONTRACT) {
-    const direction = contract > SUPPORTED_CONTRACT ? 'newer than' : 'older than';
+  if (contract !== expected) {
+    const direction = contract > expected ? 'newer than' : 'older than';
     throw new ConfigError(
       `${source}: contract ${contract} is ${direction} the contract this binary implements (${SUPPORTED_CONTRACT}). ` +
         `Refusing to load rather than guessing at what the document means. ` +
+        // **Naming the command is the whole point of this branch.** ADR-051
+        // records what a refusal that names none costs: `validateConfig` runs
+        // from every command, so one stale workspace takes `status`, `start`,
+        // `plan` and `doctor` down together, and "migrate the config" left an
+        // operator with a wall and no door. `doctor --fix` runs every migration
+        // between the contract on disk and this one.
         (contract > SUPPORTED_CONTRACT
           ? 'Upgrade lanes-link.'
-          : 'Migrate the config, or use a matching lanes-link version.'),
+          : 'Migrate it with: lanes link doctor --fix'),
     );
   }
 }
@@ -166,8 +190,11 @@ function formatZodIssues(error: z.ZodError): string {
 export interface ProviderRename {
   /** What a row naming the old id should say instead. */
   readonly to: string;
-  /** The account label that means this row is the built-in, not a vendor one. */
-  readonly keeps: string;
+  /**
+   * The account label that meant this row was the built-in rather than a
+   * vendor's, or `null` where the id belongs to nobody now.
+   */
+  readonly keeps: string | null;
   /** What the plain noun now names, for the sentence below. */
   readonly becomes: string;
   /** What it used to name. */
@@ -190,8 +217,12 @@ export interface ProviderRename {
 export const RENAMED_PROVIDERS: Readonly<Record<string, ProviderRename>> = {
   tasks: {
     to: 'google_tasks',
-    keeps: 'Tasks',
-    becomes: 'the built-in task list',
+    // **`null`, where this was `'Tasks'`.** The refusal existed because the
+    // built-in claimed `tasks`, so a stale Google Tasks row rebound to it and
+    // the label was the only evidence of which was meant (ADR-051). The
+    // built-in is `lanes_tasks` now, so no label makes a row here legitimate.
+    keeps: null,
+    becomes: 'nobody\u2019s provider id \u2014 the built-in task list is lanes_tasks',
     was: 'Google Tasks',
     noun: 'task list',
   },
@@ -217,8 +248,9 @@ export function renamedProviderFor(connection: {
   account: string;
 }): ProviderRename | null {
   const moved = RENAMED_PROVIDERS[connection.provider];
-  if (!moved || connection.account === moved.keeps) return null;
-  return moved;
+  if (!moved) return null;
+  // `keeps === null` means the id belongs to nobody, so no label exempts a row.
+  return moved.keeps !== null && connection.account === moved.keeps ? null : moved;
 }
 
 export function describeRename(
@@ -229,11 +261,15 @@ export function describeRename(
   if (!moved) return null;
 
   return (
-    `"${connection.provider}" is now ${moved.becomes}, and this row is labelled ` +
-    `"${connection.account}" rather than "${moved.keeps}".\n` +
+    (moved.keeps === null
+      ? `"${connection.provider}" is ${moved.becomes}.\n`
+      : `"${connection.provider}" is now ${moved.becomes}, and this row is labelled ` +
+        `"${connection.account}" rather than "${moved.keeps}".\n`) +
     `  If it was ${moved.was}: set provider to ${moved.to} here, and rename any ` +
     `"${connection.provider}.*" policy rule.\n` +
-    `  If it is your own ${moved.noun}: set account to ${moved.keeps}.\n` +
+    (moved.keeps === null
+      ? `  If it is your own ${moved.noun}: it is lanes_${connection.provider} now.\n`
+      : `  If it is your own ${moved.noun}: set account to ${moved.keeps}.\n`) +
     `  ${repair} applies the first, where a stored credential proves it.`
   );
 }

package/src/profile/schema.ts

@@ -50,11 +50,20 @@ import { knowledgeTargetSchema } from './knowledge.ts';
  * `members:`, because a profile worth sharing needs to say who may consume it
  * (ADR-060).
  *
+ * **4 gave a profile its bytes back, and retired `data/`** (ADR-066, ADR-067).
+ * Contract 3 moved the owner layer's stores beside the *connection*, so a
+ * profile owned nothing and two profiles granting one memory read one note. The
+ * profile is the container again — `profiles/<name>/` holds its declaration and
+ * everything it owns — and `data/`, which had been the line between what a
+ * revision reads and what it writes, stopped drawing that line the moment the
+ * declaration moved inside it. No file's *shape* changed: `grants:`,
+ * `members:` and `connections.yaml` are untouched, and only the paths moved.
+ *
  * A hard cut each time, and only the newest is read here. `./legacy.ts`
  * understands the older shapes and only the migration uses it — a runtime that
  * loaded either would be the two-sources-of-truth problem again, one level up.
  */
-export const SUPPORTED_CONTRACT = 3;
+export const SUPPORTED_CONTRACT = 4;
 
 /**
  * There is no `database:` block any more.
@@ -363,7 +372,7 @@ export const policySchema = z.object({
  * So the refusal is at load, where it names both rows, rather than at call time
  * where one would silently win.
  */
-export const SINGLE_INSTANCE_PROVIDERS: readonly string[] = ['skills', 'vault'];
+export const SINGLE_INSTANCE_PROVIDERS: readonly string[] = ['lanes_skills', 'lanes_vault'];
 
 /**
  * One connection, and what may be done with it (ADR-058).

package/src/profile/testing.ts

@@ -89,13 +89,13 @@ export function connectionsYaml(
   extra: readonly { id: string; provider: string; account: string }[] = [],
 ): string {
   const owner = [
-    { id: 'main', provider: 'memory', account: 'Memory' },
-    { id: 'main', provider: 'tasks', account: 'Tasks' },
-    { id: 'main', provider: 'assets', account: 'Assets' },
-    { id: 'main', provider: 'skills', account: 'Skills' },
-    { id: 'main', provider: 'vault', account: 'Vault' },
-    { id: 'main', provider: 'setup', account: 'Setup' },
-    { id: 'main', provider: 'entities', account: 'Entities' },
+    { id: 'lan1', provider: 'lanes_memory', account: 'Memory' },
+    { id: 'lan2', provider: 'lanes_tasks', account: 'Tasks' },
+    { id: 'lan3', provider: 'lanes_assets', account: 'Assets' },
+    { id: 'lan4', provider: 'lanes_skills', account: 'Skills' },
+    { id: 'lan5', provider: 'lanes_vault', account: 'Vault' },
+    { id: 'lan6', provider: 'lanes_setup', account: 'Setup' },
+    { id: 'lan7', provider: 'lanes_entities', account: 'Entities' },
   ];
 
   const rows = [...owner, ...extra]
@@ -109,9 +109,19 @@ export function connectionsYaml(
 export function grantsYaml(
   extra: readonly { connection: string; allow?: readonly string[]; deny?: readonly string[] }[] = [],
 ): string {
-  const owner = ['memory', 'tasks', 'assets', 'skills', 'vault', 'setup', 'entities'].map(
-    (provider) => ({ connection: `${provider}.main`, allow: [`${provider}.*`], deny: [] }),
-  );
+  const owner = [
+    'lanes_memory',
+    'lanes_tasks',
+    'lanes_assets',
+    'lanes_skills',
+    'lanes_vault',
+    'lanes_setup',
+    'lanes_entities',
+  ].map((provider, index) => ({
+    connection: `${provider}.lan${index + 1}`,
+    allow: [`${provider}.*`],
+    deny: [],
+  }));
 
   return [...owner, ...extra]
     .map(
@@ -143,3 +153,28 @@ export function profileYaml(
     `members:${members ? `\n${members}` : ' []'}\n`
   );
 }
+
+/**
+ * Write a profile's declaration into a fixture workspace.
+ *
+ * A profile is a directory now (ADR-067), so writing one means creating that
+ * directory — which every fixture that used to write `profiles/<name>.yaml`
+ * beside its siblings got for free. Centralised here rather than repeated in
+ * twenty test files, for the reason `layout.ts` exists at all: the last time a
+ * path was spelled in two places one of them went stale, and the failure was a
+ * listing that disagreed with a loader about what existed.
+ */
+export async function writeProfileFixture(
+  root: string,
+  profile: string,
+  body: string,
+): Promise<string> {
+  const { mkdir, writeFile } = await import('node:fs/promises');
+  const { dirname, join } = await import('node:path');
+  const { layout } = await import('./layout.ts');
+
+  const path = join(root, layout.profileConfig(profile));
+  await mkdir(dirname(path), { recursive: true });
+  await writeFile(path, body);
+  return path;
+}

package/src/profile/workspace.ts

@@ -1,4 +1,5 @@
 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';
@@ -19,13 +20,8 @@ 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
@@ -33,23 +29,23 @@ import { findSecrets, formatSecretFindings } from './secret-detection.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 {
@@ -104,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;
@@ -114,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
@@ -144,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);
 }
 
@@ -153,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);
 
@@ -208,9 +206,13 @@ export async function readConnections(workspaceRoot: string): Promise<Connection
 }
 
 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) {
@@ -223,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 [];
   }
@@ -254,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.'),

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/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:

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'),
       }),
@@ -326,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,
             },
             {
@@ -370,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/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.`,
             },
           ],
         };