@rolexjs/core 1.5.0-dev-20260317075835 → 1.5.0

package/dist/index.js

@@ -66,6 +66,13 @@ var strategy = structure("strategy", "Product strategy \u2014 how to win", produ
 var spec = structure("spec", "Product behavior contract \u2014 BDD specification", product);
 var release = structure("release", "Product version release", product);
 var channel = structure("channel", "Product distribution channel", product);
+var issue = structure("issue", "A collaboration topic requiring attention", society, [
+  relation("authored-by", "Who created this issue", individual),
+  relation("assigned-to", "Who is responsible for this issue", individual)
+]);
+var comment = structure("comment", "A discussion entry on an issue", issue, [
+  relation("authored-by", "Who wrote this comment", individual)
+]);
 
 // src/execution.ts
 import { create, process, transform } from "@rolexjs/system";
@@ -552,27 +559,6 @@ var Role = class {
     return this.fmt("role.forget", result);
   }
   // ================================================================
-  //  Skills
-  // ================================================================
-  /** Skill: load full skill content by locator. */
-  async skill(locator) {
-    return await this.deps.commands["role.skill"](locator);
-  }
-  // ================================================================
-  //  Use — subjective execution
-  // ================================================================
-  /** Use: subjective execution — `!ns.method` or ResourceX locator. */
-  async use(locator, args) {
-    if (!this.deps.direct) {
-      throw new Error("Direct execution is not available on this Role instance.");
-    }
-    const result = await this.deps.direct(locator, args);
-    if (this.deps.transformUseResult) {
-      return this.deps.transformUseResult(locator, result);
-    }
-    return result;
-  }
-  // ================================================================
   //  Cognitive hints
   // ================================================================
   cognitiveHint(process8) {
@@ -621,10 +607,6 @@ var Role = class {
   }
 };
 
-// src/rolex-service.ts
-import { createIssueX } from "issuexjs";
-import { createResourceX, setProvider } from "resourcexjs";
-
 // src/apply.ts
 async function applyPrototype(data, repo, direct) {
   const sorted = [...data.migrations].sort((a, b) => a.version - b.version);
@@ -667,7 +649,7 @@ function findInState(state, target) {
   return null;
 }
 function createHelpers(ctx) {
-  const { rt, project: project2, resourcex, issuex } = ctx;
+  const { rt, project: project2 } = ctx;
   async function ok2(node, process8) {
     return { state: await project2(node), process: process8 };
   }
@@ -689,95 +671,142 @@ function createHelpers(ctx) {
     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 { ok: ok2, archive: archive2, validateGherkin, removeExisting, requireResourceX, requireIssueX };
+  return { ok: ok2, archive: archive2, validateGherkin, removeExisting };
 }
 
 // src/commands/issue.ts
-function issueCommands(_ctx, helpers) {
-  const { requireIssueX } = helpers;
+var nextIssueNumber = 0;
+function initCounter(children) {
+  let max = 0;
+  for (const child of children) {
+    if (child.name === "issue" && child.id) {
+      const match = child.id.match(/^issue-(\d+)$/);
+      if (match) {
+        const n = parseInt(match[1], 10);
+        if (n > max) max = n;
+      }
+    }
+  }
+  nextIssueNumber = max;
+}
+function allocateNumber() {
+  return ++nextIssueNumber;
+}
+function issueCommands(ctx, helpers) {
+  const { rt, society: society2, resolve, project: project2 } = ctx;
+  const { ok: ok2 } = helpers;
+  let counterInitialized = false;
+  async function ensureCounter() {
+    if (counterInitialized) return;
+    const state = await rt.project(society2);
+    initCounter(state.children ?? []);
+    counterInitialized = true;
+  }
+  async function findIssue(number) {
+    const id = `issue-${number}`;
+    const node = await resolve(id);
+    return node;
+  }
   return {
     async "issue.publish"(title, body, author, assignee) {
-      const ix = requireIssueX();
-      return ix.createIssue({ title, body, author, assignee });
+      await ensureCounter();
+      const number = allocateNumber();
+      const id = `issue-${number}`;
+      const node = await rt.create(society2, issue, body, id, [title]);
+      await rt.addTag(node, "open");
+      const authorNode = await resolve(author);
+      await rt.link(node, authorNode, "authored-by", "author-of");
+      if (assignee) {
+        const assigneeNode = await resolve(assignee);
+        await rt.link(node, assigneeNode, "assigned-to", "assigned");
+      }
+      return ok2(node, "publish");
     },
     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
-      );
+      const node = await findIssue(number);
+      return ok2(node, "get");
+    },
+    async "issue.list"(status, _author, _assignee, _label) {
+      const state = await project2(society2);
+      const issues = (state.children ?? []).filter((c) => {
+        if (c.name !== "issue") return false;
+        if (status && !c.tags?.includes(status)) return false;
+        return true;
+      });
+      return {
+        state: { ...state, children: issues },
+        process: "list"
+      };
     },
     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);
+      const node = await findIssue(number);
+      if (body !== void 0 || title !== void 0) {
+        const target = issue;
+        if (body !== void 0) {
+          await rt.transform(node, target, body);
+        }
+      }
+      if (assignee !== void 0) {
+        const state = await rt.project(node);
+        const existingAssignee = state.links?.find((l) => l.relation === "assigned-to");
+        if (existingAssignee) {
+          await rt.unlink(node, existingAssignee.target, "assigned-to", "assigned");
+        }
+        if (assignee) {
+          const assigneeNode = await resolve(assignee);
+          await rt.link(node, assigneeNode, "assigned-to", "assigned");
+        }
+      }
+      return ok2(node, "update");
     },
     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);
+      const node = await findIssue(number);
+      await rt.removeTag(node, "open");
+      await rt.addTag(node, "closed");
+      return ok2(node, "close");
     },
     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);
