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

package/dist/plugin-skill-context.d.ts

@@ -0,0 +1,4 @@
+import { type ResolvedPluginSkillSourceSnapshot } from "@rynx-ai/core";
+/** Capture enabled plugin skill roots for persistence in a Session snapshot. */
+export declare function snapshotEnabledPluginSkillSources(): ResolvedPluginSkillSourceSnapshot[];
+export declare function removeLegacyPluginSkillSnapshot(sessionId: string): void;

package/dist/plugin-skill-context.js

@@ -0,0 +1,35 @@
+import { createHash } from "node:crypto";
+import { rmSync } from "node:fs";
+import { join } from "node:path";
+import { rynxHome } from "@rynx-ai/core";
+import { resolvePackagePath } from "./plugin-package.js";
+import { listEnabledPlugins } from "./plugin-store.js";
+/** Capture enabled plugin skill roots for persistence in a Session snapshot. */
+export function snapshotEnabledPluginSkillSources() {
+    return listEnabledPlugins().flatMap((record) => {
+        if (!record.manifest.skills)
+            return [];
+        return [{
+                installationId: record.canonicalId,
+                integrity: record.integrity,
+                packageRoot: record.installPath,
+                root: resolvePackagePath(record.installPath, record.manifest.skills, "skills", "directory"),
+                namespace: pluginSkillNamespace(record.canonicalId),
+            }];
+    });
+}
+export function removeLegacyPluginSkillSnapshot(sessionId) {
+    const digest = createHash("sha256").update(sessionId).digest("hex");
+    rmSync(join(rynxHome(), "plugins", "task-skill-snapshots", `${digest}.json`), {
+        force: true,
+    });
+}
+function pluginSkillNamespace(canonicalId) {
+    const slug = canonicalId
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 96);
+    const digest = createHash("sha256").update(canonicalId).digest("hex").slice(0, 12);
+    return `plugin-${slug || "package"}-${digest}`;
+}

package/dist/plugin-store.d.ts

@@ -1,56 +1,55 @@
-/**
- * Durable inventory of installed plugin packages.
- *
- * The registry stores only static, validated manifest data and a host-owned
- * installation path. Runtime modules are never imported while reading this
- * table. Rows from the pre-v1 executable-manifest format remain visible to the
- * CLI, but are not runnable and must be reinstalled.
- */
-import { type PluginCapability, type PluginManifestV1 } from "@rynx-ai/plugin-sdk";
-export type PluginSource = "npm" | "local" | "git" | "url";
+/** Durable source-qualified inventory of installed plugin packages. */
+import { type PluginManifestV1, type PluginPackageSourceV1 } from "@rynx-ai/plugin-sdk";
+export type PluginSource = "local" | "git";
+export type PluginRuntimeState = "absent" | "starting" | "running" | "degraded" | "failed" | "stopped";
 export interface PluginRecord {
-    /** Manifest id. The SQLite column remains `name` for migration stability. */
+    /** Canonical installation identity: `<plugin-id>@<marketplace-id>`. */
+    canonicalId: string;
+    /** Canonical display/CLI value; always equals canonicalId. */
     name: string;
-    /** User-supplied install source, retained for an explicit update. */
-    spec: string;
+    marketplaceId: string;
+    pluginId: string;
     source: PluginSource;
-    version?: string;
-    /** Whether daemon runtime contributions are loaded; explicit CLI stays available. */
+    requestedSource: PluginPackageSourceV1;
+    resolvedRevision: string;
+    sourceFingerprint: string;
+    /** Stable serialized source used for explicit updates. */
+    spec: string;
+    version: string;
     enabled: boolean;
     installedAt: string;
     updatedAt: string;
-    /** Host-generated immutable installation root. Missing only on legacy rows. */
-    installPath?: string;
-    /** Validated, pure-data manifest. Missing only on legacy rows. */
-    manifest?: PluginManifestV1;
-    /** sha256 integrity string for the materialized package. */
-    integrity?: string;
-    /** Capabilities approved for this installation. */
-    grants: PluginCapability[];
-}
-export interface RunnablePluginRecord extends PluginRecord {
     installPath: string;
     manifest: PluginManifestV1;
     integrity: string;
+    runtimeState: PluginRuntimeState;
+    runtimeError?: string;
 }
