@rolexjs/core 1.5.0-dev-20260310044915 → 1.5.0-dev-20260312083443

package/dist/index.js

@@ -683,13 +683,13 @@ function findInState(state, target) {
 }
 function createHelpers(ctx) {
   const { rt, project: project2, resourcex, issuex } = ctx;
-  async function ok(node, process8) {
+  async function ok2(node, process8) {
     return { state: await project2(node), process: process8 };
   }
   async function archive2(node, process8) {
     const target = structure2(node.name, node.description ?? "", past);
     const archived = await rt.transform(node, target);
-    return ok(archived, process8);
+    return ok2(archived, process8);
   }
   function validateGherkin(source) {
     if (!source) return;
@@ -712,7 +712,7 @@ function createHelpers(ctx) {
     if (!issuex) throw new Error("IssueX is not available.");
     return issuex;
   }
-  return { ok, archive: archive2, validateGherkin, removeExisting, requireResourceX, requireIssueX };
+  return { ok: ok2, archive: archive2, validateGherkin, removeExisting, requireResourceX, requireIssueX };
 }
 
 // src/commands/issue.ts
@@ -800,30 +800,30 @@ function issueCommands(_ctx, helpers) {
 // src/commands/position.ts
 function positionCommands(ctx, helpers) {
   const { rt, resolve } = ctx;
-  const { ok, validateGherkin, removeExisting } = helpers;
+  const { ok: ok2, validateGherkin, removeExisting } = helpers;
   return {
     async "position.charge"(position2, duty2, id) {
       validateGherkin(duty2);
       const node = await rt.create(await resolve(position2), duty, duty2, id);
-      return ok(node, "charge");
+      return ok2(node, "charge");
     },
     async "position.require"(position2, procedure2, id) {
       validateGherkin(procedure2);
       const parent = await resolve(position2);
       if (id) await removeExisting(parent, id);
       const node = await rt.create(parent, requirement, procedure2, id);
-      return ok(node, "require");
+      return ok2(node, "require");
     },
     async "position.appoint"(position2, individual2) {
       const posNode = await resolve(position2);
       const indNode = await resolve(individual2);
       await rt.link(posNode, indNode, "appointment", "serve");
-      return ok(posNode, "appoint");
+      return ok2(posNode, "appoint");
     },
     async "position.dismiss"(position2, individual2) {
       const posNode = await resolve(position2);
       await rt.unlink(posNode, await resolve(individual2), "appointment", "serve");
-      return ok(posNode, "dismiss");
+      return ok2(posNode, "dismiss");
     }
   };
 }
@@ -831,37 +831,37 @@ function positionCommands(ctx, helpers) {
 // src/commands/product.ts
 function productCommands(ctx, helpers) {
   const { rt, resolve } = ctx;
-  const { ok, archive: archive2, validateGherkin } = helpers;
+  const { ok: ok2, archive: archive2, validateGherkin } = helpers;
   return {
     async "product.strategy"(product2, strategy2, id) {
       validateGherkin(strategy2);
       const node = await rt.create(await resolve(product2), strategy, strategy2, id);
-      return ok(node, "strategy");
+      return ok2(node, "strategy");
     },
     async "product.spec"(product2, spec2, id) {
       validateGherkin(spec2);
       const node = await rt.create(await resolve(product2), spec, spec2, id);
-      return ok(node, "spec");
+      return ok2(node, "spec");
     },
     async "product.release"(product2, release2, id) {
       validateGherkin(release2);
       const node = await rt.create(await resolve(product2), release, release2, id);
-      return ok(node, "release");
+      return ok2(node, "release");
     },
     async "product.channel"(product2, channel2, id) {
       validateGherkin(channel2);
       const node = await rt.create(await resolve(product2), channel, channel2, id);
-      return ok(node, "channel");
+      return ok2(node, "channel");
     },
     async "product.own"(product2, individual2) {
       const prodNode = await resolve(product2);
       await rt.link(prodNode, await resolve(individual2), "ownership", "own");
-      return ok(prodNode, "own");
+      return ok2(prodNode, "own");
     },
     async "product.disown"(product2, individual2) {
       const prodNode = await resolve(product2);
       await rt.unlink(prodNode, await resolve(individual2), "ownership", "own");
-      return ok(prodNode, "disown");
+      return ok2(prodNode, "disown");
     },
     async "product.deprecate"(product2) {
       return archive2(await resolve(product2), "deprecate");
@@ -872,42 +872,42 @@ function productCommands(ctx, helpers) {
 // src/commands/project.ts
 function projectCommands(ctx, helpers) {
   const { rt, society: society2, resolve } = ctx;
-  const { ok, validateGherkin } = helpers;
+  const { ok: ok2, validateGherkin } = helpers;
   return {
     async "project.scope"(project2, scope2, id) {
       validateGherkin(scope2);
       const node = await rt.create(await resolve(project2), scope, scope2, id);
-      return ok(node, "scope");
+      return ok2(node, "scope");
     },
     async "project.milestone"(project2, milestone2, id) {
       validateGherkin(milestone2);
       const node = await rt.create(await resolve(project2), milestone, milestone2, id);
-      return ok(node, "milestone");
+      return ok2(node, "milestone");
     },
     async "project.achieve"(milestone2) {
       const node = await resolve(milestone2);
       await rt.tag(node, "done");
-      return ok(node, "achieve");
+      return ok2(node, "achieve");
     },
     async "project.enroll"(project2, individual2) {
       const projNode = await resolve(project2);
       await rt.link(projNode, await resolve(individual2), "participation", "participate");
-      return ok(projNode, "enroll");
+      return ok2(projNode, "enroll");
     },
     async "project.remove"(project2, individual2) {
       const projNode = await resolve(project2);
       await rt.unlink(projNode, await resolve(individual2), "participation", "participate");
-      return ok(projNode, "remove");
+      return ok2(projNode, "remove");
     },
     async "project.deliver"(project2, deliverable2, id) {
       validateGherkin(deliverable2);
       const node = await rt.create(await resolve(project2), deliverable, deliverable2, id);
-      return ok(node, "deliver");
+      return ok2(node, "deliver");
     },
     async "project.wiki"(project2, wiki2, id) {
       validateGherkin(wiki2);
       const node = await rt.create(await resolve(project2), wiki, wiki2, id);
-      return ok(node, "wiki");
+      return ok2(node, "wiki");
     },
     async "project.produce"(project2, content, id, alias, owner) {
       validateGherkin(content);
@@ -916,17 +916,17 @@ function projectCommands(ctx, helpers) {
       await rt.link(projNode, node, "production", "produce");
       await rt.link(node, projNode, "origin", "produced-by");
       if (owner) await rt.link(node, await resolve(owner), "ownership", "own");
-      return ok(node, "produce");
+      return ok2(node, "produce");
     },
     async "project.maintain"(project2, individual2) {
       const projNode = await resolve(project2);
       await rt.link(projNode, await resolve(individual2), "maintain", "maintained-by");
-      return ok(projNode, "maintain");
+      return ok2(projNode, "maintain");
     },
     async "project.unmaintain"(project2, individual2) {
       const projNode = await resolve(project2);
       await rt.unlink(projNode, await resolve(individual2), "maintain", "maintained-by");
-      return ok(projNode, "unmaintain");
+      return ok2(projNode, "unmaintain");
     }
   };
 }
@@ -993,29 +993,29 @@ function renderFileTree(files, indent = "") {
 }
 function roleCommands(ctx, helpers) {
   const { rt, resolve } = ctx;
-  const { ok, validateGherkin, removeExisting, requireResourceX } = helpers;
+  const { ok: ok2, validateGherkin, removeExisting, requireResourceX } = helpers;
   return {
     // ---- Role: focus ----
     async "role.focus"(goal2) {
-      return ok(await resolve(goal2), "focus");
+      return ok2(await resolve(goal2), "focus");
     },
     // ---- Role: execution ----
     async "role.want"(individual2, goal2, id, alias) {
       validateGherkin(goal2);
       const node = await rt.create(await resolve(individual2), goal, goal2, id, alias);
-      return ok(node, "want");
+      return ok2(node, "want");
     },
     async "role.plan"(goal2, plan2, id, after, fallback) {
       validateGherkin(plan2);
       const node = await rt.create(await resolve(goal2), plan, plan2, id);
       if (after) await rt.link(node, await resolve(after), "after", "before");
       if (fallback) await rt.link(node, await resolve(fallback), "fallback-for", "fallback");
-      return ok(node, "plan");
+      return ok2(node, "plan");
     },
     async "role.todo"(plan2, task2, id, alias) {
       validateGherkin(task2);
       const node = await rt.create(await resolve(plan2), task, task2, id, alias);
-      return ok(node, "todo");
+      return ok2(node, "todo");
     },
     async "role.finish"(task2, individual2, encounter2) {
       validateGherkin(encounter2);
@@ -1024,9 +1024,9 @@ function roleCommands(ctx, helpers) {
       if (encounter2) {
         const encId = taskNode.id ? `${taskNode.id}-finished` : void 0;
         const enc = await rt.create(await resolve(individual2), encounter, encounter2, encId);
-        return ok(enc, "finish");
+        return ok2(enc, "finish");
       }
-      return ok(taskNode, "finish");
+      return ok2(taskNode, "finish");
     },
     async "role.complete"(plan2, individual2, encounter2) {
       validateGherkin(encounter2);
@@ -1034,7 +1034,7 @@ function roleCommands(ctx, helpers) {
       await rt.tag(planNode, "done");
       const encId = planNode.id ? `${planNode.id}-completed` : void 0;
       const enc = await rt.create(await resolve(individual2), encounter, encounter2, encId);
-      return ok(enc, "complete");
+      return ok2(enc, "complete");
     },
     async "role.abandon"(plan2, individual2, encounter2) {
       validateGherkin(encounter2);
@@ -1042,7 +1042,7 @@ function roleCommands(ctx, helpers) {
       await rt.tag(planNode, "abandoned");
       const encId = planNode.id ? `${planNode.id}-abandoned` : void 0;
       const enc = await rt.create(await resolve(individual2), encounter, encounter2, encId);
-      return ok(enc, "abandon");
+      return ok2(enc, "abandon");
     },
     // ---- Role: cognition ----
     async "role.reflect"(encounter2, individual2, experience2, id) {
@@ -1056,10 +1056,10 @@ function roleCommands(ctx, helpers) {
           id
         );
         await rt.remove(encNode);
-        return ok(exp2, "reflect");
+        return ok2(exp2, "reflect");
       }
       const exp = await rt.create(await resolve(individual2), experience, experience2, id);
-      return ok(exp, "reflect");
+      return ok2(exp, "reflect");
     },
     async "role.realize"(experience2, individual2, principle2, id) {
       validateGherkin(principle2);
@@ -1072,10 +1072,10 @@ function roleCommands(ctx, helpers) {
           id
         );
         await rt.remove(expNode);
-        return ok(prin2, "realize");
+        return ok2(prin2, "realize");
       }
       const prin = await rt.create(await resolve(individual2), principle, principle2, id);
-      return ok(prin, "realize");
+      return ok2(prin, "realize");
     },
     async "role.master"(individual2, procedure2, id, experience2) {
       validateGherkin(procedure2);
@@ -1083,7 +1083,7 @@ function roleCommands(ctx, helpers) {
       if (id) await removeExisting(parent, id);
       const proc = await rt.create(parent, procedure, procedure2, id);
       if (experience2) await rt.remove(await resolve(experience2));
-      return ok(proc, "master");
+      return ok2(proc, "master");
     },
     // ---- Role: knowledge management ----
     async "role.forget"(nodeId) {
@@ -1111,14 +1111,14 @@ ${text}`;
 // src/commands/society.ts
 function societyCommands(ctx, helpers) {
   const { rt, society: society2, resolve } = ctx;
-  const { ok, archive: archive2, validateGherkin, removeExisting } = helpers;
+  const { ok: ok2, archive: archive2, validateGherkin, removeExisting } = helpers;
   return {
     // ---- Society: individual lifecycle ----
     async "society.born"(content, id, alias) {
       validateGherkin(content);
       const node = await rt.create(society2, individual, content, id, alias);
       await rt.create(node, identity, void 0, `${id}-identity`);
-      return ok(node, "born");
+      return ok2(node, "born");
     },
     async "society.retire"(individual2) {
       return archive2(await resolve(individual2), "retire");
@@ -1129,7 +1129,7 @@ function societyCommands(ctx, helpers) {
     async "society.rehire"(pastNode) {
       const node = await resolve(pastNode);
       const ind = await rt.transform(node, individual);
-      return ok(ind, "rehire");
+      return ok2(ind, "rehire");
     },
     // ---- Society: external injection ----
     async "society.teach"(individual2, principle2, id) {
@@ -1137,21 +1137,21 @@ function societyCommands(ctx, helpers) {
       const parent = await resolve(individual2);
       if (id) await removeExisting(parent, id);
       const node = await rt.create(parent, principle, principle2, id);
-      return ok(node, "teach");
+      return ok2(node, "teach");
     },
     async "society.train"(individual2, procedure2, id) {
       validateGherkin(procedure2);
       const parent = await resolve(individual2);
       if (id) await removeExisting(parent, id);
       const node = await rt.create(parent, procedure, procedure2, id);
-      return ok(node, "train");
+      return ok2(node, "train");
     },
     // ---- Society: organization lifecycle ----
     async "society.found"(content, id, alias, admin) {
       validateGherkin(content);
       const node = await rt.create(society2, organization, content, id, alias);
       if (admin) await rt.link(node, await resolve(admin), "admin", "administer");
-      return ok(node, "found");
+      return ok2(node, "found");
     },
     async "society.dissolve"(org) {
       return archive2(await resolve(org), "dissolve");
@@ -1160,38 +1160,38 @@ function societyCommands(ctx, helpers) {
     async "society.crown"(individual2) {
       const indNode = await resolve(individual2);
       await rt.link(society2, indNode, "crown", "crowned");
-      return ok(indNode, "crown");
+      return ok2(indNode, "crown");
     },
     async "society.uncrown"(individual2) {
       const indNode = await resolve(individual2);
       await rt.unlink(society2, indNode, "crown", "crowned");
-      return ok(indNode, "uncrown");
+      return ok2(indNode, "uncrown");
     },
     // ---- Org ----
     async "org.charter"(org, charter2, id) {
       validateGherkin(charter2);
       const node = await rt.create(await resolve(org), charter, charter2, id);
-      return ok(node, "charter");
+      return ok2(node, "charter");
     },
     async "org.hire"(org, individual2) {
       const orgNode = await resolve(org);
       await rt.link(orgNode, await resolve(individual2), "membership", "belong");
-      return ok(orgNode, "hire");
+      return ok2(orgNode, "hire");
     },
     async "org.fire"(org, individual2) {
       const orgNode = await resolve(org);
       await rt.unlink(orgNode, await resolve(individual2), "membership", "belong");
-      return ok(orgNode, "fire");
+      return ok2(orgNode, "fire");
     },
     async "org.admin"(org, individual2) {
       const orgNode = await resolve(org);
       await rt.link(orgNode, await resolve(individual2), "admin", "administer");
-      return ok(orgNode, "admin");
+      return ok2(orgNode, "admin");
     },
     async "org.unadmin"(org, individual2) {
       const orgNode = await resolve(org);
       await rt.unlink(orgNode, await resolve(individual2), "admin", "administer");
-      return ok(orgNode, "unadmin");
+      return ok2(orgNode, "unadmin");
     },
     // ---- Org: project lifecycle ----
     async "org.launch"(content, id, alias, org, maintainer) {
@@ -1199,7 +1199,7 @@ function societyCommands(ctx, helpers) {
       const node = await rt.create(society2, project, content, id, alias);
       if (org) await rt.link(node, await resolve(org), "ownership", "project");
       if (maintainer) await rt.link(node, await resolve(maintainer), "maintain", "maintained-by");
-      return ok(node, "launch");
+      return ok2(node, "launch");
     },
     async "org.archive"(project2) {
       return archive2(await resolve(project2), "archive");
@@ -1208,7 +1208,7 @@ function societyCommands(ctx, helpers) {
     async "org.establish"(content, id, alias) {
       validateGherkin(content);
       const node = await rt.create(society2, position, content, id, alias);
-      return ok(node, "establish");
+      return ok2(node, "establish");
     },
     async "org.abolish"(position2) {
       return archive2(await resolve(position2), "abolish");
@@ -2996,13 +2996,17 @@ var RoleXService = class _RoleXService {
   past;
   /** Cached Role instances — one per individual. */
   roles = /* @__PURE__ */ new Map();
+  /** Expose commands for the RPC handler. */
+  get commandMap() {
+    return this.commands;
+  }
   /** Permission registry — maps relation names to permissions. */
   permissions = new PermissionRegistry().register("crowned", sovereignPermissions).register("administer", orgAdminPermissions).register("maintained-by", projectMaintainerPermissions).register("own", productOwnerPermissions);
-  constructor(platform, renderer) {
+  constructor(platform, renderer, prototypes) {
     this.repo = platform.repository;
     this.rt = this.repo.runtime;
     this.initializer = platform.initializer;
-    this.prototypes = platform.prototypes ?? [];
+    this.prototypes = prototypes ?? [];
     this.renderer = renderer;
     if (platform.resourcexProvider) {
       setProvider(platform.resourcexProvider);
@@ -3014,8 +3018,8 @@ var RoleXService = class _RoleXService {
       this.issuex = createIssueX({ provider: platform.issuexProvider });
     }
   }
-  static async create(platform, renderer) {
-    const service = new _RoleXService(platform, renderer);
+  static async create(platform, renderer, prototypes) {
+    const service = new _RoleXService(platform, renderer, prototypes);
     await service.init();
     return service;
   }
@@ -3171,45 +3175,167 @@ function isCommandResult(value) {
   return typeof value === "object" && value !== null && "state" in value && "process" in value;
 }
 
-// src/renderer.ts
-var RendererRouter = class {
-  renderers = /* @__PURE__ */ new Map();
-  /** Register a renderer for a command namespace. */
-  register(namespace, renderer) {
-    this.renderers.set(namespace, renderer);
-    return this;
+// src/rpc.ts
+var RPC_METHOD_NOT_FOUND = -32601;
+var RPC_INTERNAL_ERROR = -32603;
+var RpcHandler = class {
+  commands;
+  methods;
+  constructor(deps) {
+    this.commands = deps.commands;
+    this.methods = deps.methods ?? {};
   }
-  /** Route a command to the appropriate renderer. */
-  render(command, result) {
-    const dot = command.indexOf(".");
-    const namespace = dot >= 0 ? command.slice(0, dot) : command;
-    const renderer = this.renderers.get(namespace);
-    if (renderer) return renderer.render(command, result);
-    return defaultRender(command, result);
+  async handle(request) {
+    const { method, params = {}, id = null } = request;
+    try {
+      const custom = this.methods[method];
+      if (custom) {
+        const result2 = await custom(params);
+        return ok(id, result2);
+      }
+      const fn = this.commands[method];
+      if (!fn) {
+        return error(id, RPC_METHOD_NOT_FOUND, `Unknown method "${method}".`);
+      }
+      const positionalArgs = toArgs(method, params);
+      const result = await fn(...positionalArgs);
+      return ok(id, result);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return error(id, RPC_INTERNAL_ERROR, message);
+    }
   }
 };
-function defaultRender(_command, result) {
-  return JSON.stringify(result, null, 2);
+function ok(id, result) {
+  return { jsonrpc: "2.0", id, result };
+}
+function error(id, code, message, data) {
+  return { jsonrpc: "2.0", id, error: { code, message, data } };
+}
+
+// src/namespaces.ts
+function createSocietyNamespace(call) {
+  return {
+    born: (p5) => call("society.born", p5),
+    retire: (p5) => call("society.retire", p5),
+    die: (p5) => call("society.die", p5),
+    rehire: (p5) => call("society.rehire", p5),
+    teach: (p5) => call("society.teach", p5),
+    train: (p5) => call("society.train", p5),
+    found: (p5) => call("society.found", p5),
+    dissolve: (p5) => call("society.dissolve", p5),
+    crown: (p5) => call("society.crown", p5),
+    uncrown: (p5) => call("society.uncrown", p5)
+  };
+}
+function createRoleNamespace(call) {
+  return {
+    activate: (p5) => call("role.activate", p5),
+    inspect: (p5) => call("inspect", p5),
+    survey: (p5) => call("survey", p5)
+  };
+}
+function createOrgNamespace(call) {
+  return {
+    charter: (p5) => call("org.charter", p5),
+    hire: (p5) => call("org.hire", p5),
+    fire: (p5) => call("org.fire", p5),
+    admin: (p5) => call("org.admin", p5),
+    unadmin: (p5) => call("org.unadmin", p5),
+    launch: (p5) => call("org.launch", p5),
+    archive: (p5) => call("org.archive", p5),
+    establish: (p5) => call("org.establish", p5),
+    abolish: (p5) => call("org.abolish", p5)
+  };
+}
+function createPositionNamespace(call) {
+  return {
+    charge: (p5) => call("position.charge", p5),
+    require: (p5) => call("position.require", p5),
+    appoint: (p5) => call("position.appoint", p5),
+    dismiss: (p5) => call("position.dismiss", p5)
+  };
+}
+function createProjectNamespace(call) {
+  return {
+    scope: (p5) => call("project.scope", p5),
+    milestone: (p5) => call("project.milestone", p5),
+    achieve: (p5) => call("project.achieve", p5),
+    enroll: (p5) => call("project.enroll", p5),
+    remove: (p5) => call("project.remove", p5),
+    deliver: (p5) => call("project.deliver", p5),
+    wiki: (p5) => call("project.wiki", p5),
+    produce: (p5) => call("project.produce", p5),
+    maintain: (p5) => call("project.maintain", p5),
+    unmaintain: (p5) => call("project.unmaintain", p5)
+  };
+}
+function createProductNamespace(call) {
+  return {
+    strategy: (p5) => call("product.strategy", p5),
+    spec: (p5) => call("product.spec", p5),
+    release: (p5) => call("product.release", p5),
+    channel: (p5) => call("product.channel", p5),
+    own: (p5) => call("product.own", p5),
+    disown: (p5) => call("product.disown", p5),
+    deprecate: (p5) => call("product.deprecate", p5)
+  };
+}
+function createCensusNamespace(call) {
+  return {
+    list: (p5) => call("census.list", p5)
+  };
+}
+function createIssueNamespace(call) {
+  return {
+    publish: (p5) => call("issue.publish", p5),
+    get: (p5) => call("issue.get", p5),
+    list: (p5) => call("issue.list", p5),
+    update: (p5) => call("issue.update", p5),
+    close: (p5) => call("issue.close", p5),
+    reopen: (p5) => call("issue.reopen", p5),
+    assign: (p5) => call("issue.assign", p5),
+    comment: (p5) => call("issue.comment", p5),
+    comments: (p5) => call("issue.comments", p5),
+    label: (p5) => call("issue.label", p5),
+    unlabel: (p5) => call("issue.unlabel", p5)
+  };
+}
+function createResourceNamespace(call) {
+  return {
+    add: (p5) => call("resource.add", p5),
+    search: (p5) => call("resource.search", p5),
+    has: (p5) => call("resource.has", p5),
+    info: (p5) => call("resource.info", p5),
+    remove: (p5) => call("resource.remove", p5),
+    push: (p5) => call("resource.push", p5),
+    pull: (p5) => call("resource.pull", p5),
+    clearCache: (p5) => call("resource.clearCache", p5)
+  };
 }
 
 // src/tools.ts
 var worldInstructions = Object.values(world).join("\n\n");
+var d = (name) => processes[name] ?? "";
 var tools = [
   // --- Top-level perception ---
   {
     name: "activate",
+    description: d("activate"),
     params: {
       roleId: { type: "string", required: true, description: "Role name to activate" }
     }
   },
   {
     name: "inspect",
+    description: d("inspect"),
     params: {
       id: { type: "string", required: true, description: "Node id to inspect (any node type)" }
     }
   },
   {
     name: "survey",
+    description: d("survey"),
     params: {
       type: {
         type: "string",
@@ -3220,6 +3346,7 @@ var tools = [
   },
   {
     name: "focus",
+    description: d("focus"),
     params: {
       id: {
         type: "string",
@@ -3231,6 +3358,7 @@ var tools = [
   // --- Execution ---
   {
     name: "want",
+    description: d("want"),
     params: {
       id: { type: "string", required: true, description: "Goal id (used for focus/reference)" },
       goal: {
@@ -3242,6 +3370,7 @@ var tools = [
   },
   {
     name: "plan",
+    description: d("plan"),
     params: {
       id: {
         type: "string",
@@ -3267,6 +3396,7 @@ var tools = [
   },
   {
     name: "todo",
+    description: d("todo"),
     params: {
       id: { type: "string", required: true, description: "Task id (used for finish/reference)" },
       task: {
@@ -3278,6 +3408,7 @@ var tools = [
   },
   {
     name: "finish",
+    description: d("finish"),
     params: {
       id: { type: "string", required: true, description: "Task id to finish" },
       encounter: {
@@ -3289,6 +3420,7 @@ var tools = [
   },
   {
     name: "complete",
+    description: d("complete"),
     params: {
       id: {
         type: "string",
@@ -3304,6 +3436,7 @@ var tools = [
   },
   {
     name: "abandon",
+    description: d("abandon"),
     params: {
       id: {
         type: "string",
@@ -3320,6 +3453,7 @@ var tools = [
   // --- Cognition ---
   {
     name: "reflect",
+    description: d("reflect"),
     params: {
       ids: {
         type: "string[]",
@@ -3340,6 +3474,7 @@ var tools = [
   },
   {
     name: "realize",
+    description: d("realize"),
     params: {
       ids: {
         type: "string[]",
@@ -3360,6 +3495,7 @@ var tools = [
   },
   {
     name: "master",
+    description: d("master"),
     params: {
       ids: {
         type: "string[]",
@@ -3381,6 +3517,7 @@ var tools = [
   // --- Knowledge ---
   {
     name: "forget",
+    description: d("forget"),
     params: {
       id: {
         type: "string",
@@ -3391,6 +3528,7 @@ var tools = [
   },
   {
     name: "skill",
+    description: d("skill"),
     params: {
       locator: {
         type: "string",
@@ -3402,6 +3540,7 @@ var tools = [
   // --- Use / Direct ---
   {
     name: "use",
+    description: d("use"),
     params: {
       command: {
         type: "string",
@@ -3417,6 +3556,7 @@ var tools = [
   },
   {
     name: "direct",
+    description: d("direct"),
     params: {
       command: {
         type: "string",
@@ -3432,10 +3572,124 @@ var tools = [
   }
 ];
 var protocol = { tools, instructions: worldInstructions };
+
+// src/builder.ts
+function createBuilder(config) {
+  let initPromise = null;
+  function ensureInit() {
+    if (!initPromise) {
+      initPromise = (async () => {
+        const service = await RoleXService.create(
+          config.platform,
+          config.renderer,
+          config.prototypes
+        );
+        const handler = new RpcHandler({
+          commands: service.commandMap,
+          methods: {
+            "role.activate": async (params) => {
+              return service.activate(params.individual);
+            },
+            inspect: async (params) => {
+              return service.inspect(params.id);
+            },
+            survey: async (params) => {
+              return service.survey(params.type);
+            }
+          }
+        });
+        return { handler, service };
+      })();
+    }
+    return initPromise;
+  }
+  const call = async (method, params) => {
+    const { handler } = await ensureInit();
+    const response = await handler.handle({
+      jsonrpc: "2.0",
+      method,
+      params,
+      id: null
+    });
+    if (response.error) {
+      throw new Error(response.error.message);
+    }
+    return response.result;
+  };
+  const _society = createSocietyNamespace(call);
+  const _role = createRoleNamespace(call);
+  const _org = createOrgNamespace(call);
+  const _position = createPositionNamespace(call);
+  const _project = createProjectNamespace(call);
+  const _product = createProductNamespace(call);
+  const _census = createCensusNamespace(call);
+  const _issue = createIssueNamespace(call);
+  const _resource = createResourceNamespace(call);
+  return {
+    get society() {
+      return _society;
+    },
+    get role() {
+      return _role;
+    },
+    get org() {
+      return _org;
+    },
+    get position() {
+      return _position;
+    },
+    get project() {
+      return _project;
+    },
+    get product() {
+      return _product;
+    },
+    get census() {
+      return _census;
+    },
+    get issue() {
+      return _issue;
+    },
+    get resource() {
+      return _resource;
+    },
+    protocol,
+    async rpc(request) {
+      const { handler } = await ensureInit();
+      return handler.handle(request);
+    },
+    async _internal() {
+      const { service } = await ensureInit();
+      return { service };
+    }
+  };
+}
+
+// src/renderer.ts
+var RendererRouter = class {
+  renderers = /* @__PURE__ */ new Map();
+  /** Register a renderer for a command namespace. */
+  register(namespace, renderer) {
+    this.renderers.set(namespace, renderer);
+    return this;
+  }
+  /** Route a command to the appropriate renderer. */
+  render(command, result) {
+    const dot = command.indexOf(".");
+    const namespace = dot >= 0 ? command.slice(0, dot) : command;
+    const renderer = this.renderers.get(namespace);
+    if (renderer) return renderer.render(command, result);
+    return defaultRender(command, result);
+  }
+};
+function defaultRender(_command, result) {
+  return JSON.stringify(result, null, 2);
+}
 export {
   RendererRouter,
   Role,
   RoleXService,
+  RpcHandler,
   abandon,
   abolish,
   activate,
@@ -3451,6 +3705,7 @@ export {
   charterOrg,
   complete,
   create6 as create,
+  createBuilder,
   createCommands,
   createRuntime,
   deliverProject,