@hachej/boring-workspace 0.1.24 → 0.1.26

package/dist/createInMemoryBridge--ZFPAgXy.d.ts

@@ -0,0 +1,161 @@
+import { B as BoringPackageBoringField, a as BoringPackagePiField } from './manifest-C2vVgH_e.js';
+import { PiPackageSource, PluginSkillSource, ProvisionWorkspaceRuntimeOptions } from '@hachej/boring-agent/server';
+import { FastifyPluginAsync } from 'fastify';
+import { A as AgentTool, U as UiBridge } from './ui-bridge-Bdgl2hR8.js';
+
+type BoringPluginNativeFrontTargetTrust$1 = "local-trusted-native";
+/**
+ * Host-owned runtime import target for a plugin front entry.
+ *
+ * Only the trusted native/browser-module case exists today. Future
+ * target kinds (iframe/artifact/...) can extend the union without
+ * rewriting list/event payload shapes.
+ */
+interface BoringPluginNativeFrontTarget$1 {
+    kind: "native";
+    entryUrl: string;
+    revision: number;
+    trust: BoringPluginNativeFrontTargetTrust$1;
+}
+type BoringPluginFrontTarget$1 = BoringPluginNativeFrontTarget$1;
+type BoringPluginEvent$1 = {
+    type: "boring.plugin.load";
+    id: string;
+    boring: BoringPackageBoringField;
+    version: string;
+    revision: number;
+    frontUrl?: string;
+    frontTarget?: BoringPluginFrontTarget$1;
+} | {
+    type: "boring.plugin.unload";
+    id: string;
+    revision: number;
+} | {
+    type: "boring.plugin.error";
+    id: string;
+    revision: number;
+    message: string;
+};
+interface BoringPluginListEntry$1 {
+    id: string;
+    boring: BoringPackageBoringField;
+    pi?: BoringPackagePiField;
+    version: string;
+    revision: number;
+    frontUrl?: string;
+    frontTarget?: BoringPluginFrontTarget$1;
+}
+
+interface BoringServerPluginManifest {
+    id: string;
+    rootDir: string;
+    version: string;
+    boring: BoringPackageBoringField;
+    pi?: BoringPackagePiField;
+    frontPath?: string;
+    /** Legacy Vite-dev browser import fallback (`/@fs/...`). */
+    frontUrl?: string;
+    serverPath?: string;
+    extensionPaths?: string[];
+    skillPaths?: string[];
+}
+type BoringPluginNativeFrontTargetTrust = BoringPluginNativeFrontTargetTrust$1;
+type BoringPluginNativeFrontTarget = BoringPluginNativeFrontTarget$1;
+type BoringPluginFrontTarget = BoringPluginFrontTarget$1;
+type BoringPluginListEntry = BoringPluginListEntry$1;
+interface BoringPluginFrontTargetResolverContext {
+    revision: number;
+    /** Plugin-root-relative front entry path normalized for URL-like consumers. */
+    frontEntrySubpath: string;
+}
+type BoringPluginFrontTargetResolver = (plugin: BoringServerPluginManifest, context: BoringPluginFrontTargetResolverContext) => BoringPluginFrontTarget | undefined;
+/**
+ * Surfaces whose changes the hot-reload pipeline can't re-load mid-
+ * session — set when a plugin's load DID succeed but a sub-surface
+ * (the agent-tools registry, Fastify routes) carries stale code from
+ * the previous revision. The /reload caller (chat UI, verify-plugin,
+ * etc.) should surface a "restart needed for X" warning.
+ *
+ * - `'routes'`: a `WorkspaceServerPlugin.routes` function changed. The
+ *   workspace's Fastify instance can't unregister + re-register routes
+ *   mid-flight; the previous routes stay live until next boot.
+ * - `'agentTools'`: a `WorkspaceServerPlugin.agentTools` array changed.
+ *   The current Pi session still has the old tool list; new sessions
+ *   get the new list.
+ * - Multiple surfaces: order is deterministic (`routes` before
+ *   `agentTools`) so subscribers can format consistently.
+ */
+type PluginRestartSurface = "routes" | "agentTools";
+type BoringPluginEvent = (Extract<BoringPluginEvent$1, {
+    type: "boring.plugin.load";
+}> & {
+    /**
+     * Non-empty when the plugin loaded but one or more server-side
+     * surfaces still hold pre-load code. UI consumers should render
+     * a "restart needed: <surfaces>" hint. Empty/omitted = fully
+     * live.
+     */
+    requiresRestart?: PluginRestartSurface[];
+}) | Extract<BoringPluginEvent$1, {
+    type: "boring.plugin.unload";
+}> | Extract<BoringPluginEvent$1, {
+    type: "boring.plugin.error";
+}>;
+
+type WorkspaceRuntimeProvisioning = NonNullable<ProvisionWorkspaceRuntimeOptions["plugins"][number]["provisioning"]>;
+interface WorkspaceServerPlugin {
+    id: string;
+    label?: string;
+    /**
+     * Native Pi package sources required by this workspace integration.
+     * Workspace declares them; @hachej/boring-agent applies them through Pi's native
+     * resource loader without asking Pi packages to export Boring adapters.
+     */
+    piPackages?: PiPackageSource[];
+    /**
+     * Native pi extension entrypoints contributed by this plugin.
+     * Passed to DefaultResourceLoader.additionalExtensionPaths so pi owns jiti
+     * loading and ctx.reload() re-imports fresh source.
+     */
+    extensionPaths?: string[];
+    systemPrompt?: string;
+    skills?: PluginSkillSource[];
+    agentTools?: AgentTool[];
+    provisioning?: WorkspaceRuntimeProvisioning;
+    routes?: FastifyPluginAsync;
+    /** UI state keys owned by this plugin that browser state PUTs must not overwrite. */
+    preservedUiStateKeys?: string[];
+}
+declare function validateServerPlugin(plugin: WorkspaceServerPlugin): void;
+declare function defineServerPlugin<T extends WorkspaceServerPlugin>(plugin: T): T;
+
+interface ServerBootstrapOptions {
+    plugins?: WorkspaceServerPlugin[];
+    defaults?: WorkspaceServerPlugin[];
+    excludeDefaults?: string[];
+}
+type WorkspaceRuntimeProvisioningInput = ProvisionWorkspaceRuntimeOptions["plugins"][number];
+type WorkspaceProvisioningContribution = {
+    id: string;
+    provisioning: NonNullable<WorkspaceRuntimeProvisioningInput["provisioning"]>;
+};
+type WorkspaceRouteContribution = {
+    id: string;
+    routes: FastifyPluginAsync;
+};
+interface ServerBootstrapResult {
+    registered: string[];
+    systemPromptAppend: string;
+    piPackages: PiPackageSource[];
+    extensionPaths: string[];
+    agentTools: AgentTool[];
+    runtimePlugins: WorkspaceRuntimeProvisioningInput[];
+    provisioningContributions: WorkspaceProvisioningContribution[];
+    routeContributions: WorkspaceRouteContribution[];
+    preservedUiStateKeys: string[];
+}
+declare function bootstrapServer(options: ServerBootstrapOptions): ServerBootstrapResult;
+
+declare function createInMemoryBridge(): UiBridge;
+
+export { type BoringPluginFrontTargetResolver as B, type PluginRestartSurface as P, type ServerBootstrapOptions as S, type WorkspaceServerPlugin as W, type WorkspaceProvisioningContribution as a, type WorkspaceRouteContribution as b, createInMemoryBridge as c, type WorkspaceRuntimeProvisioningInput as d, type BoringServerPluginManifest as e, type BoringPluginListEntry as f, type BoringPluginFrontTarget as g, type BoringPluginEvent as h, type BoringPluginFrontTargetResolverContext as i, type BoringPluginNativeFrontTarget as j, type BoringPluginNativeFrontTargetTrust as k, type ServerBootstrapResult as l, bootstrapServer as m, defineServerPlugin as n, validateServerPlugin as v };

