@rolexjs/prototype 1.4.0 → 1.6.0

package/dist/index.js

@@ -1,466 +1,3 @@
-// src/apply.ts
-async function applyPrototype(data, repo, direct) {
-  const sorted = [...data.migrations].sort((a, b) => a.version - b.version);
-  let applied = 0;
-  let skipped = 0;
-  for (const migration of sorted) {
-    if (await repo.hasMigration(data.id, migration.id)) {
-      skipped++;
-      continue;
-    }
-    for (const instr of migration.instructions) {
-      await direct(instr.op, instr.args);
-    }
-    await repo.recordMigration(data.id, migration.id, migration.version, migration.checksum);
-    applied++;
-  }
-  await repo.settle(data.id, data.source);
-  return {
-    prototypeId: data.id,
-    applied,
-    skipped,
-    upToDate: applied === 0
-  };
-}
-
-// src/commands.ts
-import * as C from "@rolexjs/core";
-import { parse } from "@rolexjs/parser";
-import { structure } from "@rolexjs/system";
-function createCommands(ctx) {
-  const { rt, society, past: past2, resolve, resourcex, issuex } = ctx;
-  async function ok(node, process) {
-    return { state: await rt.project(node), process };
-  }
-  async function archive(node, process) {
-    const target = structure(node.name, node.description ?? "", C.past);
-    const archived = await rt.transform(node, target);
-    return ok(archived, process);
-  }
-  function validateGherkin(source) {
-    if (!source) return;
-    try {
-      parse(source);
-    } catch (e) {
-      throw new Error(`Invalid Gherkin: ${e.message}`);
-    }
-  }
-  function findInState(state, target) {
-    if (state.id && state.id.toLowerCase() === target) return state;
-    if (state.alias) {
-      for (const a of state.alias) {
-        if (a.toLowerCase() === target) return state;
-      }
-    }
-    for (const child of state.children ?? []) {
-      const found = findInState(child, target);
-      if (found) return found;
-    }
-    return null;
-  }
-  async function removeExisting(parent, id) {
-    const state = await rt.project(parent);
-    const existing = findInState(state, id);
-    if (existing) await rt.remove(existing);
-  }
-  function requireResourceX() {
-    if (!resourcex) throw new Error("ResourceX is not available.");
-    return resourcex;
-  }
-  function requireIssueX() {
-    if (!issuex) throw new Error("IssueX is not available.");
-    return issuex;
-  }
-  return {
-    // ---- Individual: lifecycle ----
-    async "individual.born"(content, id, alias) {
-      validateGherkin(content);
-      const node = await rt.create(society, C.individual, content, id, alias);
-      await rt.create(node, C.identity, void 0, `${id}-identity`);
-      return ok(node, "born");
-    },
-    async "individual.retire"(individual2) {
-      return archive(await resolve(individual2), "retire");
-    },
-    async "individual.die"(individual2) {
-      return archive(await resolve(individual2), "die");
-    },
-    async "individual.rehire"(pastNode) {
-      const node = await resolve(pastNode);
-      const ind = await rt.transform(node, C.individual);
-      return ok(ind, "rehire");
-    },
-    // ---- Individual: external injection ----
-    async "individual.teach"(individual2, principle2, id) {
-      validateGherkin(principle2);
-      const parent = await resolve(individual2);
-      if (id) await removeExisting(parent, id);
-      const node = await rt.create(parent, C.principle, principle2, id);
-      return ok(node, "teach");
-    },
-    async "individual.train"(individual2, procedure2, id) {
-      validateGherkin(procedure2);
-      const parent = await resolve(individual2);
-      if (id) await removeExisting(parent, id);
-      const node = await rt.create(parent, C.procedure, procedure2, id);
-      return ok(node, "train");
-    },
-    // ---- Role: focus ----
-    async "role.focus"(goal2) {
-      return ok(await resolve(goal2), "focus");
-    },
-    // ---- Role: execution ----
-    async "role.want"(individual2, goal2, id, alias) {
-      validateGherkin(goal2);
-      const node = await rt.create(await resolve(individual2), C.goal, goal2, id, alias);
-      return ok(node, "want");
-    },
-    async "role.plan"(goal2, plan2, id, after, fallback) {
-      validateGherkin(plan2);
-      const node = await rt.create(await resolve(goal2), C.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");
-    },
-    async "role.todo"(plan2, task2, id, alias) {
-      validateGherkin(task2);
-      const node = await rt.create(await resolve(plan2), C.task, task2, id, alias);
-      return ok(node, "todo");
-    },
-    async "role.finish"(task2, individual2, encounter2) {
-      validateGherkin(encounter2);
-      const taskNode = await resolve(task2);
-      await rt.tag(taskNode, "done");
-      if (encounter2) {
-        const encId = taskNode.id ? `${taskNode.id}-finished` : void 0;
-        const enc = await rt.create(await resolve(individual2), C.encounter, encounter2, encId);
-        return ok(enc, "finish");
-      }
-      return ok(taskNode, "finish");
-    },
-    async "role.complete"(plan2, individual2, encounter2) {
-      validateGherkin(encounter2);
-      const planNode = await resolve(plan2);
-      await rt.tag(planNode, "done");
-      const encId = planNode.id ? `${planNode.id}-completed` : void 0;
-      const enc = await rt.create(await resolve(individual2), C.encounter, encounter2, encId);
-      return ok(enc, "complete");
-    },
-    async "role.abandon"(plan2, individual2, encounter2) {
-      validateGherkin(encounter2);
-      const planNode = await resolve(plan2);
-      await rt.tag(planNode, "abandoned");
-      const encId = planNode.id ? `${planNode.id}-abandoned` : void 0;
-      const enc = await rt.create(await resolve(individual2), C.encounter, encounter2, encId);
-      return ok(enc, "abandon");
-    },
-    // ---- Role: cognition ----
-    async "role.reflect"(encounter2, individual2, experience2, id) {
-      validateGherkin(experience2);
-      if (encounter2) {
-        const encNode = await resolve(encounter2);
-        const exp2 = await rt.create(
-          await resolve(individual2),
-          C.experience,
-          experience2 || encNode.information,
-          id
-        );
-        await rt.remove(encNode);
-        return ok(exp2, "reflect");
-      }
-      const exp = await rt.create(await resolve(individual2), C.experience, experience2, id);
-      return ok(exp, "reflect");
-    },
-    async "role.realize"(experience2, individual2, principle2, id) {
-      validateGherkin(principle2);
-      if (experience2) {
-        const expNode = await resolve(experience2);
-        const prin2 = await rt.create(
-          await resolve(individual2),
-          C.principle,
-          principle2 || expNode.information,
-          id
-        );
-        await rt.remove(expNode);
-        return ok(prin2, "realize");
-      }
-      const prin = await rt.create(await resolve(individual2), C.principle, principle2, id);
-      return ok(prin, "realize");
-    },
-    async "role.master"(individual2, procedure2, id, experience2) {
-      validateGherkin(procedure2);
-      const parent = await resolve(individual2);
-      if (id) await removeExisting(parent, id);
-      const proc = await rt.create(parent, C.procedure, procedure2, id);
-      if (experience2) await rt.remove(await resolve(experience2));
-      return ok(proc, "master");
-    },
-    // ---- Role: knowledge management ----
-    async "role.forget"(nodeId) {
-      const node = await resolve(nodeId);
-      await rt.remove(node);
-      return { state: { ...node, children: [] }, process: "forget" };
-    },
-    // ---- Role: skill ----
-    async "role.skill"(locator) {
-      const rx = requireResourceX();
-      const content = await rx.ingest(locator);
-      const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
-      try {
-        const rxm = await rx.info(locator);
-        return `${formatRXM(rxm)}
-
-${text}`;
-      } catch {
-        return text;
-      }
-    },
-    // ---- Project ----
-    async "project.launch"(content, id, alias, org) {
-      validateGherkin(content);
-      const node = await rt.create(society, C.project, content, id, alias);
-      if (org) await rt.link(node, await resolve(org), "ownership", "project");
-      return ok(node, "launch");
-    },
-    async "project.scope"(project2, scope2, id) {
-      validateGherkin(scope2);
-      const node = await rt.create(await resolve(project2), C.scope, scope2, id);
-      return ok(node, "scope");
-    },
-    async "project.milestone"(project2, milestone2, id) {
-      validateGherkin(milestone2);
-      const node = await rt.create(await resolve(project2), C.milestone, milestone2, id);
-      return ok(node, "milestone");
-    },
-    async "project.achieve"(milestone2) {
-      const node = await resolve(milestone2);
-      await rt.tag(node, "done");
-      return ok(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");
-    },
-    async "project.remove"(project2, individual2) {
-      const projNode = await resolve(project2);
-      await rt.unlink(projNode, await resolve(individual2), "participation", "participate");
-      return ok(projNode, "remove");
-    },
-    async "project.deliver"(project2, deliverable2, id) {
-      validateGherkin(deliverable2);
-      const node = await rt.create(await resolve(project2), C.deliverable, deliverable2, id);
-      return ok(node, "deliver");
-    },
-    async "project.wiki"(project2, wiki2, id) {
-      validateGherkin(wiki2);
-      const node = await rt.create(await resolve(project2), C.wiki, wiki2, id);
-      return ok(node, "wiki");
-    },
-    async "project.archive"(project2) {
-      return archive(await resolve(project2), "archive");
-    },
-    // ---- Org ----
-    async "org.found"(content, id, alias) {
-      validateGherkin(content);
-      const node = await rt.create(society, C.organization, content, id, alias);
-      return ok(node, "found");
-    },
-    async "org.charter"(org, charter2, id) {
-      validateGherkin(charter2);
-      const node = await rt.create(await resolve(org), C.charter, charter2, id);
-      return ok(node, "charter");
-    },
-    async "org.dissolve"(org) {
-      return archive(await resolve(org), "dissolve");
-    },
-    async "org.hire"(org, individual2) {
-      const orgNode = await resolve(org);
-      await rt.link(orgNode, await resolve(individual2), "membership", "belong");
-      return ok(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");
-    },
-    // ---- Position ----
-    async "position.establish"(content, id, alias) {
-      validateGherkin(content);
-      const node = await rt.create(society, C.position, content, id, alias);
-      return ok(node, "establish");
-    },
-    async "position.charge"(position2, duty2, id) {
-      validateGherkin(duty2);
-      const node = await rt.create(await resolve(position2), C.duty, duty2, id);
-      return ok(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, C.requirement, procedure2, id);
-      return ok(node, "require");
-    },
-    async "position.abolish"(position2) {
-      return archive(await resolve(position2), "abolish");
-    },
-    async "position.appoint"(position2, individual2) {
-      const posNode = await resolve(position2);
-      const indNode = await resolve(individual2);
-      await rt.link(posNode, indNode, "appointment", "serve");
-      const posState = await rt.project(posNode);
-      for (const child of posState.children ?? []) {
-        if (child.name !== "requirement" || !child.information) continue;
-        await rt.create(indNode, C.procedure, child.information, child.id);
-      }
-      return ok(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");
-    },
-    // ---- Census ----
-    async "census.list"(type) {
-      const target = type === "past" ? past2 : society;
-      const state = await rt.project(target);
-      const children = state.children ?? [];
-      const filtered = type === "past" ? children : children.filter((c) => type ? c.name === type : c.name !== "past");
-      return { state: { ...state, children: filtered }, process: "list" };
-    },
-    // ---- Resource (proxy to ResourceX) ----
-    "resource.add"(path) {
-      return requireResourceX().add(path);
-    },
-    "resource.search"(query) {
-      return requireResourceX().search(query);
-    },
-    "resource.has"(locator) {
-      return requireResourceX().has(locator);
-    },
-    "resource.info"(locator) {
-      return requireResourceX().info(locator);
-    },
-    "resource.remove"(locator) {
-      return requireResourceX().remove(locator);
-    },
-    "resource.push"(locator, options) {
-      return requireResourceX().push(locator, options);
-    },
-    "resource.pull"(locator, options) {
-      return requireResourceX().pull(locator, options);
-    },
-    "resource.clearCache"(registry) {
-      return requireResourceX().clearCache(registry);
-    },
-    // ---- Issue (proxy to IssueX) ----
-    async "issue.publish"(title, body, author, assignee) {
-      const ix = requireIssueX();
-      return ix.createIssue({ title, body, author, assignee });
-    },
-    async "issue.get"(number) {
-      return requireIssueX().getIssueByNumber(number);
-    },
-    async "issue.list"(status, author, assignee, label) {
-      const filter = {};
-      if (status) filter.status = status;
-      if (author) filter.author = author;
-      if (assignee) filter.assignee = assignee;
-      if (label) filter.label = label;
-      return requireIssueX().listIssues(
-        Object.keys(filter).length > 0 ? filter : void 0
-      );
-    },
-    async "issue.update"(number, title, body, assignee) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      const patch = {};
-      if (title !== void 0) patch.title = title;
-      if (body !== void 0) patch.body = body;
-      if (assignee !== void 0) patch.assignee = assignee;
-      return ix.updateIssue(issue.id, patch);
-    },
-    async "issue.close"(number) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      return ix.closeIssue(issue.id);
-    },
-    async "issue.reopen"(number) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      return ix.reopenIssue(issue.id);
-    },
-    async "issue.assign"(number, assignee) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      return ix.updateIssue(issue.id, { assignee });
-    },
-    async "issue.comment"(number, body, author) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      return ix.createComment(issue.id, body, author);
-    },
-    async "issue.comments"(number) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      return ix.listComments(issue.id);
-    },
-    async "issue.label"(number, label) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      let labelObj = await ix.getLabelByName(label);
-      if (!labelObj) labelObj = await ix.createLabel({ name: label });
-      await ix.addLabel(issue.id, labelObj.id);
-      return ix.getIssueByNumber(number);
-    },
-    async "issue.unlabel"(number, label) {
-      const ix = requireIssueX();
-      const issue = await ix.getIssueByNumber(number);
-      if (!issue) throw new Error(`Issue #${number} not found.`);
-      const labelObj = await ix.getLabelByName(label);
-      if (!labelObj) throw new Error(`Label "${label}" not found.`);
-      await ix.removeLabel(issue.id, labelObj.id);
-      return ix.getIssueByNumber(number);
-    }
-  };
-}
-function formatRXM(rxm) {
-  const lines = [`--- RXM: ${rxm.locator} ---`];
-  const def2 = rxm.definition;
-  if (def2) {
-    if (def2.author) lines.push(`Author: ${def2.author}`);
-    if (def2.description) lines.push(`Description: ${def2.description}`);
-  }
-  const source = rxm.source;
-  if (source?.files) {
-    lines.push("Files:");
-    lines.push(renderFileTree(source.files, "  "));
-  }
-  lines.push("---");
-  return lines.join("\n");
-}
-function renderFileTree(files, indent = "") {
-  const lines = [];
-  for (const [name, value] of Object.entries(files)) {
-    if (value && typeof value === "object" && !("size" in value)) {
-      lines.push(`${indent}${name}`);
-      lines.push(renderFileTree(value, `${indent}  `));
-    } else {
-      const size = value?.size ? ` (${value.size} bytes)` : "";
-      lines.push(`${indent}${name}${size}`);
-    }
-  }
-  return lines.filter(Boolean).join("\n");
-}
-
 // src/descriptions/index.ts
 var processes = {
   "born": "Feature: born \u2014 create a new individual\n  Create a new individual with persona identity.\n  The persona defines who the role is \u2014 personality, values, background.\n\n  Scenario: Birth an individual\n    Given a Gherkin source describing the persona\n    When born is called with the source\n    Then a new individual node is created in society\n    And the persona is stored as the individual's information\n    And the individual can be hired into organizations\n    And the individual can be activated to start working\n\n  Scenario: Writing the individual Gherkin\n    Given the individual Feature defines a persona \u2014 who this role is\n    Then the Feature title names the individual\n    And the description captures personality, values, expertise, and background\n    And Scenarios are optional \u2014 use them for distinct aspects of the persona",
@@ -688,95 +225,6 @@ var world = {
     And this rule applies to end-user communication, not developer communication`,
   "execution": "Feature: Execution \u2014 the doing cycle\n  The role pursues goals through a structured lifecycle.\n  activate \u2192 want \u2192 plan \u2192 todo \u2192 finish \u2192 complete or abandon.\n\n  Scenario: Declare a goal\n    Given I know who I am via activate\n    When I want something \u2014 a desired outcome\n    Then I declare it with want(id, goal)\n    And focus automatically switches to this new goal\n\n  Scenario: Plan and create tasks\n    Given I have a focused goal\n    Then I call plan(id, plan) to break it into logical phases\n    And I call todo(id, task) to create concrete, actionable tasks\n\n  Scenario: Execute and finish\n    Given I have tasks to work on\n    When I complete a task\n    Then I call finish(id) to mark it done\n    And an encounter is created \u2014 a raw record of what happened\n    And I optionally capture what happened via the encounter parameter\n\n  Scenario: Complete or abandon a plan\n    Given tasks are done or the plan's strategy is no longer viable\n    When the plan is fulfilled I call complete()\n    Or when the plan should be dropped I call abandon()\n    Then an encounter is created for the cognition cycle\n\n  Scenario: Goals are long-term directions\n    Given goals are managed with want and forget\n    When a goal is no longer needed\n    Then I call forget to remove it\n    And learning is captured at the plan and task level through encounters\n\n  Scenario: Multiple goals\n    Given I may have several active goals\n    When I need to switch between them\n    Then I call focus(id) to change the currently focused goal\n    And subsequent plan and todo operations target the focused goal",
   "gherkin": 'Feature: Gherkin \u2014 the universal language\n  Everything in RoleX is expressed as Gherkin Feature files.\n  Gherkin is not just for testing \u2014 it is the language of identity, goals, and knowledge.\n\n  Scenario: Feature and Scenario convention\n    Given RoleX uses Gherkin to represent goals, plans, tasks, experience, and knowledge\n    Then a Feature represents one independent concern \u2014 one topic, explained fully\n    And Scenarios represent different situations or conditions within that concern\n    And Given/When/Then provides narrative structure within each scenario\n\n  Scenario: Writing Gherkin for RoleX\n    Given the AI creates goals, plans, tasks, and experiences as Gherkin\n    Then keep it descriptive and meaningful \u2014 living documentation, not test boilerplate\n    And use Feature as the title \u2014 what this concern is about\n    And use Scenario for specific situations within that concern\n    And each Feature focuses on one concern \u2014 separate unrelated topics into their own Features\n\n  Scenario: Valid step keywords\n    Given the only valid step keywords are Given, When, Then, And, But\n    When writing steps that express causality or explanation\n    Then use And to chain the reason as a follow-up fact\n    And example: "Then use RoleX tools" followed by "And RoleX tools feed the growth loop"\n\n  Scenario: Expressing causality\n    Given you want to write "Then X because Y"\n    Then rewrite as two steps \u2014 "Then X" followed by "And Y" stating the reason as a fact',
-  "issue": `Feature: Issue \u2014 persistent structured collaboration beyond a single context
-  AI individuals face a fundamental challenge: context breaks.
-  Each new session starts fresh \u2014 identity and knowledge survive, but the working state is lost.
-  Like humans writing journals and memos, individuals need externalized records
-  that persist across sessions and across individuals.
-
-  Issue is the externalized, structured collaboration primitive of the RoleX world.
-  It enables both self-collaboration (same individual, different sessions)
-  and inter-individual collaboration (different individuals, asynchronous).
-
-  Scenario: Why issues exist
-    Given AI individuals have a context window limit
-    And each new session loses the previous working state
-    And multiple individuals may need to coordinate without being active simultaneously
-    When structured, persistent, discoverable records are needed
-    Then issues serve as externalized working memory for the society
-    And they survive context breaks, session restarts, and individual switches
-
-  Scenario: Self-collaboration \u2014 continuity across sessions
-    Given an individual is working on something that spans multiple sessions
-    When the context window resets or a new session begins
-    Then the individual can publish or check issues to restore working context
-    And comments serve as a journal \u2014 recording progress, decisions, and next steps
-    And the issue persists until explicitly closed, regardless of how many sessions pass
-
-  Scenario: Inter-individual collaboration \u2014 asynchronous coordination
-    Given multiple individuals need to work together
-    And they are never active simultaneously
-    When one individual publishes an issue or leaves a comment
-    Then other individuals can discover it, respond, and contribute
-    And assignee indicates who should act next
-    And labels categorize across concerns
-
-  Scenario: Relationship to goals and tasks
-    Given goals express intent \u2014 what I want to achieve
-    And tasks express action \u2014 what I am doing right now
-    When an issue is something that needs ongoing attention and discussion
-    Then issues may inspire goals, or goals may spawn issues
-    And issues may be resolved by tasks, or tasks may surface new issues
-    But issues are independent \u2014 they belong to the society, not to any single individual's goal tree
-
-  Scenario: Publish a new issue
-    Given I need to raise a topic for attention
-    When I call use("!issue.publish", { title, body, author, assignee? })
-    Then a new issue is created with an auto-incremented number
-    And author should be the active individual's id
-
-  Scenario: Browse and view issues
-    Given I need to see what issues exist
-    When I call use("!issue.list", { status?, author?, assignee?, label? })
-    Then matching issues are returned ordered by number descending
-    When I need details of a specific issue
-    Then I call use("!issue.get", { number })
-
-  Scenario: Update, close, and reopen
-    Given I need to manage an issue's lifecycle
-    When I call use("!issue.update", { number, title?, body?, assignee? })
-    Then the specified fields are updated
-    When resolved I call use("!issue.close", { number })
-    And if it needs more work I call use("!issue.reopen", { number })
-
-  Scenario: Assign and discuss
-    Given I need to delegate or discuss
-    When I call use("!issue.assign", { number, assignee })
-    Then the issue is assigned to another individual
-    When I call use("!issue.comment", { number, body, author })
-    Then a comment is added to the threaded discussion
-    And I can view all comments with use("!issue.comments", { number })
-
-  Scenario: Label for categorization
-    Given I want to categorize issues
-    When I call use("!issue.label", { number, label })
-    Then the label is attached \u2014 auto-created if new
-    And I can remove it with use("!issue.unlabel", { number, label })
-
-  Scenario: Command reference
-    Given the following commands are available:
-      | command          | required args          | optional args                   |
-      | !issue.publish   | title, body, author    | assignee                        |
-      | !issue.get       | number                 |                                 |
-      | !issue.list      |                        | status, author, assignee, label |
-      | !issue.update    | number                 | title, body, assignee           |
-      | !issue.close     | number                 |                                 |
-      | !issue.reopen    | number                 |                                 |
-      | !issue.assign    | number, assignee       |                                 |
-      | !issue.comment   | number, body, author   |                                 |
-      | !issue.comments  | number                 |                                 |
-      | !issue.label     | number, label          |                                 |
-      | !issue.unlabel   | number, label          |                                 |`,
   "memory": `Feature: Memory \u2014 when to reflect
   Reflection is how encounters become experience.
   The AI proactively reflects when it detects learning moments.
@@ -813,17 +261,16 @@ var world = {
   "use-protocol": `Feature: Use tool \u2014 the universal execution entry point
   The MCP use tool is how you execute ALL RoleX operations beyond the core MCP tools.
   Whenever you see use("...") or a !namespace.method pattern in skills or documentation,
-  it is an instruction to call the MCP use tool with that command.
+  it is an instruction to call the MCP use tool with that locator.
 
   Scenario: How to read use instructions in skills
     Given a skill document contains use("!resource.add", { path: "..." })
-    Then this means: call the MCP use tool with command "!resource.add" and path "..."
-    And all named arguments are passed as flat top-level parameters alongside command
+    Then this means: call the MCP use tool with locator "!resource.add" and args { path: "..." }
     And always use the MCP use tool for RoleX operations
     And this applies to every use("...") pattern you encounter in any skill or documentation
 
   Scenario: ! prefix dispatches to RoleX runtime
-    Given the command starts with !
+    Given the locator starts with !
     Then it is parsed as !namespace.method
     And dispatched to the corresponding RoleX API with named args
 
@@ -832,7 +279,7 @@ var world = {
     When you need to execute a command you have not seen in a loaded skill
     Then you MUST call skill(locator) first to load the full instructions
     And the loaded skill will tell you the exact command name and arguments
-    And only then call use with the correct command and flat named parameters
+    And only then call use(!namespace.method, args) with the correct syntax
     And do not use commands from other roles' descriptions \u2014 only your own skills
 
   Scenario: NEVER guess commands
@@ -842,8 +289,8 @@ var world = {
     And call skill(locator) with the relevant procedure to learn the correct syntax
     And if no procedure covers this task, it is outside your duties \u2014 suggest Nuwa
 
-  Scenario: Regular commands delegate to ResourceX
-    Given the command does not start with !
+  Scenario: Regular locators delegate to ResourceX
+    Given the locator does not start with !
     Then it is treated as a ResourceX locator
     And resolved through the ResourceX ingest pipeline`
 };
@@ -869,7 +316,7 @@ var individualBorn = def(
       required: false,
       description: "Gherkin Feature source for the individual"
     },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
+    id: { type: "string", required: false, description: "User-facing identifier (kebab-case)" },
     alias: { type: "string[]", required: false, description: "Alternative names" }
   },
   ["content", "id", "alias"]
@@ -910,7 +357,7 @@ var individualTeach = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Principle id (keywords joined by hyphens)"
     }
   },