+      const node = await findIssue(number);
+      await rt.removeTag(node, "closed");
+      await rt.addTag(node, "open");
+      return ok2(node, "reopen");
     },
     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 });
+      const node = await findIssue(number);
+      const state = await rt.project(node);
+      const existingAssignee = state.links?.find((l) => l.relation === "assigned-to");
+      if (existingAssignee) {
+        await rt.unlink(node, existingAssignee.target, "assigned-to", "assigned");
+      }
+      const assigneeNode = await resolve(assignee);
+      await rt.link(node, assigneeNode, "assigned-to", "assigned");
+      return ok2(node, "assign");
     },
     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);
+      const issueNode = await findIssue(number);
+      const commentNode = await rt.create(issueNode, comment, body);
+      const authorNode = await resolve(author);
+      await rt.link(commentNode, authorNode, "authored-by", "author-of");
+      return ok2(commentNode, "comment");
     },
     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);
+      const issueNode = await findIssue(number);
+      const state = await project2(issueNode);
+      const comments = (state.children ?? []).filter((c) => c.name === "comment");
+      return {
+        state: { ...state, children: comments },
+        process: "comments"
+      };
     },
     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);
+      const node = await findIssue(number);
+      await rt.addTag(node, label);
+      return ok2(node, "label");
     },
     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);
+      const node = await findIssue(number);
+      await rt.removeTag(node, label);
+      return ok2(node, "unlabel");
     }
   };
 }
@@ -871,7 +900,7 @@ function projectCommands(ctx, helpers) {
     },
     async "project.achieve"(milestone2) {
       const node = await resolve(milestone2);
-      await rt.tag(node, "done");
+      await rt.addTag(node, "done");
       return ok2(node, "achieve");
     },
     async "project.enroll"(project2, individual2) {
@@ -916,69 +945,10 @@ function projectCommands(ctx, helpers) {
   };
 }
 
-// src/commands/resource.ts
-function resourceCommands(_ctx, helpers) {
-  const { requireResourceX } = helpers;
-  return {
-    "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);
-    }
-  };
-}
-
 // src/commands/role.ts