package/dist/server.d.ts

@@ -1,9 +1,11 @@
-export { S as ServerBootstrapOptions, e as ServerBootstrapResult, a as WorkspaceProvisioningContribution, b as WorkspaceRouteContribution, W as WorkspaceServerPlugin, f as bootstrapServer, c as createInMemoryBridge, g as defineServerPlugin, v as validateServerPlugin } from './createInMemoryBridge-DLckqafe.js';
+import { e as BoringServerPluginManifest, B as BoringPluginFrontTargetResolver, f as BoringPluginListEntry, g as BoringPluginFrontTarget, h as BoringPluginEvent, P as PluginRestartSurface } from './createInMemoryBridge--ZFPAgXy.js';
+export { i as BoringPluginFrontTargetResolverContext, j as BoringPluginNativeFrontTarget, k as BoringPluginNativeFrontTargetTrust, S as ServerBootstrapOptions, l as ServerBootstrapResult, a as WorkspaceProvisioningContribution, b as WorkspaceRouteContribution, W as WorkspaceServerPlugin, m as bootstrapServer, c as createInMemoryBridge, n as defineServerPlugin, v as validateServerPlugin } from './createInMemoryBridge--ZFPAgXy.js';
 import { FastifyRequest, FastifyInstance } from 'fastify';
 import { U as UiBridge, A as AgentTool } from './ui-bridge-Bdgl2hR8.js';
 export { C as CommandResult, a as UiCommand, b as UiState } from './ui-bridge-Bdgl2hR8.js';