@@ -928,7 +375,7 @@ var individualTrain = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Procedure id (keywords joined by hyphens)"
     }
   },
@@ -964,7 +411,7 @@ var roleWant = def(
       required: false,
       description: "Gherkin Feature source describing the goal"
     },
-    id: { type: "string", required: true, description: "Goal id (used for focus/reference)" },
+    id: { type: "string", required: false, description: "Goal id (used for focus/reference)" },
     alias: { type: "string[]", required: false, description: "Alternative names" }
   },
   ["individual", "goal", "id", "alias"]
@@ -979,7 +426,7 @@ var rolePlan = def(
       required: false,
       description: "Gherkin Feature source describing the plan"
     },
-    id: { type: "string", required: true, description: "Plan id (keywords joined by hyphens)" },
+    id: { type: "string", required: false, description: "Plan id (keywords joined by hyphens)" },
     after: {
       type: "string",
       required: false,
@@ -1003,7 +450,7 @@ var roleTodo = def(
       required: false,
       description: "Gherkin Feature source describing the task"
     },
-    id: { type: "string", required: true, description: "Task id (used for finish/reference)" },
+    id: { type: "string", required: false, description: "Task id (used for finish/reference)" },
     alias: { type: "string[]", required: false, description: "Alternative names" }
   },
   ["plan", "task", "id", "alias"]