-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");
-}
 function roleCommands(ctx, helpers) {
   const { rt, resolve } = ctx;
-  const { ok: ok2, validateGherkin, removeExisting, requireResourceX } = helpers;
+  const { ok: ok2, validateGherkin, removeExisting } = helpers;
   return {
     // ---- Role: focus ----
     async "role.focus"(goal2) {
@@ -1005,7 +975,7 @@ function roleCommands(ctx, helpers) {
     async "role.finish"(task2, individual2, encounter2) {
       validateGherkin(encounter2);
       const taskNode = await resolve(task2);
-      await rt.tag(taskNode, "done");
+      await rt.addTag(taskNode, "done");
       if (encounter2) {
         const encId = taskNode.id ? `${taskNode.id}-finished` : void 0;
         const enc = await rt.create(await resolve(individual2), encounter, encounter2, encId);
@@ -1016,7 +986,7 @@ function roleCommands(ctx, helpers) {
     async "role.complete"(plan2, individual2, encounter2) {
       validateGherkin(encounter2);
       const planNode = await resolve(plan2);
-      await rt.tag(planNode, "done");
+      await rt.addTag(planNode, "done");
       const encId = planNode.id ? `${planNode.id}-completed` : void 0;
       const enc = await rt.create(await resolve(individual2), encounter, encounter2, encId);
       return ok2(enc, "complete");
@@ -1024,7 +994,7 @@ function roleCommands(ctx, helpers) {
     async "role.abandon"(plan2, individual2, encounter2) {
       validateGherkin(encounter2);
       const planNode = await resolve(plan2);
-      await rt.tag(planNode, "abandoned");
+      await rt.addTag(planNode, "abandoned");
       const encId = planNode.id ? `${planNode.id}-abandoned` : void 0;
       const enc = await rt.create(await resolve(individual2), encounter, encounter2, encId);
       return ok2(enc, "abandon");
@@ -1075,20 +1045,6 @@ function roleCommands(ctx, helpers) {
       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;
-      }
     }
   };
 }
@@ -1226,7 +1182,6 @@ function createCommands(ctx) {
     ...projectCommands(ctx, helpers),
     ...productCommands(ctx, helpers),
     ...surveyCommands(ctx, helpers),
-    ...resourceCommands(ctx, helpers),
     ...issueCommands(ctx, helpers)
   };
 }
@@ -1736,74 +1691,6 @@ var projectUnmaintain = def(
   ["project", "individual"]
 );
 
-// src/instructions/resource.ts
-var resourceAdd = def(
-  "resource",
-  "add",
-  {
-    path: { type: "string", required: true, description: "Path to resource directory" }
-  },
-  ["path"]
-);
-var resourceSearch = def(
-  "resource",
-  "search",
-  {
-    query: { type: "string", required: false, description: "Search query" }
-  },
-  ["query"]
-);
-var resourceHas = def(
-  "resource",
-  "has",
-  {
-    locator: { type: "string", required: true, description: "Resource locator" }
-  },
-  ["locator"]
-);
-var resourceInfo = def(
-  "resource",
-  "info",
-  {
-    locator: { type: "string", required: true, description: "Resource locator" }
-  },
-  ["locator"]
-);
-var resourceRemove = def(
-  "resource",
-  "remove",
-  {
-    locator: { type: "string", required: true, description: "Resource locator" }
-  },
-  ["locator"]
-);
-var resourcePush = def(
-  "resource",
-  "push",
-  {
-    locator: { type: "string", required: true, description: "Resource locator" },
-    registry: { type: "string", required: false, description: "Registry URL (overrides default)" }
-  },
-  ["locator", { pack: ["registry"] }]
-);
-var resourcePull = def(
-  "resource",
-  "pull",
-  {
-    locator: { type: "string", required: true, description: "Resource locator" },
-    registry: { type: "string", required: false, description: "Registry URL (overrides default)" }
-  },
-  ["locator", { pack: ["registry"] }]
-);
-var resourceClearCache = def(
-  "resource",
-  "clearCache",
-  {
-    registry: { type: "string", required: false, description: "Registry to clear cache for" }
-  },
-  ["registry"]
-);
-
 // src/instructions/role.ts
 var roleActivate = def(
   "role",
@@ -1991,14 +1878,6 @@ var roleForget = def(
   },
   ["id", "individual"]
 );
-var roleSkill = def(
-  "role",
-  "skill",
-  {
-    locator: { type: "string", required: true, description: "ResourceX locator for the skill" }
-  },
-  ["locator"]
-);
 
 // src/instructions/society.ts
 var societyBorn = def(
@@ -2163,7 +2042,6 @@ var instructions = {
   "role.realize": roleRealize,
   "role.master": roleMaster,
   "role.forget": roleForget,
-  "role.skill": roleSkill,
   // org
   "org.charter": orgCharter,
   "org.hire": orgHire,
@@ -2205,15 +2083,6 @@ var instructions = {
   "survey.list": surveyList,
   // prototype
   "prototype.evict": prototypeEvict,
-  // resource
-  "resource.add": resourceAdd,
-  "resource.search": resourceSearch,
-  "resource.has": resourceHas,
-  "resource.info": resourceInfo,
-  "resource.remove": resourceRemove,
-  "resource.push": resourcePush,
-  "resource.pull": resourcePull,
-  "resource.clearCache": resourceClearCache,
   // issue
   "issue.publish": issuePublish,
   "issue.get": issueGet,
@@ -2678,7 +2547,7 @@ var processes = {
   deliver: "Feature: deliver \u2014 define a project deliverable\n  Define a deliverable for a project.\n  Deliverables describe the concrete outputs produced by the project.\n\n  Scenario: Define a deliverable\n    Given a project exists in society\n    And a Gherkin source describing the deliverable\n    When deliver is called on the project with a deliverable id\n    Then the deliverable is stored as the project's information\n\n  Scenario: Parameters\n    Given the command is project.deliver\n    Then project is required \u2014 the project's id\n    And content is required \u2014 Gherkin Feature source for the deliverable\n    And id is required \u2014 deliverable id (keywords joined by hyphens)\n\n  Scenario: Writing the deliverable Gherkin\n    Given the deliverable defines a concrete output of the project\n    Then the Feature title names the deliverable\n    And Scenarios describe acceptance criteria and specifications\n    And the tone is concrete \u2014 what is being produced and how it will be evaluated\n",
   deprecate: "Feature: deprecate \u2014 deprecate a product\n  Mark a product as deprecated.\n  The product is no longer actively maintained or recommended.\n\n  Scenario: Deprecate a product\n    Given a product exists in society\n    When deprecate is called on the product\n    Then the product is marked as deprecated\n\n  Scenario: Parameters\n    Given the command is product.deprecate\n    Then product is required \u2014 the product's id\n",
   die: "Feature: die \u2014 permanently archive an individual\n  Move an individual to the past archive with intent of permanence.\n  Technically identical to retire (data is preserved in past), but signals finality.\n  Use die when the individual is no longer needed (deprecated role, replaced).\n\n  Scenario: Archive an individual permanently\n    Given an individual exists in society\n    When die is called on the individual\n    Then the individual is moved to the past archive\n    And data is preserved but restoration is not intended\n\n  Scenario: Parameters\n    Given the command is society.die\n    Then individual is required \u2014 the individual's id\n\n  Scenario: retire vs die\n    Given both move the individual to past archive\n    Then retire signals temporary \u2014 may return later\n    And die signals permanent \u2014 not intended to return\n",
-  direct: 'Feature: direct \u2014 stateless world-level executor\n  Execute commands and load resources without an active role.\n  Direct operates as an anonymous observer \u2014 no role identity, no role context.\n  For operations as an active role, use the use tool instead.\n\n  Scenario: When to use "direct" vs "use"\n    Given no role is activated \u2014 I am an observer\n    When I need to query or operate on the world\n    Then direct is the right tool\n    And once a role is activated, use the use tool for role-level actions\n\n  Scenario: Execute a RoleX command\n    Given the locator starts with `!`\n    When direct is called with the locator and named args\n    Then the command is parsed as `namespace.method`\n    And dispatched to the corresponding RoleX API\n\n  Scenario: Load a ResourceX resource\n    Given the locator does not start with `!`\n    When direct is called with the locator\n    Then the locator is passed to ResourceX for resolution\n    And the resource is loaded and returned\n',
+  direct: "Feature: direct \u2014 world-level command executor\n  Execute RoleX world commands without an active role.\n  Direct operates as an anonymous observer \u2014 no role identity, no role context.\n  Use for administrative operations like society.born, org.hire, etc.\n\n  Scenario: Execute a world command\n    Given the command follows the namespace.method pattern\n    When direct is called with the command and named args\n    Then the command is dispatched to the corresponding RoleX API\n    And the result is returned\n",
   dismiss: "Feature: dismiss \u2014 remove from a position\n  Dismiss an individual from a position.\n  The individual remains a member of the organization.\n\n  Scenario: Dismiss an individual\n    Given an individual holds a position\n    When dismiss is called with the position and individual\n    Then the individual no longer holds the position\n    And the individual remains a member of the organization\n    And the position is now vacant\n\n  Scenario: Parameters\n    Given the command is position.dismiss\n    Then position is required \u2014 the position's id\n    And individual is required \u2014 the individual's id\n",
   disown: "Feature: disown \u2014 remove product owner\n  Remove an individual as an owner of a product.\n  The individual is no longer responsible for the product.\n\n  Scenario: Remove an owner\n    Given an individual is an owner of a product\n    When disown is called with the product and individual\n    Then the individual is no longer an owner of the product\n\n  Scenario: Parameters\n    Given the command is product.disown\n    Then product is required \u2014 the product's id\n    And individual is required \u2014 the individual's id (owner to remove)\n",
   dissolve: "Feature: dissolve \u2014 dissolve an organization\n  Move an organization to the past archive.\n  The organization and its subtree are archived, not deleted.\n\n  Scenario: Dissolve an organization\n    Given an organization exists in society\n    When dissolve is called on the organization\n    Then the organization is moved to the past archive\n    And the organization's subtree (charter, positions) is preserved in past\n\n  Scenario: Parameters\n    Given the command is society.dissolve\n    Then org is required \u2014 the organization's id\n",
@@ -2775,7 +2644,6 @@ var processes = {
   retire: "Feature: retire \u2014 archive an individual\n  Move an individual to the past archive.\n  All data is preserved \u2014 the individual can be rehired later with full history intact.\n  Use retire when the individual may return (sabbatical, role rotation).\n\n  Scenario: Retire an individual\n    Given an individual exists in society\n    When retire is called on the individual\n    Then the individual is moved to the past archive\n    And all knowledge, experience, and history are preserved\n    And the individual can be restored via rehire\n\n  Scenario: Parameters\n    Given the command is society.retire\n    Then individual is required \u2014 the individual's id\n",
   scope: "Feature: scope \u2014 define project scope\n  Define the scope for a project.\n  The scope describes the boundaries, inclusions, and exclusions of the project.\n\n  Scenario: Define project scope\n    Given a project exists in society\n    And a Gherkin source describing the scope\n    When scope is called on the project with a scope id\n    Then the scope is stored as the project's information\n\n  Scenario: Parameters\n    Given the command is project.scope\n    Then project is required \u2014 the project's id\n    And content is required \u2014 Gherkin Feature source for the scope\n    And id is required \u2014 scope id\n\n  Scenario: Writing the scope Gherkin\n    Given the scope defines the boundaries of a project\n    Then the Feature title names the scope area\n    And Scenarios describe what is included and excluded\n    And the tone is declarative \u2014 stating what the project covers\n",
   settle: "Feature: settle \u2014 register a prototype into the world\n  Pull a prototype from a ResourceX source and register it locally.\n  Once settled, the prototype can be used to create individuals or organizations.\n\n  Scenario: Settle a prototype\n    Given a valid ResourceX source exists (URL, path, or locator)\n    When settle is called with the source\n    Then the resource is ingested and its state is extracted\n    And the prototype is registered locally by its id\n    And the prototype is available for born, activate, and organizational use\n",
-  skill: "Feature: skill \u2014 load full skill content\n  Load the complete skill instructions by ResourceX locator.\n  This is progressive disclosure layer 2 \u2014 on-demand knowledge injection.\n\n  Scenario: Load a skill\n    Given a procedure exists in the role with a locator\n    When skill is called with the locator\n    Then the full SKILL.md content is loaded via ResourceX\n    And the content is injected into the AI's context\n    And the AI can now follow the skill's detailed instructions\n",
   spec: "Feature: spec \u2014 define product specification\n  Define a behavior contract (BDD specification) for a product.\n  Specs describe the expected behavior of the product in Gherkin format.\n\n  Scenario: Define a product spec\n    Given a product exists in society\n    And a Gherkin source describing the behavior contract\n    When spec is called on the product with a spec id\n    Then the spec is stored as the product's information\n\n  Scenario: Parameters\n    Given the command is product.spec\n    Then product is required \u2014 the product's id\n    And content is required \u2014 Gherkin Feature source for the behavior contract (BDD specification)\n    And id is required \u2014 spec id (keywords joined by hyphens)\n\n  Scenario: Writing the spec Gherkin\n    Given the spec defines expected product behavior\n    Then the Feature title names the behavior or capability\n    And Scenarios describe Given-When-Then acceptance criteria\n    And the tone is precise \u2014 specifying exactly what the product should do\n",
   strategy: "Feature: strategy \u2014 define product strategy\n  Define the strategy for a product.\n  The strategy describes the product's direction, positioning, and competitive approach.\n\n  Scenario: Define product strategy\n    Given a product exists in society\n    And a Gherkin source describing the strategy\n    When strategy is called on the product with a strategy id\n    Then the strategy is stored as the product's information\n\n  Scenario: Parameters\n    Given the command is product.strategy\n    Then product is required \u2014 the product's id\n    And content is required \u2014 Gherkin Feature source for the strategy\n    And id is required \u2014 strategy id\n\n  Scenario: Writing the strategy Gherkin\n    Given the strategy defines the product's direction\n    Then the Feature title names the strategy\n    And Scenarios describe positioning, target audience, and competitive approach\n    And the tone is strategic \u2014 articulating where the product is headed and why\n",
   survey: "Feature: survey \u2014 world-level overview\n  List all entities in the world: individuals, organizations, positions.\n  Works without an active role \u2014 a stateless world query.\n\n  Scenario: Survey the world\n    When survey is called without arguments\n    Then all individuals, organizations, and positions are returned\n\n  Scenario: Filter by type\n    When survey is called with a type parameter\n    Then only entities of that type are returned\n    And valid types are individual, organization, position, past\n",
@@ -2845,7 +2713,6 @@ var processes = {
 `,
   unadmin: "Feature: unadmin \u2014 revoke organization administrator\n  Revoke admin privileges from an individual within an organization.\n  The individual remains a member but loses management capabilities.\n\n  Scenario: Revoke admin\n    Given an individual is an admin of an organization\n    When unadmin is called with the organization and individual\n    Then the individual loses admin privileges\n    And the individual remains a member of the organization\n\n  Scenario: Parameters\n    Given the command is org.unadmin\n    Then org is required \u2014 the organization's id\n    And individual is required \u2014 the individual's id\n",
   unmaintain: "Feature: unmaintain \u2014 remove project maintainer\n  Remove maintainer role from an individual on a project.\n\n  Scenario: Remove a maintainer\n    Given an individual is a maintainer of a project\n    When unmaintain is called with the project and individual\n    Then the individual is no longer a maintainer of the project\n\n  Scenario: Parameters\n    Given the command is project.unmaintain\n    Then project is required \u2014 the project's id\n    And individual is required \u2014 the individual's id\n",
-  use: 'Feature: use \u2014 act as the current role\n  Execute commands and load resources as the active role.\n  Use requires an active role \u2014 the role is the subject performing the action.\n  For operations before activating a role, use the direct tool instead.\n\n  Scenario: When to use "use" vs "direct"\n    Given a role is activated \u2014 I am someone\n    When I perform operations through use\n    Then the operation happens in the context of my role\n    And use is for role-level actions \u2014 acting in the world as myself\n\n  Scenario: Execute a RoleX command\n    Given the locator starts with `!`\n    When use is called with the locator and named args\n    Then the command is parsed as `namespace.method`\n    And dispatched to the corresponding RoleX API\n\n  Scenario: Load a ResourceX resource\n    Given the locator does not start with `!`\n    When use is called with the locator\n    Then the locator is passed to ResourceX for resolution\n    And the resource is loaded and returned\n',
   want: 'Feature: want \u2014 declare a goal\n  Declare a new goal for a role.\n  A goal describes a desired outcome with Gherkin scenarios as success criteria.\n\n  Scenario: Declare a goal\n    Given an active role exists\n    And a Gherkin source describing the desired outcome\n    When want is called with the source\n    Then a new goal node is created under the role\n    And the goal becomes the current focus\n    And subsequent plan and todo operations target this goal\n\n  Scenario: Writing the goal Gherkin\n    Given the goal describes a desired outcome \u2014 what success looks like\n    Then the Feature title names the outcome in concrete terms\n    And Scenarios define success criteria \u2014 each scenario is a testable condition\n    And the tone is aspirational but specific \u2014 "users can log in" not "improve auth"\n',
   wiki: "Feature: wiki \u2014 add a wiki entry to a project\n  Add a wiki entry to a project.\n  Wiki entries capture knowledge, documentation, and reference material for the project.\n\n  Scenario: Add a wiki entry\n    Given a project exists in society\n    And a Gherkin source describing the wiki entry\n    When wiki is called on the project with a wiki entry id\n    Then the wiki entry is stored as the project's information\n\n  Scenario: Parameters\n    Given the command is project.wiki\n    Then project is required \u2014 the project's id\n    And content is required \u2014 Gherkin Feature source for the wiki entry\n    And id is required \u2014 wiki entry id (keywords joined by hyphens)\n\n  Scenario: Writing the wiki Gherkin\n    Given the wiki entry captures project knowledge\n    Then the Feature title names the topic\n    And Scenarios describe key facts, decisions, or reference material\n    And the tone is informational \u2014 documenting what is known\n"
 };
@@ -2986,8 +2853,6 @@ var RoleXService = class _RoleXService {
   rt;
   commands;
   project;
-  resourcex;
-  issuex;
   repo;
   initializer;
   renderer;
@@ -3008,15 +2873,6 @@ var RoleXService = class _RoleXService {
     this.initializer = platform.initializer;
     this.prototypes = prototypes ?? [];
     this.renderer = renderer;
-    if (platform.resourcexProvider) {
-      setProvider(platform.resourcexProvider);
-      this.resourcex = createResourceX(
-        platform.resourcexExecutor ? { isolator: "custom", executor: platform.resourcexExecutor } : void 0
-      );
-    }
-    if (platform.issuexProvider) {
-      this.issuex = createIssueX({ provider: platform.issuexProvider });
-    }
   }
   static async create(platform, renderer, prototypes) {
     const service = new _RoleXService(platform, renderer, prototypes);
@@ -3041,10 +2897,7 @@ var RoleXService = class _RoleXService {
       },
       find: (id) => this.find(id),
       project: this.project,
-      resourcex: this.resourcex,
-      issuex: this.issuex,
-      prototype: this.repo.prototype,
-      direct: (locator, args) => this.direct(locator, args, { raw: true })
+      prototype: this.repo.prototype
     });
     await this.initializer?.bootstrap();
     for (const proto of this.prototypes) {
@@ -3072,8 +2925,7 @@ var RoleXService = class _RoleXService {
     const role = new Role(individual2, {
       commands: this.commands,
       renderer: this.renderer,
-      onSave: (snapshot) => this.saveSnapshot(snapshot),
-      direct: (locator, args) => this.direct(locator, args)
+      onSave: (snapshot) => this.saveSnapshot(snapshot)
     });
     role.hydrate(state);
     await this.restoreSnapshot(role);
@@ -3142,27 +2994,23 @@ var RoleXService = class _RoleXService {
   // ================================================================
   async direct(locator, args, options) {
     const shouldRender = !options?.raw;
-    if (locator.startsWith("!")) {
-      const command = locator.slice(1);
-      const fn = this.commands[command];
-      if (!fn) {
-        const hint = directives["identity-ethics"]?.["on-unknown-command"] ?? "";
-        throw new Error(
-          `Unknown command "${locator}".
+    const command = locator.startsWith("!") ? locator.slice(1) : locator;
+    const fn = this.commands[command];
+    if (!fn) {
+      const hint = directives["identity-ethics"]?.["on-unknown-command"] ?? "";
+      throw new Error(
+        `Unknown command "${locator}".
 
 You may be guessing the command name. Load the relevant skill first with skill(locator) to learn the correct syntax.
 
 ` + hint
-        );
-      }
-      const result = await fn(...toArgs(command, args ?? {}));
-      if (shouldRender && isCommandResult(result)) {
-        return this.renderer.render(command, result);
-      }
-      return result;
+      );
+    }
+    const result = await fn(...toArgs(command, args ?? {}));
+    if (shouldRender && isCommandResult(result)) {
+      return this.renderer.render(command, result);
     }
-    if (!this.resourcex) throw new Error("ResourceX is not available.");
-    return this.resourcex.ingest(locator, args);
+    return result;
   }
   // ================================================================
   //  Internal helpers
@@ -3296,18 +3144,6 @@ function createIssueNamespace(call) {
     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");
@@ -3521,34 +3357,7 @@ var tools = [
       }
     }
   },
-  {
-    name: "skill",
-    description: d("skill"),
-    params: {
-      locator: {
-        type: "string",
-        required: true,
-        description: "ResourceX locator for the skill (e.g. deepractice/role-management)"
-      }
-    }
-  },
-  // --- Use / Direct ---
-  {
-    name: "use",
-    description: d("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 object for the command. Pass all parameters as key-value pairs in this object (e.g. id, content, org, individual). Must be a JSON object, not a string. Load the relevant skill first to learn what args to pass."
-      }
-    }
-  },
+  // --- Direct ---
   {
     name: "direct",
     description: d("direct"),
@@ -3556,12 +3365,12 @@ var tools = [
       command: {
         type: "string",
         required: true,
-        description: "!namespace.method for RoleX commands, or a ResourceX locator for resources"
+        description: "namespace.method for RoleX commands (e.g. society.born, org.hire)"
       },
       args: {
         type: "record",
         required: false,
-        description: "Named arguments object for the command. Pass all parameters as key-value pairs in this object (e.g. id, content, type). Must be a JSON object, not a string. Load the relevant skill first to learn what args to pass."
+        description: "Named arguments object for the command. Pass all parameters as key-value pairs in this object (e.g. id, content, org, individual). Must be a JSON object, not a string."
       }
     }
   }
@@ -3622,7 +3431,6 @@ function createBuilder(config) {
   const _project = createProjectNamespace(call);
   const _product = createProductNamespace(call);
   const _issue = createIssueNamespace(call);
-  const _resource = createResourceNamespace(call);
   return {
     get society() {
       return _society;
@@ -3645,9 +3453,6 @@ function createBuilder(config) {
     get issue() {
       return _issue;
     },
-    get resource() {
-      return _resource;
-    },
     async inspect({ id, raw }) {
       return call("inspect", { id, raw });
     },
@@ -3704,6 +3509,7 @@ export {
   charge,
   charter,
   charterOrg,
+  comment,
   complete,
   create6 as create,
   createBuilder,
@@ -3731,6 +3537,7 @@ export {
   identity,
   individual,
   instructions,
+  issue,
   launch,
   link4 as link,
   master,