-/** All installed plugins, including incompatible legacy rows. */
+export type RunnablePluginRecord = PluginRecord;
+export declare function canonicalPluginId(pluginId: string, marketplaceId: string): string;
+export declare function parseCanonicalPluginId(value: string): {
+    pluginId: string;
+    marketplaceId: string;
+};
 export declare function listPlugins(): PluginRecord[];
-/** Enabled v1 installations that are safe for the runner to consider. */
-export declare function listEnabledPlugins(): RunnablePluginRecord[];
-export declare function getPlugin(name: string): PluginRecord | undefined;
-/** Atomically point a plugin id at a completely materialized installation. */
+export declare function listEnabledPlugins(): PluginRecord[];
+/** Exact canonical lookup. Unqualified ids are accepted only when unambiguous. */
+export declare function getPlugin(identity: string): PluginRecord | undefined;
 export declare function upsertPlugin(rec: {
-    name: string;
-    spec: string;
+    canonicalId: string;
+    marketplaceId: string;
+    pluginId: string;
     source: PluginSource;
-    version?: string;
+    requestedSource: PluginPackageSourceV1;
+    resolvedRevision: string;
+    sourceFingerprint: string;
+    version: string;
     installPath: string;
     manifest: PluginManifestV1;
     integrity: string;
-    grants: readonly PluginCapability[];
     enabled?: boolean;
 }): void;
-export declare function setPluginEnabled(name: string, enabled: boolean): void;
-/** Remove only the registry row. Package deletion is owned by the installer. */
-export declare function removePlugin(name: string): boolean;
+export declare function setPluginEnabled(identity: string, enabled: boolean): void;
+export declare function setPluginRuntimeState(identity: string, state: PluginRuntimeState, error?: string): void;
+export declare function removePlugin(identity: string): boolean;
 export declare function isRunnablePluginRecord(record: PluginRecord): record is RunnablePluginRecord;

package/dist/plugin-store.js

@@ -1,121 +1,169 @@
-/**
- * Durable inventory of installed plugin packages.
- *
- * The registry stores only static, validated manifest data and a host-owned
- * installation path. Runtime modules are never imported while reading this
- * table. Rows from the pre-v1 executable-manifest format remain visible to the
- * CLI, but are not runnable and must be reinstalled.
- */
-import { parsePluginManifest, } from "@rynx-ai/plugin-sdk";
+/** Durable source-qualified inventory of installed plugin packages. */
+import { MARKETPLACE_ID_PATTERN, PLUGIN_ID_PATTERN, parsePluginManifest, } from "@rynx-ai/plugin-sdk";
 import { db } from "./db.js";