@@ -1063,7 +510,7 @@ var roleReflect = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Experience id (keywords joined by hyphens)"
     }
   },
@@ -1082,7 +529,7 @@ var roleRealize = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Principle id (keywords joined by hyphens)"
     }
   },
@@ -1100,7 +547,7 @@ var roleMaster = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Procedure id (keywords joined by hyphens)"
     },
     experience: {
@@ -1137,7 +584,7 @@ var orgFound = def(
       required: false,
       description: "Gherkin Feature source for the organization"
     },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
+    id: { type: "string", required: false, description: "User-facing identifier (kebab-case)" },
     alias: { type: "string[]", required: false, description: "Alternative names" }
   },
   ["content", "id", "alias"]
@@ -1152,7 +599,7 @@ var orgCharter = def(
       required: true,
       description: "Gherkin Feature source for the charter"
     },
-    id: { type: "string", required: true, description: "Charter id" }
+    id: { type: "string", required: false, description: "Charter id" }
   },
   ["org", "content", "id"]
 );
@@ -1191,7 +638,7 @@ var positionEstablish = def(
       required: false,
       description: "Gherkin Feature source for the position"
     },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
+    id: { type: "string", required: false, description: "User-facing identifier (kebab-case)" },
     alias: { type: "string[]", required: false, description: "Alternative names" }
   },
   ["content", "id", "alias"]
