cotal-ai 0.108.1 → 0.109.0

package/dist/run.js

@@ -5,34 +5,59 @@
  * (@cotal-ai/manager). The root just picks which surfaces to pull in; `runCli` resolves
  * whatever registered. A new surface (another connector, a control client …) is one more import line.
  *
+ * A daemon entry is the exception: it runs one command for the life of its process, so it imports
+ * only the surfaces that command needs (see the providers below), never the whole CLI.
+ *
  * Reached only via ./cotal.ts, which runs the Node-version preflight first: everything imported
  * here requires Node >= 22 (the UI stack and the bundled nats-server optional dep), so this module
  * must never be the executable entry — importing it on an old Node crashes at parse time.
  */
-// NOTE: registration order across these imports is NOT guaranteed (tsx's entry interop can
-// evaluate the smaller daemon graphs first) — display order is a non-goal here; `help` ranks
-// its groups explicitly (GROUP_ORDER in @cotal-ai/cli).
-import { runCli, stdoutError } from "@cotal-ai/cli"; // self-registers the base surface incl. spawn (foreground + --detach) / stop / ps / attach
-import "@cotal-ai/manager"; // self-registers `supervise` — the agent-supervisor daemon
-import "@cotal-ai/delivery"; // self-registers `deliver` — the server-side Plane-3 delivery daemon
-import "@cotal-ai/runtime"; // self-registers `run` — the workflow-run operator surface (start/resume/ps/journal/answer)
-import "@cotal-ai/auth"; // self-registers login / logout — per-user IdP sessions (device-code sign-in)
-import "./docs.js"; // self-registers `docs`; the docs bundle loads only when `docs` runs
-import "./daemon/command.js"; // self-registers `daemon`: the local machine daemon's authenticated control endpoint (Linux)
-// Self-registers the `ag-ui.frame` part renderer, so `cotal console` and `cotal join` draw an event
-// frame instead of `[unrenderable part kind "ag-ui.frame"]`.
-//
-// IMPORTED HERE BECAUSE NOTHING ELSE IN THIS PROCESS WOULD. The four agent connectors are removable
-// ext plugins materialized lazily by `runCli`, and no `implementations/*` package imports
-// connector-core at runtime — measured, not assumed. So a renderer that only registered inside the
-// connector would be absent from every process that RENDERS, which is the one place it is needed.
-// The seam is worth nothing if the provider never loads at the display site.
-//
-// The narrow subpath rather than the package root, deliberately: the root pulls the MCP server
-// runtime and its zod copy into CLI startup, and a renderer needs none of it.
-import "@cotal-ai/connector-core/agui-render";
 import { registry } from "@cotal-ai/core";
 import { handOverStartupInterrupt, releaseStartupInterrupt } from "./startup-interrupt.js";