-function toRecord(row) {
-    const manifest = parseStoredManifest(row.manifest);
-    return {
-        name: row.name,
-        spec: row.spec,
-        source: parseSource(row.source),
-        version: row.version ?? undefined,
-        enabled: row.enabled !== 0,
-        installedAt: row.installed_at,
-        updatedAt: row.updated_at ?? row.installed_at,
-        installPath: row.install_path ?? undefined,
-        manifest,
-        integrity: row.integrity ?? undefined,
-        grants: parseStoredGrants(row.grants, manifest),
-    };
+export function canonicalPluginId(pluginId, marketplaceId) {
+    if (!PLUGIN_ID_PATTERN.test(pluginId))
+        throw new Error(`invalid plugin id "${pluginId}"`);
+    if (!MARKETPLACE_ID_PATTERN.test(marketplaceId)) {
+        throw new Error(`invalid marketplace id "${marketplaceId}"`);
+    }
+    return `${pluginId}@${marketplaceId}`;
+}
+export function parseCanonicalPluginId(value) {
+    const separator = value.lastIndexOf("@");
+    if (separator <= 0 || separator === value.length - 1) {
+        throw new Error("plugin identity must be <plugin-id>@<marketplace-id>");
+    }
+    const pluginId = value.slice(0, separator);
+    const marketplaceId = value.slice(separator + 1);
+    canonicalPluginId(pluginId, marketplaceId);
+    return { pluginId, marketplaceId };
 }
-/** All installed plugins, including incompatible legacy rows. */
 export function listPlugins() {
-    const rows = db().prepare("SELECT * FROM plugins ORDER BY name").all();
+    const rows = db()
+        .prepare("SELECT * FROM plugin_installations ORDER BY marketplace_id, plugin_id")
+        .all();
     return rows.map(toRecord);
 }
-/** Enabled v1 installations that are safe for the runner to consider. */
 export function listEnabledPlugins() {
-    return listPlugins().filter(isRunnablePluginRecord).filter((plugin) => plugin.enabled);
+    return listPlugins().filter((plugin) => plugin.enabled);
 }
-export function getPlugin(name) {
-    const row = db().prepare("SELECT * FROM plugins WHERE name = ?").get(name);
-    return row ? toRecord(row) : undefined;
+/** Exact canonical lookup. Unqualified ids are accepted only when unambiguous. */
+export function getPlugin(identity) {
+    if (identity.includes("@")) {
+        const row = db()
+            .prepare("SELECT * FROM plugin_installations WHERE canonical_id = ?")
+            .get(identity);
+        return row ? toRecord(row) : undefined;
+    }
+    if (!PLUGIN_ID_PATTERN.test(identity))
+        return undefined;
+    const rows = db()
+        .prepare("SELECT * FROM plugin_installations WHERE plugin_id = ? ORDER BY marketplace_id")
+        .all(identity);
+    if (rows.length > 1) {
+        throw new Error(`plugin id "${identity}" is ambiguous; use <plugin-id>@<marketplace-id>`);
+    }
+    return rows[0] ? toRecord(rows[0]) : undefined;
 }
-/** Atomically point a plugin id at a completely materialized installation. */
 export function upsertPlugin(rec) {
-    if (rec.name !== rec.manifest.id) {
-        throw new Error(`plugin registry id mismatch: ${rec.name} != ${rec.manifest.id}`);
+    if (rec.pluginId !== rec.manifest.id) {
+        throw new Error(`plugin registry id mismatch: ${rec.pluginId} != ${rec.manifest.id}`);
     }
-    const requested = new Set(rec.manifest.requestedCapabilities);
-    for (const grant of rec.grants) {
-        if (!requested.has(grant))
-            throw new Error(`plugin grant was not requested: ${grant}`);
+    if (rec.canonicalId !== canonicalPluginId(rec.pluginId, rec.marketplaceId)) {
+        throw new Error("plugin canonical identity mismatch");
     }
     const now = new Date().toISOString();
-    db()
-        .prepare(`INSERT INTO plugins (
-         name, spec, source, version, enabled, installed_at, updated_at,
-         install_path, manifest, integrity, grants
-       ) VALUES (
-         @name, @spec, @source, @version, @enabled, @now, @now,
-         @installPath, @manifest, @integrity, @grants
-       )
-       ON CONFLICT(name) DO UPDATE SET
-         spec = excluded.spec,
-         source = excluded.source,
-         version = excluded.version,
-         enabled = excluded.enabled,
-         installed_at = excluded.installed_at,
-         updated_at = excluded.updated_at,
-         install_path = excluded.install_path,
-         manifest = excluded.manifest,
-         integrity = excluded.integrity,
-         grants = excluded.grants`)
-        .run({
-        name: rec.name,
-        spec: rec.spec,
+    db().prepare(`INSERT INTO plugin_installations (
+       canonical_id, marketplace_id, plugin_id, source_type, requested_source,
+       resolved_revision, source_fingerprint, version, enabled, installed_at,
+       updated_at, install_path, manifest, integrity, capabilities, runtime_state, runtime_error
+     ) VALUES (
+       @canonicalId, @marketplaceId, @pluginId, @source, @requestedSource,
+       @resolvedRevision, @sourceFingerprint, @version, @enabled, @now,
+       @now, @installPath, @manifest, @integrity, @capabilities, 'stopped', NULL
+     )
+     ON CONFLICT(canonical_id) DO UPDATE SET
+       source_type = excluded.source_type,
+       requested_source = excluded.requested_source,
+       resolved_revision = excluded.resolved_revision,
+       source_fingerprint = excluded.source_fingerprint,
+       version = excluded.version,
+       enabled = excluded.enabled,
+       updated_at = excluded.updated_at,
+       install_path = excluded.install_path,
+       manifest = excluded.manifest,
+       integrity = excluded.integrity,
+       capabilities = excluded.capabilities,
+       runtime_state = 'stopped',
+       runtime_error = NULL`).run({
+        canonicalId: rec.canonicalId,
+        marketplaceId: rec.marketplaceId,
+        pluginId: rec.pluginId,
         source: rec.source,
-        version: rec.version ?? null,
+        requestedSource: JSON.stringify(rec.requestedSource),
+        resolvedRevision: rec.resolvedRevision,
+        sourceFingerprint: rec.sourceFingerprint,
+        version: rec.version,
         enabled: rec.enabled === false ? 0 : 1,
         now,
         installPath: rec.installPath,
         manifest: JSON.stringify(rec.manifest),
         integrity: rec.integrity,
-        grants: JSON.stringify([...rec.grants]),
+        capabilities: JSON.stringify(rec.manifest.capabilities),
     });
 }
-export function setPluginEnabled(name, enabled) {
-    db()
-        .prepare("UPDATE plugins SET enabled = ?, updated_at = ? WHERE name = ?")
-        .run(enabled ? 1 : 0, new Date().toISOString(), name);
+export function setPluginEnabled(identity, enabled) {
+    const record = getPlugin(identity);
+    if (!record)
+        return;
+    db().prepare("UPDATE plugin_installations SET enabled = ?, updated_at = ? WHERE canonical_id = ?").run(enabled ? 1 : 0, new Date().toISOString(), record.canonicalId);
 }
-/** Remove only the registry row. Package deletion is owned by the installer. */
-export function removePlugin(name) {
-    return db().prepare("DELETE FROM plugins WHERE name = ?").run(name).changes > 0;
+export function setPluginRuntimeState(identity, state, error) {
+    const record = getPlugin(identity);
+    if (!record)
+        return;
+    db().prepare(`UPDATE plugin_installations
+     SET runtime_state = ?, runtime_error = ?
+     WHERE canonical_id = ?`).run(state, error ?? null, record.canonicalId);
+}
+export function removePlugin(identity) {
+    const record = getPlugin(identity);
+    if (!record)
+        return false;
+    return db()
+        .prepare("DELETE FROM plugin_installations WHERE canonical_id = ?")
+        .run(record.canonicalId).changes > 0;
 }
 export function isRunnablePluginRecord(record) {
     return Boolean(record.installPath && record.manifest && record.integrity);
 }
-function parseStoredManifest(raw) {
-    if (!raw)
-        return undefined;
-    try {
-        return parsePluginManifest(JSON.parse(raw));
-    }
-    catch {
-        return undefined;
-    }
+function toRecord(row) {
+    const manifest = parsePluginManifest(JSON.parse(row.manifest));
+    const requestedSource = JSON.parse(row.requested_source);
+    return {
+        canonicalId: row.canonical_id,
+        name: row.canonical_id,
+        marketplaceId: row.marketplace_id,
+        pluginId: row.plugin_id,
+        source: row.source_type === "local" ? "local" : "git",
+        requestedSource,
+        resolvedRevision: row.resolved_revision,
+        sourceFingerprint: row.source_fingerprint,
+        spec: serializeRequestedSource(requestedSource),
+        version: row.version,
+        enabled: row.enabled !== 0,
+        installedAt: row.installed_at,
+        updatedAt: row.updated_at,
+        installPath: row.install_path,
+        manifest,
+        integrity: row.integrity,
+        runtimeState: parseRuntimeState(row.runtime_state),
+        ...(row.runtime_error ? { runtimeError: row.runtime_error } : {}),
+    };
 }
-function parseStoredGrants(raw, manifest) {
-    if (!raw || !manifest)
-        return [];
-    try {
-        const values = JSON.parse(raw);
-        if (!Array.isArray(values))
-            return [];
-        const requested = new Set(manifest.requestedCapabilities);
-        return values.filter((value) => typeof value === "string" && requested.has(value));
-    }
-    catch {
-        return [];
+function serializeRequestedSource(source) {
+    if (source.type === "local") {
+        return `${source.path}${source.subdir ? `#path=${source.subdir}` : ""}`;
     }
+    const params = new URLSearchParams();
+    if (source.subdir)
+        params.set("path", source.subdir);
+    if (source.ref)
+        params.set("ref", source.ref);
+    if (source.commit)
+        params.set("ref", source.commit);
+    const fragment = params.toString();
+    return `${source.url}${fragment ? `#${fragment}` : ""}`;
 }
-function parseSource(value) {
-    return value === "local" || value === "git" || value === "url" ? value : "npm";
+function parseRuntimeState(value) {
+    if (value === "absent" ||
+        value === "starting" ||
+        value === "running" ||
+        value === "degraded" ||
+        value === "failed")
+        return value;
+    if (value === "needs_setup")
+        return "running";
+    return "stopped";
 }

package/dist/plugin-supervisor.d.ts

@@ -1,35 +1,8 @@
-import { type ChannelTypeDescriptor } from "@rynx-ai/core";
-import { type SpawnPluginRunnerOptions } from "@rynx-ai/plugin-runner";
-import { type PluginAuthMaterial, type PluginContributionStatus, type PluginContributionTarget, type PluginJsonValue, type PluginRunnerHandshake, type PluginRuntimeStatus, type PluginStartContributionRequest } from "@rynx-ai/plugin-sdk";
+import { type PluginHealth, type PluginJsonValue } from "@rynx-ai/plugin-sdk";
+import { type SpawnedPluginRunner, type SpawnPluginRunnerOptions } from "@rynx-ai/plugin-runner";
 import { type PluginHostServices } from "./plugin-host-rpc.js";
-import type { RunnablePluginRecord } from "./plugin-store.js";
-export interface PluginRunnerClientHandle {
-    startContribution(request: PluginStartContributionRequest): Promise<void>;
-    stopContribution(target: PluginContributionTarget): Promise<void>;
-    status(target: PluginContributionTarget): Promise<PluginContributionStatus>;
-    runtimeStatus(): Promise<PluginRuntimeStatus>;
-    authorize(request: {
-        kind: "chat-channel";
-        contributionId: string;
-        instanceId?: string;
-        config: Readonly<Record<string, PluginJsonValue>>;
-    }, onMaterial: (material: PluginAuthMaterial) => void, options?: {
-        signal?: AbortSignal;
-        timeoutMs?: number;
-    }): Promise<Record<string, PluginJsonValue>>;
-    emitHostEvent(event: string, payload?: unknown): Promise<void>;
-}
-/** The subset of a spawned runner the supervisor owns. Kept structural for tests. */
-export interface SupervisedPluginRunner {
-    readonly client: PluginRunnerClientHandle;
-    readonly handshake: PluginRunnerHandshake;
-    readonly completion: Promise<{
-        code: number | null;
-        signal: NodeJS.Signals | null;
-    }>;
-    close(): Promise<void>;
-}
-export type PluginRunnerSpawnFactory = (options: SpawnPluginRunnerOptions) => Promise<SupervisedPluginRunner>;
+import { type PluginRecord, type PluginRuntimeState, type RunnablePluginRecord } from "./plugin-store.js";
+export type PluginRunnerSpawnFactory = (options: SpawnPluginRunnerOptions) => Promise<SpawnedPluginRunner>;
 export interface PluginSupervisorLogEntry {
     level: "info" | "warn" | "error";
     event: string;
@@ -40,121 +13,68 @@ export interface PluginSupervisorLogEntry {
     signal?: NodeJS.Signals | null;
 }
 export interface PluginSupervisorOptions {
-    /**
-     * Trusted daemon-owned services. May be bound later because the composition
-     * root needs the static channel catalog before startServer constructs them.
-     */
     services?: PluginHostServices;
     spawnRunner?: PluginRunnerSpawnFactory;
     log?: (entry: PluginSupervisorLogEntry) => void;
-    /** Test knobs; production restart delay is always capped at 30 seconds. */
     restartBaseMs?: number;
     restartMaxMs?: number;
-    stableResetMs?: number;
-    /** Test override. Production generates one identity per supervisor process lifetime. */
+    healthPollMs?: number;
     daemonInstanceId?: string;
-}
-export interface PluginContributionRuntimeSnapshot {
-    key: string;
-    target: PluginContributionTarget;
-    desired: boolean;
-    generation?: number;
-    failureCount: number;
-    status: PluginContributionStatus;
-}
-export interface PluginRunnerRuntimeSnapshot {
-    state: "stopped" | "starting" | "running" | "backoff" | "failed";
-    generation: number;
-    failureCount: number;
-    lastError?: string;
+    verifyPackage?: (record: RunnablePluginRecord) => Promise<void>;
 }
 export interface PluginRuntimeStatusSnapshot {
-    capturedAt: string;
     plugins: Array<{
         pluginId: string;
-        runner: PluginRunnerRuntimeSnapshot;
-        runtimeStatus: PluginRuntimeStatus;
-        contributions: PluginContributionRuntimeSnapshot[];
+        generation: number;
+        state: PluginRuntimeState;
+        health?: PluginHealth;
+        error?: string;
+        settings: boolean;
     }>;
 }
 /**
- * Owns isolated plugin child processes and projects their static chat-channel
- * declarations onto trusted host-side ChannelManager handles.
- *
- * There is at most one resident child per enabled plugin. Chat-channel
- * instances are independent desired-state entries inside that child, so
- * stopping the final channel does not tear down the plugin runtime itself.
+ * Supervises exactly one language-neutral runtime process per enabled plugin.
+ * It has no channel-instance API and never interprets plugin-owned state.
  */
 export declare class PluginSupervisor {
     private readonly states;
-    private services?;
+    private readonly queues;
     private readonly spawnRunner;
-    private readonly logger?;
+    private readonly log;
+    private readonly daemonInstanceId;
     private readonly restartBaseMs;
     private readonly restartMaxMs;
-    private readonly stableResetMs;
-    private readonly daemonInstanceId;
-    private readonly runtimeOperations;
+    private readonly healthPollMs;
+    private readonly verifyPackage;
+    private services?;
     private disposed;
-    constructor(plugins: readonly RunnablePluginRecord[], options: PluginSupervisorOptions);
-    /** Static channel catalog. Calling this never loads or executes plugin code. */
-    createChannelTypeDescriptors(): ChannelTypeDescriptor[];
-    /** Bind the trusted host once, after the server composition root constructs it. */
-    bindHostServices(services: PluginHostServices): this;
-    /** Cached, non-blocking runner/contribution health for the generic control API. */
-    statusSnapshot(): PluginRuntimeStatusSnapshot;
-    /** Start one resident runner for every enabled runtime plugin. */
+    constructor(records: readonly RunnablePluginRecord[], options?: PluginSupervisorOptions);
+    bindHostServices(services: PluginHostServices): void;
     startPluginRuntimes(): Promise<void>;
-    /**
-     * Atomically replace or add one plugin runtime, preserving its live chat
-     * desired state. Concurrent reloads of the same plugin are applied in call
-     * order; other plugins continue running independently.
-     */
-    reloadPluginRuntime(record: RunnablePluginRecord, { readyTimeoutMs }?: {
-        readyTimeoutMs?: number;
-    }): Promise<PluginRuntimeStatus>;
-    /**
-     * Make one enabled plugin runtime ready without replacing an already healthy
-     * runner. This is the idempotent operation plugin CLIs use when their durable
-     * configuration has not changed.
-     */
-    ensurePluginRuntime(record: RunnablePluginRecord, { readyTimeoutMs }?: {
-        readyTimeoutMs?: number;
-    }): Promise<PluginRuntimeStatus>;
-    private enqueueRuntimeOperation;
-    private performPluginRuntimeEnsure;
-    private performPluginRuntimeReload;
-    /** Permanently stop all children and cancel every pending automatic restart. */
+    ensurePluginRuntime(record: RunnablePluginRecord): Promise<PluginRuntimeState>;
+    /** Strict cutover: stop current generation, then start the supplied generation. */
+    reloadPluginRuntime(record: RunnablePluginRecord): Promise<PluginRuntimeState>;
+    stopPluginRuntime(identity: string): Promise<void>;
+    changeEnabled(record: PluginRecord, enabled: boolean, mutateRegistry: () => PluginRecord): Promise<PluginRuntimeState>;
+    cutoverInstallation(identity: string, commitRegistry: () => Promise<PluginRecord>): Promise<PluginRuntimeState>;
+    uninstallInstallation(identity: string, removeRegistry: () => Promise<boolean>): Promise<boolean>;
+    settingsCall(identity: string, expectedGeneration: string, method: string, params?: PluginJsonValue, options?: {
+        signal?: AbortSignal;
+    }): Promise<PluginJsonValue>;
+    supportsSettings(identity: string): boolean;
+    statusSnapshot(): PluginRuntimeStatusSnapshot;
     dispose(): Promise<void>;
-    private channelDescriptor;
-    private createRemoteChannel;
-    private authorize;
-    private rememberDesired;
-    private ensureDesiredStarted;
-    private startDesiredOnRunner;
-    private stopDesired;
-    private refreshContributionStatus;
-    private refreshRuntimeStatus;
-    private waitForRuntimeReady;
-    private runtimeReadyTimeoutError;
-    private ensureRunner;
-    private spawnAndBind;
-    private trackRunnerExit;
-    private runnerExited;
-    private joinExitTransition;
+    private upsertState;
+    private startState;
+    private startSettingsState;
+    private stopSettingsState;
+    private handleSettingsExit;
+    private stopState;
+    private handleExit;
+    private failState;
     private scheduleRestart;
-    private restart;
-    private restoreDesiredContributions;
-    private closeRunner;
-    private disposeState;
-    private cancelRestart;
-    private markRunnerUnavailable;
-    private markContributionFailed;
-    private stderrSink;
-    private writeLog;
-    private assertOpen;
-    private assertReady;
-    private requireHostServices;
+    private scheduleHealthPoll;
+    private refreshHealth;
+    private failRunningState;
+    private runSerialized;
 }
-/** Convenience export for composition roots that only need the static catalog. */
-export declare function createChannelTypeDescriptors(supervisor: PluginSupervisor): ChannelTypeDescriptor[];