@@ -1206,7 +653,7 @@ var positionCharge = def(
       required: true,
       description: "Gherkin Feature source for the duty"
     },
-    id: { type: "string", required: true, description: "Duty id (keywords joined by hyphens)" }
+    id: { type: "string", required: false, description: "Duty id (keywords joined by hyphens)" }
   },
   ["position", "content", "id"]
 );
@@ -1222,7 +669,7 @@ var positionRequire = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Requirement id (keywords joined by hyphens)"
     }
   },
@@ -1263,7 +710,7 @@ var projectLaunch = def(
       required: false,
       description: "Gherkin Feature source for the project"
     },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
+    id: { type: "string", required: false, description: "User-facing identifier (kebab-case)" },
     alias: { type: "string[]", required: false, description: "Alternative names" },
     org: {
       type: "string",
@@ -1283,7 +730,7 @@ var projectScope = def(
       required: true,
       description: "Gherkin Feature source for the scope"
     },
-    id: { type: "string", required: true, description: "Scope id" }
+    id: { type: "string", required: false, description: "Scope id" }
   },
   ["project", "content", "id"]
 );
@@ -1299,7 +746,7 @@ var projectMilestone = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Milestone id (keywords joined by hyphens)"
     }
   },
@@ -1343,7 +790,7 @@ var projectDeliver = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Deliverable id (keywords joined by hyphens)"
     }
   },
