@rynx-ai/daemon 0.1.10 → 0.1.11-beta.2

package/dist/db.js

@@ -1,9 +1,7 @@
 /**
  * `~/.rynx/rynx.db` — the daemon's SQLite store. Concerns kept apart:
- *  - `channels`  — a chat type + its plugin-owned config/credentials.
- *  - `instances` — a runnable binding: a chat channel + an agent (1:1 with a channel,
- *    enforced by a UNIQUE channel_id). This is what the daemon mounts.
- *  - `plugins`   — static manifests, grants and immutable install locations.
+ *  - `plugin_installations` — source-qualified manifests, capabilities, and immutable packages.
+ *  - `plugin_marketplaces` — catalog registrations; catalog data is never executable.
  *  - `plugin_session_launch_operations` — durable idempotency/tombstones.
  *  - `control_links` — generic, one-use links to the local session console.
  *  - `runtime_pairing_claims` / `runtime_client_grants` — one-use enrollment
@@ -16,15 +14,18 @@
  * Connections are cached per resolved path so tests can point `RYNX_DB` /
  * `RYNX_HOME` at a temp dir. Override with `RYNX_DB` (full path) or `RYNX_HOME`.
  */
-import { randomUUID } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync } from "node:fs";
-import { homedir } from "node:os";
-import { dirname, join } from "node:path";
+import { chmodSync, mkdirSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
 import Database from "better-sqlite3";
 const connections = new Map();
 /** Absolute path to the SQLite file (override via `RYNX_DB`, else `~/.rynx/rynx.db`). */
 export function dbPath() {
-    return process.env.RYNX_DB?.trim() || join(daemonHome(), "rynx.db");
+    const configured = process.env.RYNX_DB?.trim();
+    if (configured && !isAbsolute(configured)) {
+        throw new Error("RYNX_DB must be an absolute path");
+    }
+    return configured ? resolve(configured) : join(rynxHome(), "rynx.db");
 }
 /** Open (or reuse) the database at the current path, migrating + importing on first open. */
 export function db() {
@@ -37,7 +38,7 @@ export function db() {
     conn.pragma("busy_timeout = 5000");
     conn.pragma("foreign_keys = ON");
     migrate(conn);
-    // The store may hold channel secrets (e.g. LARK_APP_SECRET) — keep it private.
+    // Plugin state and daemon credentials are private.
     try {
         chmodSync(path, 0o600);
     }
@@ -49,34 +50,46 @@ export function db() {
 }
 function migrate(conn) {
     conn.exec(`
-    CREATE TABLE IF NOT EXISTS plugins (
-      name         TEXT PRIMARY KEY,
-      spec         TEXT NOT NULL,
-      source       TEXT NOT NULL,
-      version      TEXT,
-      enabled      INTEGER NOT NULL DEFAULT 1,
-      installed_at TEXT NOT NULL,
-      updated_at   TEXT,
-      install_path TEXT,
-      manifest     TEXT,
-      integrity    TEXT,
-      grants       TEXT
+    CREATE TABLE IF NOT EXISTS plugin_marketplaces (
+      marketplace_id TEXT PRIMARY KEY,
+      source_type    TEXT NOT NULL CHECK(source_type IN ('git', 'local')),
+      requested_source TEXT NOT NULL,
+      resolved_revision TEXT NOT NULL,
+      source_fingerprint TEXT NOT NULL,
+      built_in      INTEGER NOT NULL DEFAULT 0,
+      catalog        TEXT NOT NULL,
+      created_at     TEXT NOT NULL,
+      refreshed_at   TEXT NOT NULL
     );
-    CREATE TABLE IF NOT EXISTS channels (
-      id         TEXT PRIMARY KEY,
-      name       TEXT NOT NULL UNIQUE,
-      type       TEXT NOT NULL,
-      options    TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+    CREATE TABLE IF NOT EXISTS plugin_marketplace_bindings (
+      marketplace_id    TEXT PRIMARY KEY,
+      source_fingerprint TEXT NOT NULL,
+      created_at         TEXT NOT NULL
     );
-    CREATE TABLE IF NOT EXISTS instances (
-      id         TEXT PRIMARY KEY,
-      channel_id TEXT NOT NULL UNIQUE REFERENCES channels(id) ON DELETE CASCADE,
-      agent      TEXT,
-      enabled    INTEGER NOT NULL DEFAULT 1,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
+    INSERT OR IGNORE INTO plugin_marketplace_bindings (
+      marketplace_id, source_fingerprint, created_at
+    )
+    SELECT marketplace_id, source_fingerprint, created_at
+    FROM plugin_marketplaces;
+    CREATE TABLE IF NOT EXISTS plugin_installations (
+      canonical_id   TEXT PRIMARY KEY,
+      marketplace_id TEXT NOT NULL,
+      plugin_id      TEXT NOT NULL,
+      source_type    TEXT NOT NULL CHECK(source_type IN ('git', 'local')),
+      requested_source TEXT NOT NULL,
+      resolved_revision TEXT NOT NULL,
+      source_fingerprint TEXT NOT NULL,
+      version        TEXT NOT NULL,
+      enabled        INTEGER NOT NULL DEFAULT 1,
+      installed_at   TEXT NOT NULL,
+      updated_at     TEXT NOT NULL,
+      install_path   TEXT NOT NULL,
+      manifest       TEXT NOT NULL,
+      integrity      TEXT NOT NULL,
+      capabilities   TEXT NOT NULL,
+      runtime_state  TEXT,
+      runtime_error  TEXT,
+      UNIQUE(marketplace_id, plugin_id)
     );
     CREATE TABLE IF NOT EXISTS session_items (
       id          TEXT PRIMARY KEY,
@@ -142,16 +155,25 @@ function migrate(conn) {
         ON DELETE CASCADE
     );
     CREATE TABLE IF NOT EXISTS sessions (
+      id         TEXT PRIMARY KEY,
+      workspace  TEXT NOT NULL,
+      execution  TEXT NOT NULL,
+      title      TEXT,
+      forked_from_session_id TEXT,
+      source     TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      updated_at TEXT
+    );
+    CREATE TABLE IF NOT EXISTS session_snapshot_cleanup (
+      session_id TEXT PRIMARY KEY
+    );
+    CREATE TABLE IF NOT EXISTS runtime_projects (
       id               TEXT PRIMARY KEY,
-      provider         TEXT,
-      agent            TEXT,
-      config           TEXT,
-      model            TEXT,
-      reasoning_effort TEXT,
-      title            TEXT,
-      source           TEXT,
+      name             TEXT NOT NULL,
+      directories_json TEXT NOT NULL,
+      primary_dir      TEXT NOT NULL,
       created_at       TEXT NOT NULL,
-      updated_at       TEXT
+      updated_at       TEXT NOT NULL
     );
     CREATE TABLE IF NOT EXISTS session_pending_messages (
       session_id TEXT PRIMARY KEY REFERENCES sessions(id) ON DELETE CASCADE,
@@ -187,6 +209,31 @@ function migrate(conn) {
     );
     CREATE INDEX IF NOT EXISTS idx_plugin_session_launch_operations_session
       ON plugin_session_launch_operations(session_id);
+    CREATE TABLE IF NOT EXISTS session_fork_operations (
+      operation_id     TEXT PRIMARY KEY,
+      request_hash     TEXT NOT NULL,
+      source_session_id TEXT NOT NULL,
+      target_session_id TEXT NOT NULL UNIQUE,
+      title            TEXT,
+      fork_position    INTEGER,
+      state            TEXT NOT NULL DEFAULT 'reserved'
+        CHECK(state IN ('reserved', 'completed', 'target_deleted')),
+      error            TEXT,
+      created_at       TEXT NOT NULL,
+      updated_at       TEXT NOT NULL,
+      completed_at     TEXT,
+      deleted_at       TEXT,
+      CHECK(
+        (state = 'reserved' AND completed_at IS NULL AND deleted_at IS NULL)
+        OR (state = 'completed' AND completed_at IS NOT NULL AND deleted_at IS NULL)
+        OR (state = 'target_deleted' AND deleted_at IS NOT NULL)
+      )
+    );
+    CREATE INDEX IF NOT EXISTS idx_session_fork_operations_source
+      ON session_fork_operations(source_session_id, state);
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_session_fork_operations_reserved_source
+      ON session_fork_operations(source_session_id)
+      WHERE state = 'reserved';
     CREATE TABLE IF NOT EXISTS control_links (
       token      TEXT PRIMARY KEY,
       plugin_id  TEXT NOT NULL,
@@ -260,97 +307,71 @@ function migrate(conn) {
     CREATE INDEX IF NOT EXISTS idx_runtime_pending_enrollments_expires
       ON runtime_pending_enrollments(expires_at);
   `);
+    migratePluginCapabilities(conn);
+    migrateSessionSnapshots(conn);
     // Breaking plugin-runtime cutover: remove obsolete core-owned state.
     conn.exec(`
     DROP TABLE IF EXISTS control_sessions;
     DROP TABLE IF EXISTS plugin_daemon_worker_settings;
   `);
-    // `sessions` is the unified machine-session record (console + every channel).
-    // Add the identity columns to a pre-existing table (SQLite has no
-    // ADD COLUMN IF NOT EXISTS) and backfill the origin of rows written before
-    // this change — they were all console sessions.
-    addColumnIfMissing(conn, "sessions", "source", "TEXT");
-    addColumnIfMissing(conn, "sessions", "updated_at", "TEXT");
-    addColumnIfMissing(conn, "sessions", "provider", "TEXT");
-    const sessionColumns = conn.prepare("PRAGMA table_info(sessions)").all();
-    if (sessionColumns.some((column) => column.name === "executor")) {
-        conn.exec("UPDATE sessions SET provider = executor WHERE provider IS NULL AND executor IS NOT NULL");
-    }
-    addColumnIfMissing(conn, "plugins", "updated_at", "TEXT");
-    addColumnIfMissing(conn, "plugins", "install_path", "TEXT");
-    addColumnIfMissing(conn, "plugins", "manifest", "TEXT");
-    addColumnIfMissing(conn, "plugins", "integrity", "TEXT");
-    addColumnIfMissing(conn, "plugins", "grants", "TEXT");
-    conn.exec("UPDATE sessions SET source = 'console' WHERE source IS NULL");
-    conn.exec("UPDATE plugins SET updated_at = installed_at WHERE updated_at IS NULL");
-    importLegacyConfig(conn);
-}
-/** Idempotently add a column to an existing table (no-op if already present). */
-function addColumnIfMissing(conn, table, column, ddl) {
-    const cols = conn.prepare(`PRAGMA table_info(${table})`).all();
-    if (cols.some((c) => c.name === column))
-        return;
-    conn.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
+    addColumnIfMissing(conn, "plugin_marketplaces", "built_in", "INTEGER NOT NULL DEFAULT 0");
+    addColumnIfMissing(conn, "sessions", "forked_from_session_id", "TEXT");
 }
 /**
- * One-time import of a pre-existing `~/.rynx/config.json` (the old hand-edited
- * format, where each entry mixed channel config + agent binding). Each entry
- * becomes a `channels` row (the config) plus an `instances` row (the binding).
- * The instance keeps the entry's key as its `id` so per-instance on-disk state
- * (keyed by instanceId) stays intact. Runs only when empty; the file is renamed
- * afterwards so it's never read — or hand-edited — again.
+ * Breaking Session cutover: the previous rows contain mutable Agent/Provider
+ * references and no immutable workspace/execution snapshots, so they cannot be
+ * migrated faithfully. Remove every database-owned Session artifact and create
+ * the new snapshot-only table. User workspace directories are never touched.
  */
-function importLegacyConfig(conn) {
-    const { n } = conn.prepare("SELECT COUNT(*) AS n FROM channels").get();
-    if (n > 0)
+function migrateSessionSnapshots(conn) {
+    const columns = conn.prepare("PRAGMA table_info(sessions)").all();
+    const names = new Set(columns.map((column) => column.name));
+    if (names.has("workspace") && names.has("execution"))
         return;
-    const legacy = process.env.RYNX_CONFIG?.trim() || join(daemonHome(), "config.json");
-    if (!existsSync(legacy))
+    conn.transaction(() => {
+        conn.exec(`
+      INSERT OR IGNORE INTO session_snapshot_cleanup (session_id)
+      SELECT id FROM sessions;
+      DELETE FROM session_message_operation_resources;
+      DELETE FROM session_message_operations;
+      DELETE FROM session_resources;
+      DELETE FROM session_items;
+      DELETE FROM session_pending_messages;
+      DELETE FROM session_emulator_bindings;
+      DELETE FROM plugin_session_launch_operations;
+      DELETE FROM session_fork_operations;
+      DELETE FROM control_links;
+      DELETE FROM sessions;
+      DROP TABLE sessions;
+      CREATE TABLE sessions (
+        id         TEXT PRIMARY KEY,
+        workspace  TEXT NOT NULL,
+        execution  TEXT NOT NULL,
+        title      TEXT,
+        forked_from_session_id TEXT,
+        source     TEXT NOT NULL,
+        created_at TEXT NOT NULL,
+        updated_at TEXT
+      );
+    `);
+    }).immediate();
+}
+function migratePluginCapabilities(conn) {
+    const columns = conn
+        .prepare("PRAGMA table_info(plugin_installations)")
+        .all();
+    if (columns.some((column) => column.name === "capabilities"))
         return;
-    let channels;
-    try {
-        const parsed = JSON.parse(readFileSync(legacy, "utf8"));
-        if (parsed.channels && typeof parsed.channels === "object") {
-            channels = parsed.channels;
-        }
-    }
-    catch {
-        return; // malformed legacy file — leave it alone, start empty
-    }
-    if (!channels)
+    if (columns.some((column) => column.name === "grants")) {
+        conn.exec("ALTER TABLE plugin_installations RENAME COLUMN grants TO capabilities");
         return;
-    const now = new Date().toISOString();
-    const insertChannel = conn.prepare(`INSERT OR IGNORE INTO channels (id, name, type, options, created_at, updated_at)
-     VALUES (@id, @name, @type, @options, @now, @now)`);
-    const insertInstance = conn.prepare(`INSERT OR IGNORE INTO instances (id, channel_id, agent, enabled, created_at, updated_at)
-     VALUES (@id, @channelId, @agent, @enabled, @now, @now)`);
-    const tx = conn.transaction(() => {
-        for (const [key, entry] of Object.entries(channels)) {
-            const channelId = randomUUID();
-            insertChannel.run({
-                id: channelId,
-                name: key,
-                type: entry.type ?? key,
-                options: entry.options ? JSON.stringify(entry.options) : null,
-                now,
-            });
-            insertInstance.run({
-                id: key, // preserve the old key as the runtime instanceId
-                channelId,
-                agent: entry.agent ?? null,
-                enabled: entry.enabled === false ? 0 : 1,
-                now,
-            });
-        }
-    });
-    tx();
-    try {
-        renameSync(legacy, `${legacy}.imported`);
-    }
-    catch {
-        /* leave the source in place if it can't be renamed */
     }
+    conn.exec("ALTER TABLE plugin_installations ADD COLUMN capabilities TEXT NOT NULL DEFAULT '[]'");
 }
-function daemonHome() {
-    return process.env.RYNX_HOME?.trim() || join(homedir(), ".rynx");
+/** Idempotently add a column to an existing table (no-op if already present). */
+function addColumnIfMissing(conn, table, column, ddl) {
+    const cols = conn.prepare(`PRAGMA table_info(${table})`).all();
+    if (cols.some((c) => c.name === column))
+        return;
+    conn.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${ddl}`);
 }

package/dist/index-daemon.js

@@ -3,11 +3,12 @@
  * The resident daemon entry — this is what pm2 keeps alive.
  *
  * Boot order matters: install the EPIPE guard first (we're a pm2 child).
- * The composition root reads static plugin manifests, projects chat instances
- * onto remote runner handles, and supervises non-chat plugin workers. Installed
- * plugin code is loaded only in child processes.
+ * The composition root reads static plugin manifests and supervises one runtime
+ * process for each enabled runtime plugin. Installed plugin code is loaded only
+ * in child processes; plugin-owned channel instances stay inside that process.
  */
 import { startRynxDaemonServer } from "./daemon-server.js";
+import { ensureBundledOfficialPlugins } from "./bundled-plugins.js";
 import { installStdioEpipeGuard } from "./stdio-epipe-guard.js";
 installStdioEpipeGuard();
 async function main() {
@@ -18,9 +19,29 @@ async function main() {
     };
     if (followsApp)
         process.once("disconnect", recordParentDisconnect);
+    const preparePlugins = async () => {
+        try {
+            const bundled = await ensureBundledOfficialPlugins({ reclaimHostLeases: true });
+            if (bundled.status === "ready") {
+                console.log(JSON.stringify({
+                    level: "info",
+                    type: "bundled_plugins_ready",
+                    installed: bundled.installed,
+                    updated: bundled.updated,
+                }));
+            }
+        }
+        catch (error) {
+            console.error(JSON.stringify({
+                level: "error",
+                type: "bundled_plugins_failed",
+                error: error instanceof Error ? error.message : String(error),
+            }));
+        }
+    };
     let server;
     try {
-        server = await startRynxDaemonServer();
+        server = await startRynxDaemonServer({ preparePlugins });
     }
     catch (error) {
         process.off("disconnect", recordParentDisconnect);

package/dist/migrations/cleanup-legacy-sessions.d.ts

@@ -1,5 +1,5 @@
 export interface CleanupOptions {
-    /** CodexSessionStore JSON path; defaults to `<cwd>/.codex-proxy/sessions.json`. */
+    /** CodexSessionStore JSON path; defaults to `{RYNX_HOME}/.codex-proxy/sessions.json`. */
     codexStorePath?: string;
     /** Report what would be removed without deleting anything. */
     dryRun?: boolean;

package/dist/migrations/cleanup-legacy-sessions.js

@@ -8,20 +8,21 @@
  *   - canonical-log rows (`session_items`) and identity rows (`sessions`) whose
  *     id is not an opaque `sess_` id,
  *   - the daemon-owned runtime thread→rollout bindings in
- *     `.codex-proxy/sessions.json` that use a legacy id.
+ *     `.codex-proxy/sessions.json` that no longer have a Session row. This also
+ *     removes opaque bindings left behind by the snapshot-schema cutover.
  *
  * Runs on every daemon boot (not marker-gated): on a healthy system it deletes
  * nothing and writes nothing, so it is cheap; if a legacy session ever appears
- * the next boot removes it. The `sess_` filter means it can never touch a
- * current session. Plugin-private routing stores are deliberately not read.
+ * the next boot removes it. Plugin-private routing stores are deliberately not
+ * read.
  */
 import { mkdirSync, readFileSync, renameSync, writeFileSync, } from "node:fs";
 import path from "node:path";
-import { isMachineSessionId } from "@rynx-ai/core";
+import { rynxHome } from "@rynx-ai/core";
 import { db } from "../db.js";
 /** Mirrors the daemon runtime store's default resolution. */
 function defaultProxyDir() {
-    return path.join(process.cwd(), ".codex-proxy");
+    return path.join(rynxHome(), ".codex-proxy");
 }
 // Anything whose id isn't an opaque `sess_` id is legacy. GLOB treats `_` as a
 // literal (unlike LIKE), so `sess_*` matches exactly the new id shape.
@@ -31,11 +32,14 @@ export function cleanupLegacySessions(opts = {}) {
     const log = opts.log ?? (() => { });
     const dryRun = Boolean(opts.dryRun);
     const conn = db();
-    const codexStorePath = opts.codexStorePath ?? path.join(defaultProxyDir(), "sessions.json");
+    const liveSessionIds = new Set(conn.prepare("SELECT id FROM sessions").all().map((row) => row.id));
+    const codexStorePath = opts.codexStorePath
+        ? path.resolve(rynxHome(), opts.codexStorePath)
+        : path.join(defaultProxyDir(), "sessions.json");
     if (dryRun) {
         const deletedLogRows = countRows(conn, `SELECT COUNT(*) AS n FROM session_items WHERE ${LEGACY_LOG}`);
         const deletedSessions = countRows(conn, `SELECT COUNT(*) AS n FROM sessions WHERE ${LEGACY_META}`);
-        const prunedStoreEntries = countLegacyStoreEntries(readJsonStore(codexStorePath), (key) => key);
+        const prunedStoreEntries = countOrphanedStoreEntries(readJsonStore(codexStorePath), (key) => key, liveSessionIds);
         log({ event: "cleanup.dry_run", deletedLogRows, deletedSessions, prunedStoreEntries });
         return { dryRun: true, deletedLogRows, deletedSessions, prunedStoreEntries };
     }
@@ -48,7 +52,7 @@ export function cleanupLegacySessions(opts = {}) {
     })();
     // The runtime store is daemon-owned. Plugin routing stores remain private to
     // their plugins and are never inspected by this migration.
-    prunedStoreEntries += pruneStore(codexStorePath, (key) => key);
+    prunedStoreEntries += pruneStore(codexStorePath, (key) => key, liveSessionIds);
     if (deletedLogRows || deletedSessions || prunedStoreEntries) {
         log({ event: "cleanup.done", deletedLogRows, deletedSessions, prunedStoreEntries });
     }
@@ -57,31 +61,45 @@ export function cleanupLegacySessions(opts = {}) {
 function countRows(conn, sql) {
     return conn.prepare(sql).get().n;
 }
-function countLegacyStoreEntries(data, idOf) {
+function countOrphanedStoreEntries(data, idOf, liveSessionIds) {
     let n = 0;
     for (const [key, record] of Object.entries(data.sessions ?? {})) {
         const id = idOf(key, record);
-        if (typeof id === "string" && !isMachineSessionId(id))
+        if (typeof id === "string" && !liveSessionIds.has(id))
+            n += 1;
+    }
+    for (const key of Object.keys(data.claudeForkIntents ?? {})) {
+        if (!liveSessionIds.has(key))
             n += 1;
     }
     return n;
 }
-/** Drop every legacy entry from a JSON store; returns how many were removed. */
-function pruneStore(file, idOf) {
+/** Drop every binding whose owning Session no longer exists. */
+function pruneStore(file, idOf, liveSessionIds) {
     const data = readJsonStore(file);
-    if (!data.sessions)
+    if (!data.sessions && !data.claudeForkIntents)
         return 0;
     let pruned = 0;
     const kept = {};
-    for (const [key, record] of Object.entries(data.sessions)) {
+    for (const [key, record] of Object.entries(data.sessions ?? {})) {
         const id = idOf(key, record);
-        if (typeof id === "string" && !isMachineSessionId(id)) {
+        if (typeof id === "string" && !liveSessionIds.has(id)) {
             pruned += 1;
         }
         else {
             kept[key] = record;
         }
     }
+    if (data.claudeForkIntents) {
+        const keptIntents = {};
+        for (const [targetSessionId, intent] of Object.entries(data.claudeForkIntents)) {
+            if (liveSessionIds.has(targetSessionId))
+                keptIntents[targetSessionId] = intent;
+            else
+                pruned += 1;
+        }
+        data.claudeForkIntents = keptIntents;
+    }
     if (pruned > 0) {
         data.sessions = kept;
         writeJsonStore(file, data);

package/dist/official-plugins.d.ts

@@ -0,0 +1,2 @@
+export declare const OFFICIAL_MARKETPLACE_ID = "rynx-ai/rynx";
+export declare const DEFAULT_BUNDLED_PLUGINS: readonly ["lark@rynx-ai/rynx"];

package/dist/official-plugins.js

@@ -0,0 +1,2 @@
+export const OFFICIAL_MARKETPLACE_ID = "rynx-ai/rynx";
+export const DEFAULT_BUNDLED_PLUGINS = ["lark@rynx-ai/rynx"];

package/dist/plugin-cli.d.ts

@@ -1,4 +1,3 @@
-import { type PluginCliHostEffect } from "@rynx-ai/plugin-sdk";
 import { type RunnablePluginRecord } from "./plugin-store.js";
 export interface RunPluginCliOptions {
     stdio?: "inherit" | "pipe";
@@ -14,7 +13,6 @@ export interface RunPluginCliOptions {
 }
 export interface PluginCliCommandResult {
     code: number;
-    effects: PluginCliHostEffect[];
     output?: {
         stdout: string;
         stderr: string;
@@ -22,7 +20,7 @@ export interface PluginCliCommandResult {
         stderrTruncated: boolean;
     };
 }
-/** Execute one statically declared plugin command in a separate Node process. */
+/** Execute one statically declared, language-neutral plugin command. */
 export declare function runPluginCliCommand(pluginId: string, args: readonly string[], options?: RunPluginCliOptions): Promise<PluginCliCommandResult>;
 export declare function pluginCommandUsage(record: RunnablePluginRecord): string;
 export declare class PluginCliUsageError extends Error {