+// Each surface self-registers when imported. The whole CLI imports them one after another in this
+// order, which is the order the root's static imports evaluated them in; display order is still a
+// non-goal, since `help` ranks its groups explicitly (GROUP_ORDER in @cotal-ai/cli).
+const surfaces = {
+    cli: () => import("@cotal-ai/cli"), // the base surface incl. spawn (foreground + --detach) / stop / ps / attach
+    manager: () => import("@cotal-ai/manager"), // `supervise` — the agent-supervisor daemon
+    delivery: () => import("@cotal-ai/delivery"), // `deliver` — the server-side Plane-3 delivery daemon
+    runtime: () => import("@cotal-ai/runtime"), // `run` — the workflow-run operator surface (start/resume/ps/journal/answer)
+    auth: () => import("@cotal-ai/auth"), // login / logout — per-user IdP sessions (device-code sign-in)
+    docs: () => import("./docs.js"), // `docs`; the docs bundle loads only when `docs` runs
+    daemon: () => import("./daemon/command.js"), // `daemon`: the local machine daemon's authenticated control endpoint (Linux)
+    // The `ag-ui.frame` part renderer, so `cotal console` and `cotal join` draw an event frame instead
+    // of `[unrenderable part kind "ag-ui.frame"]`.
+    //
+    // IMPORTED HERE BECAUSE NOTHING ELSE IN THIS PROCESS WOULD. The four agent connectors are removable
+    // ext plugins materialized lazily by `runCli`, and no `implementations/*` package imports
+    // connector-core at runtime — measured, not assumed. So a renderer that only registered inside the
+    // connector would be absent from every process that RENDERS, which is the one place it is needed.
+    // The seam is worth nothing if the provider never loads at the display site.
+    //
+    // The narrow subpath rather than the package root, deliberately: the root pulls the MCP server
+    // runtime and its zod copy into CLI startup, and a renderer needs none of it.
+    aguiRender: () => import("@cotal-ai/connector-core/agui-render"),
+};
+const importing = (...names) => async () => { for (const name of names)
+    await surfaces[name](); };
+const commands = (...names) => names.map((name) => ({ kind: "command", name }));
+// The daemon entries. Each imports its own surface and the surfaces whose registrations its run
+// resolves: the auth provider a user-auth mesh dials through (@cotal-ai/auth), and the workflow run
+// host a manager hosts runs with (@cotal-ai/runtime). Nothing else in the CLI is imported, and the
+// command's flags, refusals and exit are `runCli`'s as for any other command.
+registry.provide({ provides: commands("supervise", "__daemon-manager", "__service-manager"), load: importing("manager", "auth", "runtime") });
+registry.provide({ provides: commands("deliver", "__daemon-deliver", "__service-delivery", "feedback-intake", "__service-feedback-intake"), load: importing("delivery", "auth") });
+registry.provide({ provides: commands("auth-service", "__daemon-auth-service", "__service-auth"), load: importing("auth") });
+registry.provide({ provides: commands("__service-unit"), load: () => import("@cotal-ai/cli/service-unit") });
+// The dispatch module reads the command word as `runCli` will, and loads no command. A word a
+// provider declares imports that provider's surfaces; any other word imports them all.
+const { commandWord, runCli, stdoutError } = await import("@cotal-ai/cli/dispatch");
+const argv = process.argv.slice(2);
+const word = commandWord(argv);
+if (word !== undefined && registry.provides("command", word))
+    await registry.load("command", word);
+else
+    await importing(...Object.keys(surfaces))();
 // A CLI must exit quietly when its stdout is closed early — piped to `head`, a pager that quits,
 // or a shell's process substitution (`source <(cotal completion script bash)`). Node otherwise turns the
 // closed-pipe write into a fatal unhandled 'error' event with a stack trace. Mirror SIGPIPE: exit
@@ -49,5 +74,4 @@ process.stdout.on("error", stdoutError);
 // the ONE composition root that loads operator-installed extensions (`cotal ext add …`) — commands,
 // runtimes, connectors, and local process components all self-register from those packages. Library
 // roots keep the explicit-import model.