@@ -1361,7 +808,7 @@ var projectWiki = def(
     },
     id: {
       type: "string",
-      required: true,
+      required: false,
       description: "Wiki entry id (keywords joined by hyphens)"
     }
   },
@@ -1387,6 +834,18 @@ var censusList = def(
   },
   ["type"]
 );
+var prototypeSettle = def(
+  "prototype",
+  "settle",
+  {
+    source: {
+      type: "string",
+      required: true,
+      description: "ResourceX source \u2014 local path or locator"
+    }
+  },
+  ["source"]
+);
 var prototypeEvict = def(
   "prototype",
   "evict",
@@ -1611,6 +1070,7 @@ var instructions = {
   // census
   "census.list": censusList,
   // prototype
+  "prototype.settle": prototypeSettle,
   "prototype.evict": prototypeEvict,
   // resource
   "resource.add": resourceAdd,
@@ -1663,260 +1123,520 @@ function resolveArg(entry, args) {
   return hasValue ? obj : void 0;
 }
 
-// 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/ops.ts
+import * as C from "@rolexjs/core";
+import { parse } from "@rolexjs/parser";
+function createOps(ctx) {
+  const { rt, society, past: past2, resolve, resourcex, issuex } = ctx;
+  async function ok(node, process) {
+    return { state: await rt.project(node), process };
   }
-  /** 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 function archive(node, process) {
+    const archived = await rt.transform(node, C.past);
+    return ok(archived, process);
   }
-};
-function defaultRender(_command, result) {
-  return JSON.stringify(result, null, 2);
-}
-
-// src/tools.ts
-var worldInstructions = Object.values(world).join("\n\n");
-var tools = [
-  // --- Role ---
-  {
-    name: "activate",
-    params: {
-      roleId: { type: "string", required: true, description: "Role name to activate" }
+  function validateGherkin(source) {
+    if (!source) return;
+    try {
+      parse(source);
+    } catch (e) {
+      throw new Error(`Invalid Gherkin: ${e.message}`);
     }
-  },
-  {
-    name: "focus",
-    params: {
-      id: {
-        type: "string",
-        required: false,
-        description: "Goal id to switch to. Omit to view current."
+  }
+  function findInState(state, target) {
+    if (state.id && state.id.toLowerCase() === target) return state;
+    if (state.alias) {
+      for (const a of state.alias) {
+        if (a.toLowerCase() === target) return state;
       }
     }
-  },
-  // --- Execution ---
-  {
-    name: "want",
-    params: {
-      id: { type: "string", required: true, description: "Goal id (used for focus/reference)" },
-      goal: {
-        type: "gherkin",
-        required: true,
-        description: "Gherkin Feature source describing the goal"
-      }
+    for (const child of state.children ?? []) {
+      const found = findInState(child, target);
+      if (found) return found;
     }
-  },
-  {
-    name: "plan",
-    params: {
-      id: {
-        type: "string",
-        required: true,
-        description: "Plan id \u2014 keywords from the plan content joined by hyphens"
-      },
-      plan: {
-        type: "gherkin",
-        required: true,
-        description: "Gherkin Feature source describing the plan"
-      },
-      after: {
-        type: "string",
-        required: false,
-        description: "Plan id this plan follows (sequential/phase relationship)"
-      },
-      fallback: {
-        type: "string",
-        required: false,
-        description: "Plan id this plan is a backup for (alternative/strategy relationship)"
+    return null;
+  }
+  async function removeExisting(parent, id) {
+    const state = await rt.project(parent);
+    const existing = findInState(state, id);
+    if (existing) await rt.remove(existing);
+  }
+  function requireResourceX() {
+    if (!resourcex) throw new Error("ResourceX is not available.");
+    return resourcex;
+  }
+  function requireIssueX() {
+    if (!issuex) throw new Error("IssueX is not available.");
+    return issuex;
+  }
+  return {
+    // ---- Individual: lifecycle ----
+    async "individual.born"(content, id, alias) {
+      validateGherkin(content);
+      const node = await rt.create(society, C.individual, content, id, alias);
+      await rt.create(node, C.identity, void 0, id ? `${id}-identity` : void 0);
+      return ok(node, "born");
+    },
+    async "individual.retire"(individual2) {
+      return archive(await resolve(individual2), "retire");
+    },
+    async "individual.die"(individual2) {
+      return archive(await resolve(individual2), "die");
+    },
+    async "individual.rehire"(pastNode) {
+      const node = await resolve(pastNode);
+      const ind = await rt.transform(node, C.individual);
+      return ok(ind, "rehire");
+    },
+    // ---- Individual: external injection ----
+    async "individual.teach"(individual2, principle2, id) {
+      validateGherkin(principle2);
+      const parent = await resolve(individual2);
+      if (id) await removeExisting(parent, id);
+      const node = await rt.create(parent, C.principle, principle2, id);
+      return ok(node, "teach");
+    },
+    async "individual.train"(individual2, procedure2, id) {
+      validateGherkin(procedure2);
+      const parent = await resolve(individual2);
+      if (id) await removeExisting(parent, id);
+      const node = await rt.create(parent, C.procedure, procedure2, id);
+      return ok(node, "train");
+    },
+    // ---- Role: focus ----
+    async "role.focus"(goal2) {
+      return ok(await resolve(goal2), "focus");
+    },
+    // ---- Role: execution ----
+    async "role.want"(individual2, goal2, id, alias) {
+      validateGherkin(goal2);
+      const node = await rt.create(await resolve(individual2), C.goal, goal2, id, alias);
+      return ok(node, "want");
+    },
+    async "role.plan"(goal2, plan2, id, after, fallback) {
+      validateGherkin(plan2);
+      const node = await rt.create(await resolve(goal2), C.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");
+    },
+    async "role.todo"(plan2, task2, id, alias) {
+      validateGherkin(task2);
+      const node = await rt.create(await resolve(plan2), C.task, task2, id, alias);
+      return ok(node, "todo");
+    },
+    async "role.finish"(task2, individual2, encounter2) {
+      validateGherkin(encounter2);
+      const taskNode = await resolve(task2);
+      await rt.tag(taskNode, "done");
+      if (encounter2) {
+        const encId = taskNode.id ? `${taskNode.id}-finished` : void 0;
+        const enc = await rt.create(await resolve(individual2), C.encounter, encounter2, encId);
+        return ok(enc, "finish");
       }
-    }
-  },
-  {
-    name: "todo",
-    params: {
-      id: { type: "string", required: true, description: "Task id (used for finish/reference)" },
-      task: {
-        type: "gherkin",
-        required: true,
-        description: "Gherkin Feature source describing the task"
+      return ok(taskNode, "finish");
+    },
+    async "role.complete"(plan2, individual2, encounter2) {
+      validateGherkin(encounter2);
+      const planNode = await resolve(plan2);
+      await rt.tag(planNode, "done");
+      const encId = planNode.id ? `${planNode.id}-completed` : void 0;
+      const enc = await rt.create(await resolve(individual2), C.encounter, encounter2, encId);
+      return ok(enc, "complete");
+    },
+    async "role.abandon"(plan2, individual2, encounter2) {
+      validateGherkin(encounter2);
+      const planNode = await resolve(plan2);
+      await rt.tag(planNode, "abandoned");
+      const encId = planNode.id ? `${planNode.id}-abandoned` : void 0;
+      const enc = await rt.create(await resolve(individual2), C.encounter, encounter2, encId);
+      return ok(enc, "abandon");
+    },
+    // ---- Role: cognition ----
+    async "role.reflect"(encounter2, individual2, experience2, id) {
+      validateGherkin(experience2);
+      if (encounter2) {
+        const encNode = await resolve(encounter2);
+        const exp2 = await rt.create(
+          await resolve(individual2),
+          C.experience,
+          experience2 || encNode.information,
+          id
+        );
+        await rt.remove(encNode);
+        return ok(exp2, "reflect");
       }
-    }
-  },
-  {
-    name: "finish",
-    params: {
-      id: { type: "string", required: true, description: "Task id to finish" },
-      encounter: {
-        type: "gherkin",
-        required: false,
-        description: "Optional Gherkin Feature describing what happened"
+      const exp = await rt.create(await resolve(individual2), C.experience, experience2, id);
+      return ok(exp, "reflect");
+    },
+    async "role.realize"(experience2, individual2, principle2, id) {
+      validateGherkin(principle2);
+      if (experience2) {
+        const expNode = await resolve(experience2);
+        const prin2 = await rt.create(
+          await resolve(individual2),
+          C.principle,
+          principle2 || expNode.information,
+          id
+        );
+        await rt.remove(expNode);
+        return ok(prin2, "realize");
       }
-    }
-  },
-  {
-    name: "complete",
-    params: {
-      id: {
-        type: "string",
-        required: false,
-        description: "Plan id to complete (defaults to focused plan)"
-      },
-      encounter: {
-        type: "gherkin",
-        required: false,
-        description: "Optional Gherkin Feature describing what happened"
+      const prin = await rt.create(await resolve(individual2), C.principle, principle2, id);
+      return ok(prin, "realize");
+    },
+    async "role.master"(individual2, procedure2, id, experience2) {
+      validateGherkin(procedure2);
+      const parent = await resolve(individual2);
+      if (id) await removeExisting(parent, id);
+      const proc = await rt.create(parent, C.procedure, procedure2, id);
+      if (experience2) await rt.remove(await resolve(experience2));
+      return ok(proc, "master");
+    },
+    // ---- Role: knowledge management ----
+    async "role.forget"(nodeId) {
+      const node = await resolve(nodeId);
+      await rt.remove(node);
+      return { state: { ...node, children: [] }, process: "forget" };
+    },
+    // ---- Role: skill ----
+    async "role.skill"(locator) {
+      const rx = requireResourceX();
+      const content = await rx.ingest(locator);
+      const text = typeof content === "string" ? content : JSON.stringify(content, null, 2);
+      try {
+        const rxm = await rx.info(locator);
+        return `${formatRXM(rxm)}
+
+${text}`;
+      } catch {
+        return text;
       }
-    }
-  },
-  {
-    name: "abandon",
-    params: {
-      id: {
-        type: "string",
-        required: false,
-        description: "Plan id to abandon (defaults to focused plan)"
-      },
-      encounter: {
-        type: "gherkin",
-        required: false,
-        description: "Optional Gherkin Feature describing what happened"
+    },
+    // ---- Project ----
+    async "project.launch"(content, id, alias, org) {
+      validateGherkin(content);
+      const node = await rt.create(society, C.project, content, id, alias);
+      if (org) await rt.link(node, await resolve(org), "ownership", "project");
+      return ok(node, "launch");
+    },
+    async "project.scope"(project2, scope2, id) {
+      validateGherkin(scope2);
+      const node = await rt.create(await resolve(project2), C.scope, scope2, id);
+      return ok(node, "scope");
+    },
+    async "project.milestone"(project2, milestone2, id) {
+      validateGherkin(milestone2);
+      const node = await rt.create(await resolve(project2), C.milestone, milestone2, id);
+      return ok(node, "milestone");
+    },
+    async "project.achieve"(milestone2) {
+      const node = await resolve(milestone2);
+      await rt.tag(node, "done");
+      return ok(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");
+    },
+    async "project.remove"(project2, individual2) {
+      const projNode = await resolve(project2);
+      await rt.unlink(projNode, await resolve(individual2), "participation", "participate");
+      return ok(projNode, "remove");
+    },
+    async "project.deliver"(project2, deliverable2, id) {
+      validateGherkin(deliverable2);
+      const node = await rt.create(await resolve(project2), C.deliverable, deliverable2, id);
+      return ok(node, "deliver");
+    },
+    async "project.wiki"(project2, wiki2, id) {
+      validateGherkin(wiki2);
+      const node = await rt.create(await resolve(project2), C.wiki, wiki2, id);
+      return ok(node, "wiki");
+    },
+    async "project.archive"(project2) {
+      return archive(await resolve(project2), "archive");
+    },
+    // ---- Org ----
+    async "org.found"(content, id, alias) {
+      validateGherkin(content);
+      const node = await rt.create(society, C.organization, content, id, alias);
+      return ok(node, "found");
+    },
+    async "org.charter"(org, charter2, id) {
+      validateGherkin(charter2);
+      const node = await rt.create(await resolve(org), C.charter, charter2, id);
+      return ok(node, "charter");
+    },
+    async "org.dissolve"(org) {
+      return archive(await resolve(org), "dissolve");
+    },
+    async "org.hire"(org, individual2) {
+      const orgNode = await resolve(org);
+      await rt.link(orgNode, await resolve(individual2), "membership", "belong");
+      return ok(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");
+    },
+    // ---- Position ----
+    async "position.establish"(content, id, alias) {
+      validateGherkin(content);
+      const node = await rt.create(society, C.position, content, id, alias);
+      return ok(node, "establish");
+    },
+    async "position.charge"(position2, duty2, id) {
+      validateGherkin(duty2);
+      const node = await rt.create(await resolve(position2), C.duty, duty2, id);
+      return ok(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, C.requirement, procedure2, id);
+      return ok(node, "require");
+    },
+    async "position.abolish"(position2) {
+      return archive(await resolve(position2), "abolish");
+    },
+    async "position.appoint"(position2, individual2) {
+      const posNode = await resolve(position2);
+      const indNode = await resolve(individual2);
+      await rt.link(posNode, indNode, "appointment", "serve");
+      const posState = await rt.project(posNode);
+      for (const child of posState.children ?? []) {
+        if (child.name !== "requirement" || !child.information) continue;
+        await rt.create(indNode, C.procedure, child.information, child.id);
       }
-    }
-  },
-  // --- Cognition ---
-  {
-    name: "reflect",
-    params: {
-      ids: {
-        type: "string[]",
-        required: true,
-        description: "Encounter ids to reflect on (selective consumption)"
-      },
-      id: {
-        type: "string",
-        required: true,
-        description: "Experience id \u2014 keywords from the experience content joined by hyphens"
-      },
-      experience: {
-        type: "gherkin",
-        required: false,
-        description: "Gherkin Feature source for the experience"
+      return ok(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");
+    },
+    // ---- Census ----
+    async "census.list"(type) {
+      const target = type === "past" ? past2 : society;
+      const state = await rt.project(target);
+      const children = state.children ?? [];
+      const filtered = type === "past" ? children : children.filter((c) => type ? c.name === type : c.name !== "past");
+      if (filtered.length === 0) {
+        return type ? `No ${type} found.` : "Society is empty.";
       }
-    }
-  },
-  {
-    name: "realize",
-    params: {
-      ids: {
-        type: "string[]",
-        required: true,
-        description: "Experience ids to distill into a principle"
-      },
-      id: {
-        type: "string",
-        required: true,
-        description: "Principle id \u2014 keywords from the principle content joined by hyphens"
-      },
-      principle: {
-        type: "gherkin",
-        required: false,
-        description: "Gherkin Feature source for the principle"
+      if (type) {
+        const lines2 = [];
+        for (const item of filtered) {
+          const tag = item.tag ? ` #${item.tag}` : "";
+          const alias = item.alias?.length ? ` (${item.alias.join(", ")})` : "";
+          lines2.push(`${item.id ?? "(no id)"}${alias}${tag}`);
+        }
+        return lines2.join("\n");
       }
-    }
-  },
-  {
-    name: "master",
-    params: {
-      ids: {
-        type: "string[]",
-        required: false,
-        description: "Experience ids to distill into a procedure"
-      },
-      id: {
-        type: "string",
-        required: true,
-        description: "Procedure id \u2014 keywords from the procedure content joined by hyphens"
-      },
-      procedure: {
-        type: "gherkin",
-        required: true,
-        description: "Gherkin Feature source for the procedure"
+      const orgs = filtered.filter((c) => c.name === "organization");
+      const individuals = filtered.filter((c) => c.name === "individual");
+      const affiliatedIndividuals = /* @__PURE__ */ new Set();
+      const individualPositions = /* @__PURE__ */ new Map();
+      for (const ind of individuals) {
+        const serves = ind.links?.filter((l) => l.relation === "serve") ?? [];
+        if (serves.length > 0) {
+          individualPositions.set(
+            ind.id ?? "",
+            serves.map((l) => l.target.id ?? "(no id)")
+          );
+        }
       }
-    }
-  },
-  // --- Knowledge ---
-  {
-    name: "forget",
-    params: {
-      id: {
-        type: "string",
-        required: true,
-        description: "Id of the node to remove (principle, procedure, experience, encounter, etc.)"
+      const lines = [];
+      for (const org of orgs) {
+        const alias = org.alias?.length ? ` (${org.alias.join(", ")})` : "";
+        const tag = org.tag ? ` #${org.tag}` : "";
+        lines.push(`${org.id}${alias}${tag}`);
+        const projects = org.links?.filter((l) => l.relation === "project") ?? [];
+        for (const p of projects) {
+          const pAlias = p.target.alias?.length ? ` (${p.target.alias.join(", ")})` : "";
+          const pTag = p.target.tag ? ` #${p.target.tag}` : "";
+          lines.push(`  \u{1F4E6} ${p.target.id ?? "(no id)"}${pAlias}${pTag}`);
+        }
+        const members = org.links?.filter((l) => l.relation === "membership") ?? [];
+        if (members.length === 0 && projects.length === 0) {
+          lines.push("  (empty)");
+        }
+        for (const m of members) {
+          affiliatedIndividuals.add(m.target.id ?? "");
+          const mAlias = m.target.alias?.length ? ` (${m.target.alias.join(", ")})` : "";
+          const mTag = m.target.tag ? ` #${m.target.tag}` : "";
+          const posLabels = individualPositions.get(m.target.id ?? "");
+          const posStr = posLabels?.length ? ` \u2014 ${posLabels.join(", ")}` : "";
+          lines.push(`  ${m.target.id}${mAlias}${mTag}${posStr}`);
+        }
+        lines.push("");
       }
-    }
-  },
-  {
-    name: "skill",
-    params: {
-      locator: {
-        type: "string",
-        required: true,
-        description: "ResourceX locator for the skill (e.g. deepractice/role-management)"
+      const unaffiliated = individuals.filter((ind) => !affiliatedIndividuals.has(ind.id ?? ""));
+      if (unaffiliated.length > 0) {
+        lines.push("\u2500\u2500\u2500 unaffiliated \u2500\u2500\u2500");
+        for (const ind of unaffiliated) {
+          const alias = ind.alias?.length ? ` (${ind.alias.join(", ")})` : "";
+          const tag = ind.tag ? ` #${ind.tag}` : "";
+          const posLabels = individualPositions.get(ind.id ?? "");
+          const posStr = posLabels?.length ? ` \u2014 ${posLabels.join(", ")}` : "";
+          lines.push(`  ${ind.id}${alias}${tag}${posStr}`);
+        }
       }
-    }
-  },
-  // --- Use / Direct ---
-  {
-    name: "use",
-    params: {
-      command: {
-        type: "string",
-        required: true,
-        description: "!namespace.method for RoleX commands, or a ResourceX locator for resources"
-      },
-      args: {
-        type: "record",
-        required: false,
-        description: "Named arguments for the command. Load the relevant skill first to learn what args to pass."
+      return lines.join("\n");
+    },
+    // ---- Prototype ----
+    async "prototype.settle"(source) {
+      const rx = requireResourceX();
+      if (!ctx.prototype) throw new Error("Prototype registry is not available.");
+      if (!ctx.direct) throw new Error("Direct dispatch is not available.");
+      const result = await rx.ingest(source);
+      for (const instr of result.instructions) {
+        await ctx.direct(instr.op, instr.args);
       }
+      ctx.prototype.settle(result.id, source);
+      return `Prototype "${result.id}" settled (${result.instructions.length} instructions).`;
+    },
+    // ---- Resource (proxy to ResourceX) ----
+    "resource.add"(path) {
+      return requireResourceX().add(path);
+    },
+    "resource.search"(query) {
+      return requireResourceX().search(query);
+    },
+    "resource.has"(locator) {
+      return requireResourceX().has(locator);
+    },
+    "resource.info"(locator) {
+      return requireResourceX().info(locator);
+    },
+    "resource.remove"(locator) {
+      return requireResourceX().remove(locator);
+    },
+    "resource.push"(locator, options) {
+      return requireResourceX().push(locator, options);
+    },
+    "resource.pull"(locator, options) {
+      return requireResourceX().pull(locator, options);
+    },
+    "resource.clearCache"(registry) {
+      return requireResourceX().clearCache(registry);
+    },
+    // ---- Issue (proxy to IssueX) ----
+    async "issue.publish"(title, body, author, assignee) {
+      const ix = requireIssueX();
+      return ix.createIssue({ title, body, author, assignee });
+    },
+    async "issue.get"(number) {
+      return requireIssueX().getIssueByNumber(number);
+    },
+    async "issue.list"(status, author, assignee, label) {
+      const filter = {};
+      if (status) filter.status = status;
+      if (author) filter.author = author;
+      if (assignee) filter.assignee = assignee;
+      if (label) filter.label = label;
+      return requireIssueX().listIssues(
+        Object.keys(filter).length > 0 ? filter : void 0
+      );
+    },
+    async "issue.update"(number, title, body, assignee) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      const patch = {};
+      if (title !== void 0) patch.title = title;
+      if (body !== void 0) patch.body = body;
+      if (assignee !== void 0) patch.assignee = assignee;
+      return ix.updateIssue(issue.id, patch);
+    },
+    async "issue.close"(number) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      return ix.closeIssue(issue.id);
+    },
+    async "issue.reopen"(number) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      return ix.reopenIssue(issue.id);
+    },
+    async "issue.assign"(number, assignee) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      return ix.updateIssue(issue.id, { assignee });
+    },
+    async "issue.comment"(number, body, author) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      return ix.createComment(issue.id, body, author);
+    },
+    async "issue.comments"(number) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      return ix.listComments(issue.id);
+    },
+    async "issue.label"(number, label) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      let labelObj = await ix.getLabelByName(label);
+      if (!labelObj) labelObj = await ix.createLabel({ name: label });
+      await ix.addLabel(issue.id, labelObj.id);
+      return ix.getIssueByNumber(number);
+    },
+    async "issue.unlabel"(number, label) {
+      const ix = requireIssueX();
+      const issue = await ix.getIssueByNumber(number);
+      if (!issue) throw new Error(`Issue #${number} not found.`);
+      const labelObj = await ix.getLabelByName(label);
+      if (!labelObj) throw new Error(`Label "${label}" not found.`);
+      await ix.removeLabel(issue.id, labelObj.id);
+      return ix.getIssueByNumber(number);
     }
