@h-rig/runtime 0.0.6-alpha.3 → 0.0.6-alpha.30

package/dist/src/control-plane/pi-sessiond/session-service.js

@@ -0,0 +1,540 @@
+// @bun
+// packages/runtime/src/control-plane/pi-sessiond/session-service.ts
+import { randomUUID as randomUUID2 } from "crypto";
+import { mkdirSync } from "fs";
+import { join } from "path";
+import {
+  AuthStorage,
+  createAgentSessionFromServices,
+  createAgentSessionRuntime,
+  createAgentSessionServices,
+  ModelRegistry,
+  SessionManager
+} from "@earendil-works/pi-coding-agent";
+
+// packages/runtime/src/control-plane/pi-sessiond/extension-ui-context.ts
+import { randomUUID } from "crypto";
+import {
+  initTheme
+} from "@earendil-works/pi-coding-agent";
+var headlessTheme = {
+  fg: (_color, text) => text,
+  bg: (_color, text) => text,
+  dim: (text) => text,
+  bold: (text) => text,
+  italic: (text) => text,
+  underline: (text) => text,
+  strikethrough: (text) => text,
+  reset: (text) => text,
+  getFgAnsi: () => "",
+  getBgAnsi: () => "",
+  name: "rig-headless"
+};
+function ensureThemeInitialized() {
+  try {
+    initTheme(undefined, false);
+  } catch {}
+}
+
+class RigPiExtensionUiBridge {
+  sessionId;
+  runId;
+  publish;
+  pending = new Map;
+  constructor(sessionId, runId, publish) {
+    this.sessionId = sessionId;
+    this.runId = runId;
+    this.publish = publish;
+    ensureThemeInitialized();
+  }
+  createContext() {
+    const dialog = (opts, defaultValue, request, parse) => {
+      if (opts?.signal?.aborted)
+        return Promise.resolve(defaultValue);
+      const id = randomUUID();
+      return new Promise((resolve) => {
+        let timeout;
+        const cleanup = () => {
+          if (timeout)
+            clearTimeout(timeout);
+          opts?.signal?.removeEventListener("abort", onAbort);
+          this.pending.delete(id);
+        };
+        const finish = (value) => {
+          cleanup();
+          resolve(value);
+        };
+        const onAbort = () => finish(defaultValue);
+        opts?.signal?.addEventListener("abort", onAbort, { once: true });
+        if (opts?.timeout)
+          timeout = setTimeout(() => finish(defaultValue), opts.timeout);
+        this.pending.set(id, {
+          timeout,
+          abort: onAbort,
+          resolve: (raw) => finish(parse(normalizeResponse(raw)))
+        });
+        this.publish({
+          type: "extension_ui_request",
+          sessionId: this.sessionId,
+          runId: this.runId,
+          request: { id, timeout: opts?.timeout, ...request }
+        });
+      });
+    };
+    return {
+      select: (title, options, opts) => dialog(opts, undefined, { method: "select", title, options }, (response) => {
+        if (response.cancelled)
+          return;
+        return typeof response.value === "string" ? response.value : undefined;
+      }),
+      confirm: (title, message, opts) => dialog(opts, false, { method: "confirm", title, message }, (response) => {
+        if (response.cancelled)
+          return false;
+        return response.confirmed === true || response.value === true;
+      }),
+      input: (title, placeholder, opts) => dialog(opts, undefined, { method: "input", title, placeholder }, (response) => {
+        if (response.cancelled)
+          return;
+        return typeof response.value === "string" ? response.value : undefined;
+      }),
+      notify: (message, type) => {
+        this.fire({ method: "notify", message, notifyType: type });
+      },
+      onTerminalInput: () => () => {},
+      setStatus: (key, text) => {
+        this.fire({ method: "setStatus", statusKey: key, statusText: text });
+      },
+      setWorkingMessage: (message) => {
+        this.fire({ method: "setWorkingMessage", message });
+      },
+      setWorkingVisible: (visible) => {
+        this.fire({ method: "setWorkingVisible", visible });
+      },
+      setWorkingIndicator: (options) => {
+        this.fire({ method: "setWorkingIndicator", options });
+      },
+      setHiddenThinkingLabel: (label) => {
+        this.fire({ method: "setHiddenThinkingLabel", label });
+      },
+      setWidget: (key, content, options) => {
+        if (content === undefined || Array.isArray(content)) {
+          this.fire({ method: "setWidget", widgetKey: key, widgetLines: content, widgetPlacement: options?.placement });
+          return;
+        }
+        this.fire({ method: "notify", message: `Extension widget '${key}' uses a component factory that Rig daemon mode cannot render.`, notifyType: "warning" });
+      },
+      setFooter: (factory) => {
+        if (factory !== undefined)
+          this.fire({ method: "notify", message: "Custom extension footers are not rendered in Rig daemon mode.", notifyType: "warning" });
+      },
+      setHeader: (factory) => {
+        if (factory !== undefined)
+          this.fire({ method: "notify", message: "Custom extension headers are not rendered in Rig daemon mode.", notifyType: "warning" });
+      },
+      setTitle: (title) => {
+        this.fire({ method: "setTitle", title });
+      },
+      custom: async () => {
+        this.fire({ method: "notify", message: "Custom extension UI components are not supported in Rig daemon mode.", notifyType: "warning" });
+        return;
+      },
+      pasteToEditor: (text) => {
+        this.fire({ method: "set_editor_text", text });
+      },
+      setEditorText: (text) => {
+        this.fire({ method: "set_editor_text", text });
+      },
+      getEditorText: () => "",
+      editor: (title, prefill) => dialog(undefined, undefined, { method: "editor", title, prefill }, (response) => {
+        if (response.cancelled)
+          return;
+        return typeof response.value === "string" ? response.value : undefined;
+      }),
+      addAutocompleteProvider: () => {},
+      setEditorComponent: (factory) => {
+        if (factory !== undefined)
+          this.fire({ method: "notify", message: "Custom editor components are not supported in Rig daemon mode.", notifyType: "warning" });
+      },
+      getEditorComponent: () => {
+        return;
+      },
+      get theme() {
+        return headlessTheme;
+      },
+      getAllThemes: () => [],
+      getTheme: () => {
+        return;
+      },
+      setTheme: () => ({ success: false, error: "Theme switching is not supported in Rig daemon mode" }),
+      getToolsExpanded: () => false,
+      setToolsExpanded: () => {}
+    };
+  }
+  respond(input) {
+    const pending = this.pending.get(input.requestId);
+    if (!pending)
+      return false;
+    pending.resolve(input);
+    return true;
+  }
+  cancelAll() {
+    for (const [id, pending] of this.pending.entries()) {
+      if (pending.timeout)
+        clearTimeout(pending.timeout);
+      pending.abort?.();
+      this.pending.delete(id);
+      pending.resolve({ requestId: id, cancelled: true });
+    }
+  }
+  fire(request) {
+    this.publish({
+      type: "extension_ui_request",
+      sessionId: this.sessionId,
+      runId: this.runId,
+      request: { id: randomUUID(), ...request }
+    });
+  }
+}
+function normalizeResponse(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { requestId: "", cancelled: true };
+  const record = value;
+  return {
+    requestId: typeof record.requestId === "string" ? record.requestId : "",
+    value: record.value,
+    confirmed: typeof record.confirmed === "boolean" ? record.confirmed : undefined,
+    cancelled: record.cancelled === true
+  };
+}
+
+// packages/runtime/src/control-plane/pi-sessiond/session-service.ts
+var BUILTIN_COMMANDS = [
+  { name: "session", description: "Show session info and stats", source: "builtin" },
+  { name: "name", description: "Set session display name", source: "builtin" },
+  { name: "compact", description: "Manually compact session context", source: "builtin" },
+  { name: "reload", description: "Reload keybindings, extensions, skills, prompts, and themes", source: "builtin" },
+  { name: "quit", description: "Detach from the current local Pi frontend", source: "builtin" }
+];
+
+class RigPiSessionService {
+  hub;
+  config;
+  activeBySession = new Map;
+  sessionIdByRun = new Map;
+  heartbeat;
+  constructor(hub, config) {
+    this.hub = hub;
+    this.config = config;
+    this.heartbeat = setInterval(() => this.publishHeartbeats(), 2000);
+  }
+  activeCount() {
+    return this.activeBySession.size;
+  }
+  async dispose() {
+    clearInterval(this.heartbeat);
+    const sessions = [...this.activeBySession.values()];
+    this.activeBySession.clear();
+    this.sessionIdByRun.clear();
+    await Promise.all(sessions.map(async (active) => {
+      active.unsubscribe();
+      active.ui.cancelAll();
+      try {
+        await active.runtime.session.abort();
+      } catch {}
+      await active.runtime.dispose();
+    }));
+  }
+  async startSession(input) {
+    const existing = this.getByRun(input.runId);
+    if (existing)
+      return existing.metadata;
+    mkdirSync(input.agentDir, { recursive: true });
+    mkdirSync(input.sessionDir, { recursive: true });
+    const authStorage = AuthStorage.create(join(input.agentDir, "auth.json"));
+    const modelRegistry = ModelRegistry.create(authStorage, join(input.agentDir, "models.json"));
+    const createRuntime = async ({ cwd, agentDir, sessionManager: sessionManager2, sessionStartEvent }) => {
+      const services = await createAgentSessionServices({ cwd, agentDir, authStorage, modelRegistry });
+      const result = await createAgentSessionFromServices({ services, sessionManager: sessionManager2, sessionStartEvent });
+      return { ...result, services, diagnostics: services.diagnostics };
+    };
+    const sessionManager = SessionManager.create(input.cwd, input.sessionDir);
+    const runtime = await createAgentSessionRuntime(createRuntime, {
+      cwd: input.cwd,
+      agentDir: input.agentDir,
+      sessionManager,
+      sessionStartEvent: { type: "session_start", reason: "new" }
+    });
+    const now = new Date().toISOString();
+    const metadata = {
+      runId: input.runId,
+      sessionId: runtime.session.sessionId,
+      daemonId: this.config.daemonId,
+      cwd: input.cwd,
+      agentDir: input.agentDir,
+      sessionDir: input.sessionDir,
+      transport: "http-control-ws-events",
+      serverBasePath: `/api/runs/${encodeURIComponent(input.runId)}/pi`,
+      eventsPath: `/api/runs/${encodeURIComponent(input.runId)}/pi/events`,
+      createdAt: now,
+      updatedAt: now,
+      backend: {
+        kind: "worker-pi-sessiond",
+        version: this.config.version,
+        commit: this.config.commit,
+        pid: process.pid
+      }
+    };
+    const active = {
+      runId: input.runId,
+      runtime,
+      metadata,
+      unsubscribe: () => {},
+      ui: new RigPiExtensionUiBridge(runtime.session.sessionId, input.runId, (event) => this.publish(runtime.session.sessionId, input.runId, event))
+    };
+    await this.bindRuntime(active);
+    if (input.sessionName?.trim())
+      runtime.session.setSessionName(input.sessionName.trim());
+    this.activeBySession.set(runtime.session.sessionId, active);
+    this.sessionIdByRun.set(input.runId, runtime.session.sessionId);
+    this.publish(runtime.session.sessionId, input.runId, { type: "ready", metadata });
+    this.publishStatus(active);
+    this.publishActivity(active, "ready", "idle");
+    return metadata;
+  }
+  getByRun(runId) {
+    const sessionId = this.sessionIdByRun.get(runId);
+    return sessionId ? this.activeBySession.get(sessionId) : undefined;
+  }
+  getBySession(sessionId) {
+    return this.activeBySession.get(sessionId);
+  }
+  messages(sessionId) {
+    const active = this.requireActive(sessionId);
+    return [...active.runtime.session.messages];
+  }
+  status(sessionId) {
+    return this.statusFromActive(this.requireActive(sessionId));
+  }
+  commands(sessionId) {
+    const session = this.requireActive(sessionId).runtime.session;
+    const commands = [...BUILTIN_COMMANDS];
+    for (const command of session.extensionRunner.getRegisteredCommands()) {
+      commands.push({ name: command.invocationName, description: command.description, source: "extension" });
+    }
+    for (const template of session.promptTemplates) {
+      commands.push({ name: template.name, description: template.description, source: "prompt" });
+    }
+    for (const skill of session.resourceLoader.getSkills().skills) {
+      commands.push({ name: `skill:${skill.name}`, description: skill.description, source: "skill" });
+    }
+    return commands.sort((a, b) => a.name.localeCompare(b.name));
+  }
+  async prompt(sessionId, text, streamingBehavior) {
+    const active = this.requireActive(sessionId);
+    const session = active.runtime.session;
+    const behavior = session.isStreaming || session.isCompacting ? streamingBehavior ?? "steer" : undefined;
+    this.publishActivity(active, behavior === "followUp" ? "follow-up queued" : behavior === "steer" ? "steering queued" : "prompt accepted", "active");
+    session.prompt(text, behavior ? { streamingBehavior: behavior, source: "rpc" } : { source: "rpc" }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "error", message });
+      this.publishActivity(active, "prompt failed", "error", message);
+    });
+    this.publishStatus(active);
+    return { accepted: true };
+  }
+  async shell(sessionId, text) {
+    const active = this.requireActive(sessionId);
+    const session = active.runtime.session;
+    const excluded = text.startsWith("!!");
+    const command = (excluded ? text.slice(2) : text.startsWith("!") ? text.slice(1) : text).trim();
+    if (!command)
+      throw new Error("Usage: !<shell command>");
+    if (session.isBashRunning)
+      throw new Error("A bash command is already running");
+    this.publishActivity(active, "running bash", "active", command);
+    this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.start", command, excludeFromContext: excluded } });
+    session.executeBash(command, (chunk) => {
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.chunk", chunk } });
+      this.publishActivity(active, "running bash", "active", command);
+      this.publishStatus(active);
+    }, { excludeFromContext: excluded }).then((result) => {
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.end", ...result } });
+      this.publishActivity(active, "bash complete", result.exitCode === 0 ? "idle" : "error", command);
+      this.publishStatus(active);
+    }).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "pi.ui_event", sessionId, runId: active.runId, event: { type: "shell.end", output: message, isError: true } });
+      this.publish(active.runtime.session.sessionId, active.runId, { type: "error", message });
+      this.publishActivity(active, "bash failed", "error", message);
+      this.publishStatus(active);
+    });
+    return { accepted: true };
+  }
+  async runCommand(sessionId, text) {
+    const active = this.requireActive(sessionId);
+    const trimmed = text.trim();
+    const [rawName = "", ...args] = trimmed.replace(/^\//, "").split(/\s+/);
+    const rest = args.join(" ").trim();
+    if (rawName === "session")
+      return { type: "done", message: formatSessionStats(active.runtime.session) };
+    if (rawName === "name") {
+      if (!rest)
+        return { type: "unsupported", message: "Usage: /name <session name>" };
+      active.runtime.session.setSessionName(rest);
+      this.publishStatus(active);
+      return { type: "done", message: `Session named: ${rest}` };
+    }
+    if (rawName === "compact") {
+      active.runtime.session.compact(rest || undefined).catch((error) => {
+        this.publish(active.runtime.session.sessionId, active.runId, { type: "error", message: error instanceof Error ? error.message : String(error) });
+      });
+      return { type: "done", message: "Compaction started\u2026" };
+    }
+    if (rawName === "reload") {
+      await active.runtime.session.reload();
+      await this.bindRuntime(active);
+      return { type: "done", message: "Pi resources reloaded" };
+    }
+    if (rawName === "quit")
+      return { type: "done", message: "Detach locally with /detach or /quit." };
+    await this.prompt(sessionId, trimmed, active.runtime.session.isStreaming ? "steer" : undefined);
+    return { type: "done", message: `Accepted ${trimmed}` };
+  }
+  respondToCommand(_sessionId, _requestId, _value) {
+    return { type: "unsupported", message: "No pending command selection is active." };
+  }
+  respondToExtensionUi(sessionId, input) {
+    const active = this.requireActive(sessionId);
+    return { accepted: active.ui.respond(input) };
+  }
+  async abort(sessionId) {
+    const active = this.requireActive(sessionId);
+    active.runtime.session.clearQueue();
+    await active.runtime.session.abort();
+    this.publishActivity(active, "stopped", "idle");
+    this.publishStatus(active);
+    return { aborted: true };
+  }
+  async bindRuntime(active) {
+    active.unsubscribe();
+    const session = active.runtime.session;
+    active.ui.cancelAll();
+    active.ui = new RigPiExtensionUiBridge(session.sessionId, active.runId, (event) => this.publish(session.sessionId, active.runId, event));
+    active.metadata = { ...active.metadata, sessionId: session.sessionId, updatedAt: new Date().toISOString() };
+    this.sessionIdByRun.set(active.runId, session.sessionId);
+    this.activeBySession.set(session.sessionId, active);
+    active.runtime.setRebindSession(async () => this.bindRuntime(active));
+    await session.bindExtensions({
+      uiContext: active.ui.createContext(),
+      commandContextActions: {
+        waitForIdle: () => session.agent.waitForIdle(),
+        newSession: async (options) => active.runtime.newSession(options),
+        fork: async (entryId, options) => {
+          const result = await active.runtime.fork(entryId, options);
+          return { cancelled: result.cancelled };
+        },
+        navigateTree: async (targetId, options) => session.navigateTree(targetId, options),
+        switchSession: async (sessionPath, options) => active.runtime.switchSession(sessionPath, options),
+        reload: async () => {
+          await session.reload();
+        }
+      },
+      shutdownHandler: () => {
+        this.abort(session.sessionId);
+      },
+      onError: (error) => {
+        this.publish(session.sessionId, active.runId, { type: "error", message: error.error, detail: error });
+      }
+    });
+    active.unsubscribe = session.subscribe((event) => {
+      this.publish(session.sessionId, active.runId, { type: "pi.event", sessionId: session.sessionId, runId: active.runId, event });
+      this.publishActivityForEvent(active, event);
+      this.publishStatus(active);
+    });
+  }
+  publish(sessionId, runId, event) {
+    this.hub.publish(sessionId, runId, event);
+  }
+  publishStatus(active) {
+    const status = this.statusFromActive(active);
+    this.publish(active.runtime.session.sessionId, active.runId, { type: "status.update", sessionId: active.runtime.session.sessionId, runId: active.runId, status });
+  }
+  publishActivity(active, label, phase, detail) {
+    const activity = {
+      sessionId: active.runtime.session.sessionId,
+      runId: active.runId,
+      phase,
+      label,
+      detail,
+      at: new Date().toISOString()
+    };
+    active.activity = activity;
+    this.publish(active.runtime.session.sessionId, active.runId, { type: "activity.update", sessionId: active.runtime.session.sessionId, runId: active.runId, activity });
+  }
+  publishActivityForEvent(active, event) {
+    const type = event && typeof event === "object" && !Array.isArray(event) ? event.type : undefined;
+    if (type === "agent_start")
+      this.publishActivity(active, "agent running", "active");
+    else if (type === "agent_end")
+      this.publishActivity(active, "idle", "idle");
+    else if (type === "tool_execution_start")
+      this.publishActivity(active, `tool: ${String(event.toolName ?? "tool")}`, "active");
+    else if (type === "compaction_start")
+      this.publishActivity(active, "compacting", "active");
+    else if (type === "compaction_end")
+      this.publishActivity(active, "compaction complete", "idle");
+  }
+  publishHeartbeats() {
+    for (const active of this.activeBySession.values()) {
+      if (active.runtime.session.isStreaming || active.runtime.session.isCompacting || active.runtime.session.isBashRunning || active.runtime.session.pendingMessageCount > 0) {
+        this.publishStatus(active);
+        this.publishActivity(active, active.activity?.label ?? "active", "active", active.activity?.detail);
+      }
+    }
+  }
+  statusFromActive(active) {
+    const session = active.runtime.session;
+    return {
+      sessionId: session.sessionId,
+      runId: active.runId,
+      cwd: active.runtime.cwd,
+      sessionFile: session.sessionFile,
+      sessionName: session.sessionName,
+      model: session.model,
+      thinkingLevel: session.thinkingLevel,
+      isStreaming: session.isStreaming,
+      isCompacting: session.isCompacting,
+      isBashRunning: session.isBashRunning,
+      pendingMessageCount: session.pendingMessageCount,
+      messageCount: session.messages.length,
+      steeringMessages: session.getSteeringMessages(),
+      followUpMessages: session.getFollowUpMessages(),
+      contextUsage: session.getContextUsage(),
+      stats: session.getSessionStats()
+    };
+  }
+  requireActive(sessionId) {
+    const active = this.activeBySession.get(sessionId);
+    if (!active)
+      throw new Error("Pi session not found");
+    return active;
+  }
+}
+function formatSessionStats(session) {
+  const stats = session.getSessionStats();
+  return [
+    `Session: ${stats.sessionId}`,
+    `Messages: ${stats.totalMessages} (${stats.userMessages} user, ${stats.assistantMessages} assistant)`,
+    `Tool calls: ${stats.toolCalls}`,
+    `Tokens: \u2191${stats.tokens.input} \u2193${stats.tokens.output} total ${stats.tokens.total}`,
+    `Cost: $${stats.cost.toFixed(4)}`
+  ].join(`
+`);
+}
+function createDaemonId() {
+  return `rig-pi-sessiond-${randomUUID2()}`;
+}
+export {
+  createDaemonId,
+  RigPiSessionService
+};