-import { B as BoringPackageBoringField, a as BoringPackagePiField } from './manifest-C2vVgH_e.js';
+import { PiPackageSource } from '@hachej/boring-agent/server';
 export { PiPackageSource as WorkspacePiPackageSource } from '@hachej/boring-agent/server';
+import './manifest-C2vVgH_e.js';
 
 interface UiRoutesOptions {
     bridge?: UiBridge;
@@ -69,9 +71,9 @@ declare function createWorkspaceUiTools(uiBridge: UiBridge, opts?: ExecUiToolOpt
 
 /**
  * boring-ui system prompt — workflow steps + a Pi-style docs pointer
- * block (per DECISIONS.md #17). The block lists absolute paths into the
- * installed `@hachej/boring-pi` package so the agent's `read` tool can
- * fetch the SKILL.md + reference docs on demand, without inlining their
+ * block (per DECISIONS.md #17). The block lists workspace-readable paths
+ * into the installed `@hachej/boring-pi` package so the agent's `read` tool
+ * can fetch the SKILL.md + reference docs on demand, without inlining their
  * ~12-30 KB of markdown into every system prompt.
  *
  * `@hachej/boring-pi` is a runtime dep of `@hachej/boring-workspace`;
@@ -102,68 +104,6 @@ interface BuildBoringSystemPromptOptions {
 }
 declare function buildBoringSystemPrompt(opts: BuildBoringSystemPromptOptions): string;
 
-interface BoringServerPluginManifest {
-    id: string;
-    rootDir: string;
-    version: string;
-    boring: BoringPackageBoringField;
-    pi?: BoringPackagePiField;
-    frontPath?: string;
-    frontUrl?: string;
-    serverPath?: string;
-    extensionPaths?: string[];
-    skillPaths?: string[];
-}
-/**
- * Surfaces whose changes the hot-reload pipeline can't re-load mid-
- * session — set when a plugin's load DID succeed but a sub-surface
- * (the agent-tools registry, Fastify routes) carries stale code from
- * the previous revision. The /reload caller (chat UI, verify-plugin,
- * etc.) should surface a "restart needed for X" warning.
- *
- * - `'routes'`: a `WorkspaceServerPlugin.routes` function changed. The
- *   workspace's Fastify instance can't unregister + re-register routes
- *   mid-flight; the previous routes stay live until next boot.
- * - `'agentTools'`: a `WorkspaceServerPlugin.agentTools` array changed.
- *   The current Pi session still has the old tool list; new sessions
- *   get the new list.
- * - Multiple surfaces: order is deterministic (`routes` before
- *   `agentTools`) so subscribers can format consistently.
- */
-type PluginRestartSurface = "routes" | "agentTools";
-type BoringPluginEvent = {
-    type: "boring.plugin.load";
-    id: string;
-    boring: BoringPackageBoringField;
-    version: string;
-    revision: number;
-    frontUrl?: string;
-    /**
-     * Non-empty when the plugin loaded but one or more server-side
-     * surfaces still hold pre-load code. UI consumers should render
-     * a "restart needed: <surfaces>" hint. Empty/omitted = fully
-     * live.
-     */
-    requiresRestart?: PluginRestartSurface[];
-} | {
-    type: "boring.plugin.unload";
-    id: string;
-    revision: number;
-} | {
-    type: "boring.plugin.error";
-    id: string;
-    revision: number;
-    message: string;
-};
-interface BoringPluginListEntry {
-    id: string;
-    boring: BoringPackageBoringField;
-    pi?: BoringPackagePiField;
-    version: string;
-    revision: number;
-    frontUrl?: string;
-}
-
 interface BoringPluginPreflightIssue {
     pluginDir: string;
     pluginId?: string;
@@ -191,6 +131,16 @@ interface BoringPluginAssetManagerOptions {
      * the default assumes workspace root equals `process.cwd()`.
      */
     errorRoot?: string;
+    /**
+     * Optional host-owned runtime front-target resolver. When omitted, list/event
+     * payloads preserve the existing `frontUrl` (`/@fs/...`) fallback only.
+     */
+    frontTargetResolver?: BoringPluginFrontTargetResolver;
+    /**
+     * Keep legacy `/@fs/...` frontUrl payloads alongside frontTarget. Defaults
+     * to true for back-compat; packaged CLI folder/workspaces mode can disable it.
+     */
+    includeLegacyFrontUrl?: boolean;
 }
 interface LoadBoringAssetsError {
     id: string;
@@ -202,25 +152,48 @@ interface LoadBoringAssetsResult {
     events: BoringPluginEvent[];
     errors: LoadBoringAssetsError[];
 }
+interface LoadedBoringPluginInspection {
+    id: string;
+    version: string;
+    revision: number;
+    rootDir: string;
+    frontPath?: string;
+    frontTarget?: BoringPluginFrontTarget;
+}
+interface LoadedBoringPluginPiSnapshot {
+    additionalSkillPaths: string[];
+    packages: PiPackageSource[];
+    extensionPaths: string[];
+    systemPromptAppend?: string;
+}
 type Listener = (event: BoringPluginEvent) => void;
 declare class BoringPluginAssetManager {
     private readonly pluginDirs;
     private readonly errorRoot;
+    private readonly frontTargetResolver?;
+    private readonly includeLegacyFrontUrl;
     private readonly loaded;
     private readonly revisions;
     private readonly listeners;
+    private readonly lastErrors;
     private loading;
     private reloadQueued;
     constructor(options: BoringPluginAssetManagerOptions);
     preflight(): BoringPluginPreflightResult;
     list(): BoringPluginListEntry[];
     getError(pluginId: string): string | null;
+    getErrors(): LoadBoringAssetsError[];
+    inspectLoaded(): LoadedBoringPluginInspection[];
+    inspectLoadedPiSnapshot(): LoadedBoringPluginPiSnapshot;
     subscribe(listener: Listener): () => void;
     load(): Promise<LoadBoringAssetsResult>;
     private drainLoads;
     private doLoadOnce;
     private collectPreflightErrors;
     private bumpRevision;
+    private toListEntry;
+    private frontUrlPayload;
+    private resolveFrontTarget;
     private emit;
     private errorPath;
     private writeError;
@@ -301,4 +274,4 @@ declare function pluginFileSignature(path: string | undefined): string;
 declare function writePluginSignatureCache(pluginRootDir: string, payload: Omit<PluginSignatureCachePayload, "version" | "loadedAt"> & Partial<Pick<PluginSignatureCachePayload, "loadedAt">>): void;
 declare function readPluginSignatureCache(pluginRootDir: string): PluginSignatureCachePayload | null;
 
-export { BoringPluginAssetManager, type BoringPluginEvent, type BoringPluginListEntry, type BoringPluginScanResult, type BoringServerPluginManifest, type PluginReloadRebuild, type PluginRestartWarning, UiBridge, type UiRoutesOptions, aggregatePluginPrompts, boringPluginRoutes, buildBoringSystemPrompt, collectRestartWarnings, createExecUiTool, createGetUiStateTool, createWorkspaceUiTools, pluginFileSignature, preflightBoringPlugins, readBoringPlugins, readPluginSignatureCache, scanBoringPlugins, uiRoutes, writePluginSignatureCache };
+export { BoringPluginAssetManager, BoringPluginEvent, BoringPluginFrontTarget, BoringPluginFrontTargetResolver, BoringPluginListEntry, type BoringPluginScanResult, BoringServerPluginManifest, type PluginReloadRebuild, type PluginRestartWarning, UiBridge, type UiRoutesOptions, aggregatePluginPrompts, boringPluginRoutes, buildBoringSystemPrompt, collectRestartWarnings, createExecUiTool, createGetUiStateTool, createWorkspaceUiTools, pluginFileSignature, preflightBoringPlugins, readBoringPlugins, readPluginSignatureCache, scanBoringPlugins, uiRoutes, writePluginSignatureCache };

package/dist/server.js

@@ -762,7 +762,7 @@ function buildBoringSystemPrompt(opts) {
   if (opts.scaffoldCommand) {
     n += 1;
     steps.push(
-      `**${n}. Scaffold.** Bash \`${opts.scaffoldCommand} <kebab-name> "$BORING_AGENT_WORKSPACE_ROOT"\` \u2014 writes canonical files under \`$BORING_AGENT_WORKSPACE_ROOT/.pi/extensions/<kebab-name>/\`. Read the generated \`package.json\` + \`front/index.tsx\`. Do NOT skip this or write from memory. Never \`cd\` to a parent repo or write plugins outside \`$BORING_AGENT_WORKSPACE_ROOT/.pi/extensions/\`.`
+      `**${n}. Check plugin-root support, then scaffold.** Bash \`boring-ui plugin-status --json\`; continue only if \`workspaceLocalPluginRoots\` is \`true\`. Then bash \`${opts.scaffoldCommand} <kebab-name> "$BORING_AGENT_WORKSPACE_ROOT"\`. Read generated \`package.json\` + \`front/index.tsx\`; do NOT write from memory.`
     );
   } else {
     n += 1;
@@ -788,7 +788,7 @@ function buildBoringSystemPrompt(opts) {
   steps.push(`**${n}. Ask the user to run \`/reload\`** to publish the change.`);
   const docsBlock = boringPiRoot ? [
     "## boring-ui plugin authoring documentation",
-    "Read these only when the user asks to build, modify, or debug a workspace plugin. Use your `read` tool with the absolute path; the agent runtime guarantees these files exist on the host:",
+    "Read these only when the user asks to build, modify, or debug a workspace plugin. Use your `read` tool with these workspace-relative paths; the agent runtime guarantees they exist inside `$BORING_AGENT_WORKSPACE_ROOT`:",
     ...buildDocsRefs(boringPiRoot).map((r) => `- ${r.topic}: ${r.path}`),
     "Follow .md cross-references when present (e.g. SKILL.md may link to a reference doc \u2014 read both)."
   ].join("\n") : [
@@ -796,7 +796,7 @@ function buildBoringSystemPrompt(opts) {
     "The `boring-plugin-authoring` skill listed under `<available_skills>` is the authoritative reference (read its `<location>`). Additional reference docs (`panels.md`, `bridge.md`, `plugins.md`) are unavailable on this host \u2014 `@hachej/boring-pi` is not installed."
   ].join("\n");
   return [
-    "You are operating inside boring-ui. Workspace root: `$BORING_AGENT_WORKSPACE_ROOT`; plugin files go under `$BORING_AGENT_WORKSPACE_ROOT/.pi/extensions/<name>/`.",
+    "You are operating inside boring-ui. Before `.pi/extensions/<name>/`, run `boring-ui plugin-status --json`; continue only when `workspaceLocalPluginRoots` is `true`. Default to `.pi/extensions/<name>/`. Global `~/.pi/agent/extensions/` only for explicit requests.",
     [
       "## Plugin authoring \u2014 required workflow",
       "",
@@ -806,7 +806,7 @@ function buildBoringSystemPrompt(opts) {
       "- API factories: `createPlugin`, `defineFrontPlugin`, `defineComponent` \u2014 use `definePlugin({id, panels, commands, ...})` from `@hachej/boring-workspace/plugin`.",
       "- Imperative method names: `registerComponent`, `addPanel`, `registerCommand` (no `Panel`), `registerTab` \u2014 the actual names are `registerPanel`, `registerPanelCommand`, `registerLeftTab`, `registerSurfaceResolver` (and you usually express these declaratively, not as method calls).",
       "- Import paths: `@hachej/boring-pi` (it's a skills package, not for code), `@boring-ui/*`, `@hachej/pi-sdk` \u2014 use `@hachej/boring-workspace/plugin` for front and `@hachej/boring-workspace/server` for server.",
-      '- File visualizers: for `.csv`/file-tree opens, import `WORKSPACE_OPEN_PATH_SURFACE_KIND` (and `PaneProps`) from `@hachej/boring-workspace/plugin`, read `request.target`, and fetch `/api/v1/files/raw?path=${encodeURIComponent(request.target)}`. Never import these from the root package, use `/workspace/read`, or string kind `"WORKSPACE_OPEN_PATH_SURFACE_KIND"`.',
+      '- File visualizers: import `WORKSPACE_OPEN_PATH_SURFACE_KIND`/`PaneProps` from `@hachej/boring-workspace/plugin`; import `useApiBaseUrl`/`useWorkspaceRequestId` from `@hachej/boring-workspace`; read `request.target`; fetch `${apiBaseUrl}/api/v1/files/raw?...` with `credentials: "include"` and `x-boring-workspace-id` when present. Never use `/workspace/read` or string kind `"WORKSPACE_OPEN_PATH_SURFACE_KIND"`.',
       "- Pi extension tools: `defineTool` and `export const tools` do NOT exist. Export `default function (pi) { pi.registerTool({ name, description, execute }) }`.",
       '- Server/Pi tool method: `handler` \u2014 use `execute`. Return shape: `{ content: [{ type: "text", text }] }` (NEVER a bare string).',
       "- Manifest values: `boring.server: true` \u2014 use `false`/omit for hot-reload user plugins, or a relative path string only for advanced boot-time/static server integration.",
@@ -820,7 +820,7 @@ function buildBoringSystemPrompt(opts) {
 // src/server/agentPlugins/manager.ts
 import { createHash } from "crypto";
 import { existsSync as existsSync4, lstatSync, mkdirSync as mkdirSync2, readFileSync as readFileSync3, readdirSync as readdirSync2, realpathSync as realpathSync2, rmSync as rmSync2, statSync as statSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname5, isAbsolute as isAbsolute3, join as join4, relative as relative3, resolve as resolve4 } from "path";
+import { dirname as dirname5, isAbsolute as isAbsolute3, join as join4, relative as relative3, resolve as resolve5 } from "path";
 
 // src/shared/plugins/manifest.ts
 var SEMVER_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
@@ -1241,7 +1241,48 @@ function clearPluginSignatureCache(pluginRootDir) {
   if (existsSync3(path)) rmSync(path, { force: true });
 }
 
+// src/server/agentPlugins/piPackages.ts
+import { resolve as resolve4 } from "path";
+var REMOTE_PI_PACKAGE_PREFIXES2 = ["npm:", "git:", "github:", "http:", "https:", "ssh:"];
+function isRemotePiPackageSource2(source) {
+  return REMOTE_PI_PACKAGE_PREFIXES2.some((prefix) => source.startsWith(prefix));
+}
+function packageLocalPathFromSource(source) {
+  if (isRemotePiPackageSource2(source)) return null;
+  return source.startsWith("file:") ? source.slice("file:".length) : source;
+}
+function normalizeLocalPiPackageSource(pluginRoot, source) {
+  const localPath = packageLocalPathFromSource(source);
+  if (localPath == null) return source;
+  if (localPath === "." || localPath === "./") return resolve4(pluginRoot);
+  const normalized = localPath.startsWith("./") ? localPath.slice(2) : localPath;
+  if (!isSafePluginRelativePath(normalized)) {
+    throw new Error(`unsafe Pi package source: ${source}`);
+  }
+  return resolve4(pluginRoot, normalized);
+}
+function normalizeBoringPluginPiPackageSource(pluginRoot, source) {
+  if (typeof source === "string") return normalizeLocalPiPackageSource(pluginRoot, source);
+  return {
+    source: normalizeLocalPiPackageSource(pluginRoot, source.source),
+    ...source.extensions ? { extensions: source.extensions } : {},
+    ...source.skills ? { skills: source.skills } : {},
+    ...source.prompts ? { prompts: source.prompts } : {},
+    ...source.themes ? { themes: source.themes } : {}
+  };
+}
+function normalizeBoringPluginPiPackages(plugins) {
+  return plugins.flatMap(
+    (plugin) => (plugin.pi?.packages ?? []).map(
+      (source) => normalizeBoringPluginPiPackageSource(plugin.rootDir, source)
+    )
+  );
+}
+
 // src/server/agentPlugins/manager.ts
+function skillPathForPiLoader(path) {
+  return existsSync4(join4(path, "SKILL.md")) ? dirname5(path) : path;
+}
 function preflightErrorId(pluginDir) {
   return `preflight-${createHash("sha256").update(pluginDir).digest("hex").slice(0, 12)}`;
 }
@@ -1300,8 +1341,17 @@ function directorySignature(root) {
   visit(root, 0);
   return hash.digest("hex");
 }
+function normalizePluginSubpath(rootDir, path) {
+  return relative3(rootDir, path).replaceAll("\\", "/");
+}
+function frontSignatureRoot(plugin) {
+  if (!plugin.frontPath) return void 0;
+  const frontRoot = join4(plugin.rootDir, "front");
+  const rel = relative3(frontRoot, plugin.frontPath);
+  return rel === "" || !rel.startsWith("..") && !isAbsolute3(rel) ? frontRoot : dirname5(plugin.frontPath);
+}
 function pluginSignature(plugin) {
-  return createHash("sha256").update(JSON.stringify(plugin.boring)).update(JSON.stringify(plugin.pi ?? {})).update(plugin.version).update(plugin.frontPath ?? "").update(pluginFileSignature(plugin.frontPath)).update(directorySignature(plugin.frontPath ? dirname5(plugin.frontPath) : void 0)).update(directorySignature(join4(plugin.rootDir, "shared"))).update(plugin.serverPath ?? "").update(pluginFileSignature(plugin.serverPath)).update(directorySignature(plugin.serverPath ? dirname5(plugin.serverPath) : void 0)).update((plugin.extensionPaths ?? []).join("\0")).update((plugin.skillPaths ?? []).join("\0")).digest("hex");
+  return createHash("sha256").update(JSON.stringify(plugin.boring)).update(JSON.stringify(plugin.pi ?? {})).update(plugin.version).update(plugin.frontPath ?? "").update(pluginFileSignature(plugin.frontPath)).update(directorySignature(frontSignatureRoot(plugin))).update(directorySignature(join4(plugin.rootDir, "shared"))).update(plugin.serverPath ?? "").update(pluginFileSignature(plugin.serverPath)).update(directorySignature(plugin.serverPath ? dirname5(plugin.serverPath) : void 0)).update((plugin.extensionPaths ?? []).join("\0")).update((plugin.skillPaths ?? []).join("\0")).digest("hex");
 }
 function computeRequiresRestart(previous, next) {
   if (!previous) return [];
@@ -1316,32 +1366,55 @@ function computeRequiresRestart(previous, next) {
 var BoringPluginAssetManager = class {
   pluginDirs;
   errorRoot;
+  frontTargetResolver;
+  includeLegacyFrontUrl;
   loaded = /* @__PURE__ */ new Map();
   revisions = /* @__PURE__ */ new Map();
   listeners = /* @__PURE__ */ new Set();
+  lastErrors = /* @__PURE__ */ new Map();
   loading = null;
   reloadQueued = false;
   constructor(options) {
     this.pluginDirs = options.pluginDirs;
     this.errorRoot = options.errorRoot ?? join4(process.cwd(), ".pi", "extensions");
+    this.frontTargetResolver = options.frontTargetResolver;
+    this.includeLegacyFrontUrl = options.includeLegacyFrontUrl ?? true;
   }
   preflight() {
     return preflightBoringPlugins(this.pluginDirs);
   }
   list() {
+    return [...this.loaded.values()].map((plugin) => this.toListEntry(plugin));
+  }
+  getError(pluginId) {
+    const path = this.errorPath(pluginId);
+    if (!path || !existsSync4(path)) return null;
+    return readFileSync3(path, "utf8");
+  }
+  getErrors() {
+    return [...this.lastErrors.values()];
+  }
+  inspectLoaded() {
     return [...this.loaded.values()].map((plugin) => ({
       id: plugin.id,
-      boring: plugin.boring,
-      ...plugin.pi ? { pi: plugin.pi } : {},
       version: plugin.version,
       revision: plugin.revision,
-      ...plugin.frontUrl ? { frontUrl: plugin.frontUrl } : {}
+      rootDir: plugin.rootDir,
+      ...plugin.frontPath ? { frontPath: plugin.frontPath } : {},
+      ...plugin.frontTarget ? { frontTarget: plugin.frontTarget } : {}
     }));
   }
-  getError(pluginId) {
-    const path = this.errorPath(pluginId);
-    if (!path || !existsSync4(path)) return null;
-    return readFileSync3(path, "utf8");
+  inspectLoadedPiSnapshot() {
+    const plugins = [...this.loaded.values()];
+    const prompts = plugins.map((plugin) => plugin.pi?.systemPrompt?.trim()).filter((prompt) => Boolean(prompt));
+    return {
+      additionalSkillPaths: [...new Set(plugins.flatMap((plugin) => plugin.skillPaths ?? []).map(skillPathForPiLoader))],
+      packages: compactPiPackages(normalizeBoringPluginPiPackages(plugins)),
+      extensionPaths: plugins.flatMap((plugin) => plugin.extensionPaths ?? []),
+      ...prompts.length > 0 ? { systemPromptAppend: `# Loaded boring-ui plugin context
+
+${prompts.join("\n\n")}` } : {}
+    };
   }
   subscribe(listener) {
     this.listeners.add(listener);
@@ -1366,19 +1439,21 @@ var BoringPluginAssetManager = class {
     return result;
   }
   async doLoadOnce() {
+    this.lastErrors.clear();
     const scan = scanBoringPlugins(this.pluginDirs);
     const nextPlugins = scan.plugins;
     const nextIds = new Set(nextPlugins.map((plugin) => plugin.id));
-    const invalidPluginDirs = new Set(scan.preflight.errors.map((error) => resolve4(error.pluginDir)));
+    const invalidPluginDirs = new Set(scan.preflight.errors.map((error) => resolve5(error.pluginDir)));
     const events = [];
     const errors = [];
     this.collectPreflightErrors(scan.preflight, events, errors);
     for (const id of [...this.loaded.keys()]) {
       if (nextIds.has(id)) continue;
       const previous = this.loaded.get(id);
-      if (previous && invalidPluginDirs.has(resolve4(previous.rootDir))) continue;
+      if (previous && invalidPluginDirs.has(resolve5(previous.rootDir))) continue;
       const revision = this.bumpRevision(id);
       this.loaded.delete(id);
+      this.lastErrors.delete(id);
       if (previous) {
         try {
           clearPluginSignatureCache(previous.rootDir);
@@ -1395,9 +1470,17 @@ var BoringPluginAssetManager = class {
         const previous = this.loaded.get(plugin.id);
         if (previous?.signature === signature) continue;
         const revision = this.bumpRevision(plugin.id);
+        const frontTarget = this.resolveFrontTarget(plugin, revision);
         const serverSignature = plugin.serverPath ? pluginFileSignature(plugin.serverPath) : null;
-        const record = { ...plugin, revision, signature, serverSignature };
+        const record = {
+          ...plugin,
+          revision,
+          signature,
+          ...frontTarget ? { frontTarget } : {},
+          serverSignature
+        };
         this.loaded.set(plugin.id, record);
+        this.lastErrors.delete(plugin.id);
         this.clearError(plugin.id);
         try {
           writePluginSignatureCache(plugin.rootDir, { serverSignature });
@@ -1410,7 +1493,8 @@ var BoringPluginAssetManager = class {
           boring: plugin.boring,
           version: plugin.version,
           revision,
-          ...plugin.frontUrl ? { frontUrl: plugin.frontUrl } : {},
+          ...this.frontUrlPayload(plugin.frontUrl),
+          ...frontTarget ? { frontTarget } : {},
           ...requiresRestart.length > 0 ? { requiresRestart } : {}
         };
         events.push(event);
@@ -1420,7 +1504,9 @@ var BoringPluginAssetManager = class {
         const message = error instanceof Error ? error.stack ?? error.message : String(error);
         this.writeError(plugin.id, message);
         const event = { type: "boring.plugin.error", id: plugin.id, revision, message };
-        errors.push({ id: plugin.id, revision, message });
+        const loadError = { id: plugin.id, revision, message };
+        this.lastErrors.set(plugin.id, loadError);
+        errors.push(loadError);
         events.push(event);
         this.emit(event);
       }
@@ -1435,6 +1521,7 @@ var BoringPluginAssetManager = class {
 
 Plugin dir: ${error.pluginDir}`;
       const loadError = { id, revision, message };
+      this.lastErrors.set(id, loadError);
       errors.push(loadError);
       this.writeError(id, message);
       const event = { type: "boring.plugin.error", id, revision, message };
@@ -1447,6 +1534,31 @@ Plugin dir: ${error.pluginDir}`;
     this.revisions.set(id, next);
     return next;
   }
+  toListEntry(plugin) {
+    return {
+      id: plugin.id,
+      boring: plugin.boring,
+      ...plugin.pi ? { pi: plugin.pi } : {},
+      version: plugin.version,
+      revision: plugin.revision,
+      ...this.frontUrlPayload(plugin.frontUrl),
+      ...plugin.frontTarget ? { frontTarget: plugin.frontTarget } : {}
+    };
+  }
+  frontUrlPayload(frontUrl) {
+    if (!this.includeLegacyFrontUrl || !frontUrl) return {};
+    return { frontUrl };
+  }
+  resolveFrontTarget(plugin, revision) {
+    if (!plugin.frontPath || !this.frontTargetResolver) return void 0;
+    const frontEntrySubpath = typeof plugin.boring.front === "string" ? plugin.boring.front.replace(/^\.\//, "") : normalizePluginSubpath(plugin.rootDir, plugin.frontPath);
+    const frontTarget = this.frontTargetResolver(plugin, {
+      revision,
+      frontEntrySubpath
+    });
+    if (!frontTarget) return void 0;
+    return { ...frontTarget, revision };
+  }
   emit(event) {
     for (const listener of [...this.listeners]) {
       try {
@@ -1459,8 +1571,8 @@ Plugin dir: ${error.pluginDir}`;
   }
   errorPath(pluginId) {
     if (!isValidBoringPluginId(pluginId)) return null;
-    const root = resolve4(this.errorRoot);
-    const path = resolve4(root, pluginId, ".error");
+    const root = resolve5(this.errorRoot);
+    const path = resolve5(root, pluginId, ".error");
     const rel = relative3(root, path);
     if (rel.startsWith("..") || isAbsolute3(rel)) return null;
     return path;
@@ -1535,27 +1647,44 @@ async function boringPluginRoutes(app, opts) {
     res.setHeader("Connection", "keep-alive");
     res.setHeader("X-Accel-Buffering", "no");
     res.flushHeaders?.();
-    const write = (event) => {
+    const write = (eventName, payload) => {
       try {
-        res.write(`event: ${event.type}
+        res.write(`event: ${eventName}
 `);
-        res.write(`data: ${JSON.stringify(event)}
+        res.write(`data: ${JSON.stringify(payload)}
 
 `);
       } catch {
       }
     };
+    const liveQueue = [];
+    let replaying = true;
+    const unsubscribe = manager.subscribe((event) => {
+      const payload = { ...event, replay: false };
+      if (replaying) {
+        liveQueue.push({ eventName: event.type, payload });
+        return;
+      }
+      write(event.type, payload);
+    });
     for (const plugin of manager.list()) {
-      write({
+      write("boring.plugin.load", {
         type: "boring.plugin.load",
         id: plugin.id,
         boring: plugin.boring,
         version: plugin.version,
         revision: plugin.revision,
-        ...plugin.frontUrl ? { frontUrl: plugin.frontUrl } : {}
+        ...plugin.frontUrl ? { frontUrl: plugin.frontUrl } : {},
+        ...plugin.frontTarget ? { frontTarget: plugin.frontTarget } : {},
+        replay: true
       });
     }
-    const unsubscribe = manager.subscribe(write);
+    write("boring.plugin.replay-complete", {
+      type: "boring.plugin.replay-complete",
+      replay: true
+    });
+    replaying = false;
+    for (const event of liveQueue) write(event.eventName, event.payload);
     const heartbeat = setInterval(() => {
       try {
         res.write(": heartbeat\n\n");