-const argv = process.argv.slice(2);
 await runCli(registry, argv, { extensions: true, startupNotice: { release: releaseStartupInterrupt, handOver: handOverStartupInterrupt } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cotal-ai",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "description": "Cotal — lateral agent coordination over NATS. Run `npx cotal-ai` for the CLI.",
   "license": "Apache-2.0",
   "keywords": [
@@ -33,26 +33,26 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@cotal-ai/auth": "0.108.1",
-    "@cotal-ai/cli": "0.108.1",
-    "@cotal-ai/connector-core": "0.108.1",
-    "@cotal-ai/core": "0.108.1",
-    "@cotal-ai/delivery": "0.108.1",
-    "@cotal-ai/manager": "0.108.1",
-    "@cotal-ai/runtime": "0.108.1",
-    "@cotal-ai/seat": "0.108.1",
-    "@cotal-ai/workspace": "0.108.1"
+    "@cotal-ai/auth": "0.109.0",
+    "@cotal-ai/cli": "0.109.0",
+    "@cotal-ai/connector-core": "0.109.0",
+    "@cotal-ai/core": "0.109.0",
+    "@cotal-ai/delivery": "0.109.0",
+    "@cotal-ai/manager": "0.109.0",
+    "@cotal-ai/runtime": "0.109.0",
+    "@cotal-ai/seat": "0.109.0",
+    "@cotal-ai/workspace": "0.109.0"
   },
   "devDependencies": {
-    "@cotal-ai/connector-claude-code": "0.108.1",
-    "@cotal-ai/connector-codex": "0.108.1",
-    "@cotal-ai/connector-hermes": "0.108.1",
-    "@cotal-ai/connector-jcode": "0.108.1",
-    "@cotal-ai/connector-opencode": "0.108.1",
-    "@cotal-ai/linear": "0.108.1",
-    "@cotal-ai/pi": "0.108.1",
+    "@cotal-ai/connector-claude-code": "0.109.0",
+    "@cotal-ai/connector-codex": "0.109.0",
+    "@cotal-ai/connector-hermes": "0.109.0",
+    "@cotal-ai/connector-jcode": "0.109.0",
+    "@cotal-ai/connector-opencode": "0.109.0",
+    "@cotal-ai/linear": "0.109.0",
+    "@cotal-ai/pi": "0.109.0",
     "@cotal-ai/smoke-kit": "0.0.0",
-    "@cotal-ai/web": "0.108.1",
+    "@cotal-ai/web": "0.109.0",
     "@nats-io/jetstream": "^3.4.0",
     "@nats-io/transport-node": "^3.4.0",
     "typescript": "^5.9.3"

package/seeded-connectors/claude/dist/mcp.cjs

@@ -69031,6 +69031,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -69117,13 +69119,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -75492,10 +75528,10 @@ async function submitFeedback(input, options = {}) {
 var import_node_child_process3 = require("node:child_process");
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/claude/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cotal-ai/connector-claude-code",
   "description": "Cotal connector for Claude Code: an installed plugin that joins a session to the mesh.",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/seeded-connectors/codex/dist/host.js

@@ -48755,6 +48755,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -48841,13 +48843,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -69582,10 +69618,10 @@ function date4(params) {
 config(en_default());
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/codex/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cotal-ai/connector-codex",
   "description": "Cotal connector for OpenAI Codex: a host-mode peer driving codex app-server, with Codex's own TUI attached and the cotal_* tools served over a loopback MCP endpoint.",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/seeded-connectors/hermes/dist/launch.js

@@ -45077,6 +45077,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -45163,13 +45165,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -63240,10 +63276,10 @@ function date4(params) {
 config(en_default());
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/hermes/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cotal-ai/connector-hermes",
   "description": "Cotal connector for the Hermes (Nous Research) agent.",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/seeded-connectors/hermes/plugin/cotal/_sidecar/standalone.cjs

@@ -44934,6 +44934,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -45020,13 +45022,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -63077,10 +63113,10 @@ function date4(params) {
 config(en_default());
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/jcode/dist/host.js

@@ -45082,6 +45082,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -45168,13 +45170,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -65882,10 +65918,10 @@ function date4(params) {
 config(en_default());
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/jcode/dist/mcp.js

@@ -57541,6 +57541,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -57627,13 +57629,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -58085,10 +58121,10 @@ async function submitFeedback(input, options = {}) {
 import { execFileSync } from "node:child_process";
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/jcode/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cotal-ai/connector-jcode",
   "description": "Cotal connector for Jcode: a host-mode mesh peer driven through Jcode's Harness API bridge.",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/seeded-connectors/opencode/dist/plugin/index.js

@@ -44981,6 +44981,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -45067,13 +45069,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -65593,10 +65629,10 @@ function date4(params) {
 config(en_default());
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/opencode/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cotal-ai/connector-opencode",
   "description": "Cotal connector for OpenCode: a native in-process plugin that joins a session to the mesh.",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",

package/seeded-connectors/pi/dist/index.js

@@ -27449,10 +27449,10 @@ import { isConcreteChannel as isConcreteChannel3, channelInAllow as channelInAll
 import { parsePrincipalKey as parsePrincipalKey2, peerLabel as peerLabel3 } from "@cotal-ai/core";
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/pi/dist/standalone.js

@@ -45114,6 +45114,8 @@ function claims(ext) {
 }
 var Registry = class {
   #byKey = /* @__PURE__ */ new Map();
+  /** `kind:name` → the declared provider that registers it, and its import once one has started. */
+  #providers = /* @__PURE__ */ new Map();
   /** `kind:alias` → the claiming extension's `kind:name` key, for committed extensions. */
   #aliases = /* @__PURE__ */ new Map();
   /** While a stage is active in the CURRENT async context, {@link register} writes there instead of
@@ -45200,13 +45202,47 @@ var Registry = class {
     return this.#aliases.get(key) ?? key;
   }
   /** Resolve one extension by kind + name or alias. Unknown throws. Staged (uncommitted) registrations are
-   *  invisible here; only committed ones resolve. */
+   *  invisible here; only committed ones resolve. A key whose declared provider has not loaded throws
+   *  too, naming that: {@link load} resolves it. */
   resolve(kind, name) {
     const ext = this.#byKey.get(this.#canonical(kind, name));
-    if (!ext)
+    if (!ext) {
+      if (this.#providers.has(`${kind}:${name}`))
+        throw new Error(`${kind} "${name}" is declared by a provider this process has not loaded`);
       throw new Error(`no ${kind} registered for "${name}"`);
+    }
     return ext;
   }
+  /** Declare a provider: a module that registers `provides` when it is imported. Nothing is imported
+   *  here. A key that another provider already declares is refused, so a key has one provider. */
+  provide(provider) {
+    const keys = provider.provides.map((ref) => `${ref.kind}:${ref.name}`);
+    for (const key of keys)
+      if (this.#providers.has(key))
+        throw new Error(`extension provider already declared: ${key}`);
+    const entry = { provider };
+    for (const key of keys)
+      this.#providers.set(key, entry);
+  }
+  /** Whether a provider was declared for exactly this kind + name, loaded or not. A boolean probe
+   *  that never throws and imports nothing. */
+  provides(kind, name) {
+    return this.#providers.has(`${kind}:${name}`);
+  }
+  /** Resolve kind + name, first importing the provider declared for it unless that import has run.
+   *  Concurrent calls share one import. A key no provider declares resolves as {@link resolve} does.
+   *  A provider that loads without registering the key it declared throws: the declaration is wrong,
+   *  and no other extension stands in for it. */
+  async load(kind, name) {
+    const entry = this.#providers.get(`${kind}:${name}`);
+    if (entry) {
+      entry.loading ??= entry.provider.load();
+      await entry.loading;
+      if (!this.#byKey.has(this.#canonical(kind, name)))
+        throw new Error(`the provider declared for ${kind} "${name}" loaded without registering it`);
+    }
+    return this.resolve(kind, name);
+  }
   all(kind) {
     const values = [...this.#byKey.values()];
     return kind === void 0 ? values : values.filter((e) => e.kind === kind);
@@ -65891,10 +65927,10 @@ function date4(params) {
 config(en_default());
 
 // ../connector-core/dist/docs-bundle.generated.js
-var DOCS_VERSION = "0.108.1";
+var DOCS_VERSION = "0.109.0";
 function loadDocsBundle() {
   return {
-    "version": "0.108.1",
+    "version": "0.109.0",
     "generatedFrom": "docs/*.md + SPEC.md + spec/cotal-lang.md + spec/cotal.schema.json",
     "pages": [
       {

package/seeded-connectors/pi/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cotal-ai/pi",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "keywords": [
     "cotal",

package/seeded-connectors/web/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cotal-ai/web",
   "description": "Cotal browser observability dashboard as an owned service preset.",
-  "version": "0.108.1",
+  "version": "0.109.0",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",