-  },
-  {
-    name: "direct",
-    params: {
-      command: {
-        type: "string",
-        required: true,
-        description: "!namespace.method for RoleX commands, or a ResourceX locator for resources"
-      },
-      args: {
-        type: "record",
-        required: false,
-        description: "Named arguments for the command. Load the relevant skill first to learn what args to pass."
-      }
+  };
+}
+function formatRXM(rxm) {
+  const lines = [`--- RXM: ${rxm.locator} ---`];
+  const def2 = rxm.definition;
+  if (def2) {
+    if (def2.author) lines.push(`Author: ${def2.author}`);
+    if (def2.description) lines.push(`Description: ${def2.description}`);
+  }
+  const source = rxm.source;
+  if (source?.files) {
+    lines.push("Files:");
+    lines.push(renderFileTree(source.files, "  "));
+  }
+  lines.push("---");
+  return lines.join("\n");
+}
+function renderFileTree(files, indent = "") {
+  const lines = [];
+  for (const [name, value] of Object.entries(files)) {
+    if (value && typeof value === "object" && !("size" in value)) {
+      lines.push(`${indent}${name}`);
+      lines.push(renderFileTree(value, `${indent}  `));
+    } else {
+      const size = value?.size ? ` (${value.size} bytes)` : "";
+      lines.push(`${indent}${name}${size}`);
     }
   }
-];
+  return lines.filter(Boolean).join("\n");
+}
 export {
-  RendererRouter,
-  applyPrototype,
-  createCommands,
+  createOps,
   directives,
   instructions,
   processes,
   toArgs,
-  tools,
-  world,
-  worldInstructions
+  world
 };
 //# sourceMappingURL=index.js.map