refactor: restructure PrismFacet per OpenClaw plugin spec

- plugin/ directory structure: hooks/, tools/, core/
- export default { id, name, register } entry format
- globalThis state management with lifecycle protection
- WeakSet dedup on before_prompt_build hook
- Tool uses inputSchema + execute (not parameters + handler)
- additionalProperties: false in config schema
- Core logic in plugin/core/ (no plugin-sdk dependency)
- Install/uninstall script (scripts/install.mjs)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

plugin/core/prompt-injector.ts

@@ -0,0 +1,41 @@
+import { readFileSync } from "node:fs";
+import { getRouters } from "./router-loader.js";
+import { getRule } from "./rule-store.js";
+import type { RouterContext } from "./router-loader.js";
+
+export interface InjectionResult {
+  appendSystemContext?: string;
+}
+
+export async function resolveInjection(
+  ctx: RouterContext,
+  log: { info(msg: string): void; warn(msg: string): void }
+): Promise<InjectionResult> {
+  const routers = getRouters();
+  const segments: string[] = [];
+
+  for (const router of routers) {
+    try {
+      const key = await router.module.resolve(ctx);
+      if (!key) continue;
+
+      const promptFile = getRule(router.name, key);
+      if (!promptFile) continue;
+
+      try {
+        const content = readFileSync(promptFile, "utf8").trim();
+        if (content) {
+          segments.push(content);
+          log.info(`[prism-facet] injecting ${router.name}:${key} → ${promptFile}`);
+        }
+      } catch (err) {
+        log.warn(`[prism-facet] cannot read ${promptFile}: ${String(err)}`);
+      }
+    } catch (err) {
+      log.warn(`[prism-facet] router ${router.name} failed: ${String(err)}`);
+    }
+  }
+
+  if (segments.length === 0) return {};
+  return { appendSystemContext: segments.join("\n\n---\n\n") };
+}

plugin/core/router-loader.ts

@@ -0,0 +1,77 @@
+import { readdirSync } from "node:fs";
+import path from "node:path";
+
+export interface RouterContext {
+  agentId: string;
+}
+
+export interface RouterModule {
+  resolve(ctx: RouterContext): string | Promise<string>;
+}
+
+export interface LoadedRouter {
+  name: string;
+  filePath: string;
+  module: RouterModule;
+}
+
+const _G = globalThis as Record<string, unknown>;
+const ROUTERS_KEY = "_prismFacetRouters";
+const LOAD_COUNTER_KEY = "_prismFacetLoadCounter";
+
+function getRouterMap(): Map<string, LoadedRouter> {
+  if (!(_G[ROUTERS_KEY] instanceof Map)) {
+    _G[ROUTERS_KEY] = new Map<string, LoadedRouter>();
+  }
+  return _G[ROUTERS_KEY] as Map<string, LoadedRouter>;
+}
+
+function routerNameFromFile(filename: string): string {
+  return filename.replace(/\.(ts|js|mjs)$/, "");
+}
+
+export async function loadRouters(
+  routersDir: string,
+  log: { info(msg: string): void; warn(msg: string): void }
+): Promise<void> {
+  const map = getRouterMap();
+  map.clear();
+
+  if (typeof _G[LOAD_COUNTER_KEY] !== "number") _G[LOAD_COUNTER_KEY] = 0;
+  (_G[LOAD_COUNTER_KEY] as number)++;
+  const counter = _G[LOAD_COUNTER_KEY] as number;
+
+  let files: string[];
+  try {
+    files = readdirSync(routersDir).filter(
+      (f) => /\.(ts|js|mjs)$/.test(f) && !f.startsWith(".")
+    );
+  } catch {
+    log.warn(`[prism-facet] routers directory not found: ${routersDir}`);
+    return;
+  }
+
+  for (const file of files) {
+    const name = routerNameFromFile(file);
+    const filePath = path.resolve(routersDir, file);
+    try {
+      const mod = (await import(`${filePath}?v=${counter}`)) as RouterModule;
+      if (typeof mod.resolve !== "function") {
+        log.warn(`[prism-facet] router ${name}: no resolve() export, skipping`);
+        continue;
+      }
+      map.set(name, { name, filePath, module: mod });
+      log.info(`[prism-facet] router loaded: ${name}`);
+    } catch (err) {
+      log.warn(`[prism-facet] router ${name}: failed to load — ${String(err)}`);
+    }
+  }
+}
+
+export function getRouters(): LoadedRouter[] {
+  return Array.from(getRouterMap().values());
+}
+
+export function getRouterNames(): string[] {
+  return Array.from(getRouterMap().keys());
+}

plugin/core/rule-store.ts

@@ -0,0 +1,56 @@
+import { readFileSync, writeFileSync } from "node:fs";
+
+export type RuleStore = Record<string, string>; // "router:key" → prompt file path
+
+const _G = globalThis as Record<string, unknown>;
+const RULES_KEY = "_prismFacetRules";
+const RULES_PATH_KEY = "_prismFacetRulesPath";
+
+function getRules(): RuleStore {
+  if (!_G[RULES_KEY] || typeof _G[RULES_KEY] !== "object") {
+    _G[RULES_KEY] = {};
+  }
+  return _G[RULES_KEY] as RuleStore;
+}
+
+function getRulesPath(): string {
+  return (_G[RULES_PATH_KEY] as string) || "";
+}
+
+function save(): void {
+  const p = getRulesPath();
+  if (!p) return;
+  writeFileSync(p, JSON.stringify(getRules(), null, 2) + "\n", "utf8");
+}
+
+export function initRuleStore(filePath: string): void {
+  _G[RULES_PATH_KEY] = filePath;
+  try {
+    const raw = readFileSync(filePath, "utf8");
+    _G[RULES_KEY] = JSON.parse(raw) as RuleStore;
+  } catch {
+    _G[RULES_KEY] = {};
+  }
+}
+
+export function addRule(router: string, key: string, promptFile: string): void {
+  getRules()[`${router}:${key}`] = promptFile;
+  save();
+}
+
+export function removeRule(router: string, key: string): boolean {
+  const rules = getRules();
+  const ruleKey = `${router}:${key}`;
+  if (!(ruleKey in rules)) return false;
+  delete rules[ruleKey];
+  save();
+  return true;
+}
+
+export function getRule(router: string, key: string): string | undefined {
+  return getRules()[`${router}:${key}`];
+}
+
+export function listRules(): Record<string, string> {
+  return { ...getRules() };
+}