package/dist/src/control-plane/pi-sessiond/types.js

@@ -0,0 +1 @@
+// @bun

package/dist/src/control-plane/plugin-host-context.js

@@ -283,6 +283,49 @@ function safeReadJson(path) {
   }
 }
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readFileSync as readFileSync2, readdirSync, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import { loadSkill } from "@rig/skill-loader";
+var MARKER_FILENAME = ".rig-plugin";
+function skillDirName(id) {
+  return id.replace(/[^a-zA-Z0-9._-]+/g, "-");
+}
+async function materializeSkills(projectRoot, entries) {
+  const skillsRoot = resolve2(projectRoot, ".pi", "skills");
+  if (existsSync3(skillsRoot)) {
+    for (const name of readdirSync(skillsRoot)) {
+      const dir = resolve2(skillsRoot, name);
+      if (existsSync3(resolve2(dir, MARKER_FILENAME))) {
+        rmSync(dir, { recursive: true, force: true });
+      }
+    }
+  }
+  const written = [];
+  for (const { pluginName, skill } of entries) {
+    const sourcePath = resolve2(projectRoot, skill.path);
+    if (!existsSync3(sourcePath)) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${sourcePath} does not exist`);
+      continue;
+    }
+    let body;
+    try {
+      await loadSkill(sourcePath);
+      body = readFileSync2(sourcePath, "utf-8");
+    } catch (err) {
+      console.warn(`[plugin-host] skill "${skill.id}" from plugin "${pluginName}" not materialized: ${err instanceof Error ? err.message : err}`);
+      continue;
+    }
+    const dir = resolve2(skillsRoot, skillDirName(skill.id));
+    mkdirSync2(dir, { recursive: true });
+    writeFileSync2(resolve2(dir, "SKILL.md"), body, "utf-8");
+    writeFileSync2(resolve2(dir, MARKER_FILENAME), `${JSON.stringify({ plugin: pluginName, skillId: skill.id }, null, 2)}
+`, "utf-8");
+    written.push({ id: skill.id, pluginName, directory: dir });
+  }
+  return written;
+}
+
 // packages/runtime/src/control-plane/plugin-host-context.ts
 async function buildPluginHostContext(projectRoot) {
   let config;
@@ -319,6 +362,17 @@ async function buildPluginHostContext(projectRoot) {
   } catch (err) {
     console.warn(`[plugin-host] hook materialization failed: ${err instanceof Error ? err.message : err}`);
   }
+  try {
+    const skillEntries = config.plugins.flatMap((plugin) => (plugin.contributes?.skills ?? []).map((skill) => ({
+      pluginName: plugin.name,
+      skill
+    })));
+    if (skillEntries.length > 0) {
+      await materializeSkills(projectRoot, skillEntries);
+    }
+  } catch (err) {
+    console.warn(`[plugin-host] skill materialization failed: ${err instanceof Error ? err.message : err}`);
+  }
   return {
     config,
     pluginHost,

package/dist/src/control-plane/runtime/image/fingerprint-sidecar.js

@@ -333,6 +333,9 @@ import { loadConfig } from "@rig/core/load-config";
 // packages/runtime/src/control-plane/repos/registry.ts
 var MANAGED_REPOS = new Map;
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { loadSkill } from "@rig/skill-loader";
+
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 

package/dist/src/control-plane/runtime/image/index.js

@@ -454,6 +454,9 @@ import { loadConfig } from "@rig/core/load-config";
 // packages/runtime/src/control-plane/repos/registry.ts
 var MANAGED_REPOS = new Map;
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { loadSkill } from "@rig/skill-loader";
+
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 

package/dist/src/control-plane/runtime/image-fingerprint-sidecar.js

@@ -332,6 +332,9 @@ import { loadConfig } from "@rig/core/load-config";
 // packages/runtime/src/control-plane/repos/registry.ts
 var MANAGED_REPOS = new Map;
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { loadSkill } from "@rig/skill-loader";
+
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);
 

package/dist/src/control-plane/runtime/image.js

@@ -454,6 +454,9 @@ import { loadConfig } from "@rig/core/load-config";
 // packages/runtime/src/control-plane/repos/registry.ts
 var MANAGED_REPOS = new Map;
 
+// packages/runtime/src/control-plane/skill-materializer.ts
+import { loadSkill } from "@rig/skill-loader";
+
 // packages/runtime/src/control-plane/tasks/source-aware-task-config-source.ts
 var STATUS_LABELS = new Set(["ready", "blocked", "in-progress", "under-review", "failed", "cancelled"]);