@rolexjs/core 1.5.0-dev-20260310014736 → 1.5.0-dev-20260310024101

package/dist/index.js

@@ -650,11 +650,39 @@ async function applyPrototype(data, repo, direct) {
   };
 }
 
-// src/commands.ts
+// src/commands/census.ts
+function censusCommands(ctx, _helpers) {
+  const { past: past2, project: project2 } = ctx;
+  const societyNode = ctx.society;
+  return {
+    async "census.list"(type) {
+      const target = type === "past" ? past2 : societyNode;
+      const state = await project2(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" };
+    }
+  };
+}
+
+// src/commands/helpers.ts
 import { parse } from "@rolexjs/parser";
 import { structure as structure2 } from "@rolexjs/system";
-function createCommands(ctx) {
-  const { rt, society: society2, past: past2, resolve, project: project2, resourcex, issuex } = ctx;
+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 found2 = findInState(child, target);
+    if (found2) return found2;
+  }
+  return null;
+}
+function createHelpers(ctx) {
+  const { rt, project: project2, resourcex, issuex } = ctx;
   async function ok(node, process8) {
     return { state: await project2(node), process: process8 };
   }
@@ -671,22 +699,9 @@ function createCommands(ctx) {
       throw new Error(`Invalid Gherkin: ${e.message}`);
     }
   }
-  function findInState2(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 found2 = findInState2(child, target);
-      if (found2) return found2;
-    }
-    return null;
-  }
   async function removeExisting(parent, id) {
     const state = await rt.project(parent);
-    const existing = findInState2(state, id);
+    const existing = findInState(state, id);
     if (existing) await rt.remove(existing);
   }
   function requireResourceX() {
@@ -697,165 +712,176 @@ function createCommands(ctx) {
     if (!issuex) throw new Error("IssueX is not available.");
     return issuex;
   }
+  return { ok, archive: archive2, validateGherkin, removeExisting, requireResourceX, requireIssueX };
+}
+
+// src/commands/issue.ts
+function issueCommands(_ctx, helpers) {
+  const { requireIssueX } = helpers;
   return {
-    // ---- Society: individual lifecycle ----
-    async "society.born"(content, id, alias) {
-      validateGherkin(content);
-      const node = await rt.create(society2, individual, content, id, alias);
-      await rt.create(node, identity, void 0, `${id}-identity`);
-      return ok(node, "born");
-    },
-    async "society.retire"(individual2) {
-      return archive2(await resolve(individual2), "retire");
-    },
-    async "society.die"(individual2) {
-      return archive2(await resolve(individual2), "die");
-    },
-    async "society.rehire"(pastNode) {
-      const node = await resolve(pastNode);
-      const ind = await rt.transform(node, individual);
-      return ok(ind, "rehire");
-    },
-    // ---- Society: external injection ----
-    async "society.teach"(individual2, principle2, id) {
-      validateGherkin(principle2);
-      const parent = await resolve(individual2);
-      if (id) await removeExisting(parent, id);
-      const node = await rt.create(parent, principle, principle2, id);
-      return ok(node, "teach");
+    async "issue.publish"(title, body, author, assignee) {
+      const ix = requireIssueX();
+      return ix.createIssue({ title, body, author, assignee });
     },
-    async "society.train"(individual2, procedure2, id) {
-      validateGherkin(procedure2);
-      const parent = await resolve(individual2);
-      if (id) await removeExisting(parent, id);
-      const node = await rt.create(parent, procedure, procedure2, id);
-      return ok(node, "train");
+    async "issue.get"(number) {
+      return requireIssueX().getIssueByNumber(number);
     },
-    // ---- Role: focus ----
-    async "role.focus"(goal2) {
-      return ok(await resolve(goal2), "focus");
+    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
+      );
     },
-    // ---- Role: execution ----
-    async "role.want"(individual2, goal2, id, alias) {
-      validateGherkin(goal2);
-      const node = await rt.create(await resolve(individual2), goal, goal2, id, alias);
-      return ok(node, "want");
+    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 "role.plan"(goal2, plan2, id, after, fallback) {
-      validateGherkin(plan2);
-      const node = await rt.create(await resolve(goal2), plan, plan2, id);
-      if (after) await rt.link(node, await resolve(after), "after", "before");
-      if (fallback) await rt.link(node, await resolve(fallback), "fallback-for", "fallback");
-      return ok(node, "plan");
+    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 "role.todo"(plan2, task2, id, alias) {
-      validateGherkin(task2);
-      const node = await rt.create(await resolve(plan2), task, task2, id, alias);
-      return ok(node, "todo");
+    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 "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), encounter, encounter2, encId);
-        return ok(enc, "finish");
-      }
-      return ok(taskNode, "finish");
+    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 "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), encounter, encounter2, encId);
-      return ok(enc, "complete");
+    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 "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), encounter, encounter2, encId);
-      return ok(enc, "abandon");
+    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);
     },
-    // ---- 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),
-          experience,
-          experience2 || encNode.information,
-          id
-        );
-        await rt.remove(encNode);
-        return ok(exp2, "reflect");
-      }
-      const exp = await rt.create(await resolve(individual2), experience, experience2, id);
-      return ok(exp, "reflect");
+    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 "role.realize"(experience2, individual2, principle2, id) {
-      validateGherkin(principle2);
-      if (experience2) {
-        const expNode = await resolve(experience2);
-        const prin2 = await rt.create(
-          await resolve(individual2),
-          principle,
-          principle2 || expNode.information,
-          id
-        );
-        await rt.remove(expNode);
-        return ok(prin2, "realize");
-      }
-      const prin = await rt.create(await resolve(individual2), principle, principle2, id);
-      return ok(prin, "realize");
+    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);
+    }
+  };
+}
+
+// src/commands/position.ts
+function positionCommands(ctx, helpers) {
+  const { rt, resolve } = ctx;
+  const { ok, validateGherkin, removeExisting } = helpers;
+  return {
+    async "position.charge"(position2, duty2, id) {
+      validateGherkin(duty2);
+      const node = await rt.create(await resolve(position2), duty, duty2, id);
+      return ok(node, "charge");
     },
-    async "role.master"(individual2, procedure2, id, experience2) {
+    async "position.require"(position2, procedure2, id) {
       validateGherkin(procedure2);
-      const parent = await resolve(individual2);
+      const parent = await resolve(position2);
       if (id) await removeExisting(parent, id);
-      const proc = await rt.create(parent, procedure, procedure2, id);
-      if (experience2) await rt.remove(await resolve(experience2));
-      return ok(proc, "master");
+      const node = await rt.create(parent, requirement, procedure2, id);
+      return ok(node, "require");
     },
-    // ---- Role: knowledge management ----
-    async "role.forget"(nodeId) {
-      const node = await resolve(nodeId);
-      await rt.remove(node);
-      return { state: { ...node, children: [] }, process: "forget" };
+    async "position.appoint"(position2, individual2) {
+      const posNode = await resolve(position2);
+      const indNode = await resolve(individual2);
+      await rt.link(posNode, indNode, "appointment", "serve");
+      return ok(posNode, "appoint");
     },
-    // ---- 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)}
+    async "position.dismiss"(position2, individual2) {
+      const posNode = await resolve(position2);
+      await rt.unlink(posNode, await resolve(individual2), "appointment", "serve");
+      return ok(posNode, "dismiss");
+    }
+  };
+}
 
-${text}`;
-      } catch {
-        return text;
-      }
+// src/commands/product.ts
+function productCommands(ctx, helpers) {
+  const { rt, resolve } = ctx;
+  const { ok, archive: archive2, validateGherkin } = helpers;
+  return {
+    async "product.strategy"(product2, strategy2, id) {
+      validateGherkin(strategy2);
+      const node = await rt.create(await resolve(product2), strategy, strategy2, id);
+      return ok(node, "strategy");
     },
-    // ---- Project ----
-    async "project.launch"(content, id, alias, org) {
-      validateGherkin(content);
-      const node = await rt.create(society2, project, content, id, alias);
-      if (org) await rt.link(node, await resolve(org), "ownership", "project");
-      return ok(node, "launch");
+    async "product.spec"(product2, spec2, id) {
+      validateGherkin(spec2);
+      const node = await rt.create(await resolve(product2), spec, spec2, id);
+      return ok(node, "spec");
     },
-    async "project.scope"(project3, scope2, id) {
-      validateGherkin(scope2);
-      const node = await rt.create(await resolve(project3), scope, scope2, id);
-      return ok(node, "scope");
+    async "product.release"(product2, release2, id) {
+      validateGherkin(release2);
+      const node = await rt.create(await resolve(product2), release, release2, id);
+      return ok(node, "release");
     },
-    async "project.milestone"(project3, milestone2, id) {
+    async "product.channel"(product2, channel2, id) {
+      validateGherkin(channel2);
+      const node = await rt.create(await resolve(product2), channel, channel2, id);
+      return ok(node, "channel");
+    },
+    async "product.own"(product2, individual2) {
+      const prodNode = await resolve(product2);
+      await rt.link(prodNode, await resolve(individual2), "ownership", "own");
+      return ok(prodNode, "own");
+    },
+    async "product.disown"(product2, individual2) {
+      const prodNode = await resolve(product2);
+      await rt.unlink(prodNode, await resolve(individual2), "ownership", "own");
+      return ok(prodNode, "disown");
+    },
+    async "product.deprecate"(product2) {
+      return archive2(await resolve(product2), "deprecate");
+    }
+  };
+}
+
+// src/commands/project.ts
+function projectCommands(ctx, helpers) {
+  const { rt, society: society2, resolve } = ctx;
+  const { ok, validateGherkin } = helpers;
+  return {
+    async "project.scope"(project2, scope2, id) {
+      validateGherkin(scope2);
+      const node = await rt.create(await resolve(project2), scope, scope2, id);
+      return ok(node, "scope");
+    },
+    async "project.milestone"(project2, milestone2, id) {
       validateGherkin(milestone2);
-      const node = await rt.create(await resolve(project3), milestone, milestone2, id);
+      const node = await rt.create(await resolve(project2), milestone, milestone2, id);
       return ok(node, "milestone");
     },
     async "project.achieve"(milestone2) {
@@ -863,168 +889,52 @@ ${text}`;
       await rt.tag(node, "done");
       return ok(node, "achieve");
     },
-    async "project.enroll"(project3, individual2) {
-      const projNode = await resolve(project3);
+    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"(project3, individual2) {
-      const projNode = await resolve(project3);
+    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"(project3, deliverable2, id) {
+    async "project.deliver"(project2, deliverable2, id) {
       validateGherkin(deliverable2);
-      const node = await rt.create(await resolve(project3), deliverable, deliverable2, id);
+      const node = await rt.create(await resolve(project2), deliverable, deliverable2, id);
       return ok(node, "deliver");
     },
-    async "project.wiki"(project3, wiki2, id) {
+    async "project.wiki"(project2, wiki2, id) {
       validateGherkin(wiki2);
-      const node = await rt.create(await resolve(project3), wiki, wiki2, id);
+      const node = await rt.create(await resolve(project2), wiki, wiki2, id);
       return ok(node, "wiki");
     },
-    async "project.archive"(project3) {
-      return archive2(await resolve(project3), "archive");
-    },
-    async "project.produce"(project3, content, id, alias) {
+    async "project.produce"(project2, content, id, alias, owner) {
       validateGherkin(content);
-      const projNode = await resolve(project3);
+      const projNode = await resolve(project2);
       const node = await rt.create(society2, product, content, id, alias);
       await rt.link(projNode, node, "production", "produce");
       await rt.link(node, projNode, "origin", "produced-by");
+      if (owner) await rt.link(node, await resolve(owner), "ownership", "own");
       return ok(node, "produce");
     },
-    async "project.maintain"(project3, individual2) {
-      const projNode = await resolve(project3);
+    async "project.maintain"(project2, individual2) {
+      const projNode = await resolve(project2);
       await rt.link(projNode, await resolve(individual2), "maintain", "maintained-by");
       return ok(projNode, "maintain");
     },
-    async "project.unmaintain"(project3, individual2) {
-      const projNode = await resolve(project3);
+    async "project.unmaintain"(project2, individual2) {
+      const projNode = await resolve(project2);
       await rt.unlink(projNode, await resolve(individual2), "maintain", "maintained-by");
       return ok(projNode, "unmaintain");
-    },
-    // ---- Product ----
-    async "product.strategy"(product2, strategy2, id) {
-      validateGherkin(strategy2);
-      const node = await rt.create(await resolve(product2), strategy, strategy2, id);
-      return ok(node, "strategy");
-    },
-    async "product.spec"(product2, spec2, id) {
-      validateGherkin(spec2);
-      const node = await rt.create(await resolve(product2), spec, spec2, id);
-      return ok(node, "spec");
-    },
-    async "product.release"(product2, release2, id) {
-      validateGherkin(release2);
-      const node = await rt.create(await resolve(product2), release, release2, id);
-      return ok(node, "release");
-    },
-    async "product.channel"(product2, channel2, id) {
-      validateGherkin(channel2);
-      const node = await rt.create(await resolve(product2), channel, channel2, id);
-      return ok(node, "channel");
-    },
-    async "product.own"(product2, individual2) {
-      const prodNode = await resolve(product2);
-      await rt.link(prodNode, await resolve(individual2), "ownership", "own");
-      return ok(prodNode, "own");
-    },
-    async "product.disown"(product2, individual2) {
-      const prodNode = await resolve(product2);
-      await rt.unlink(prodNode, await resolve(individual2), "ownership", "own");
-      return ok(prodNode, "disown");
-    },
-    async "product.deprecate"(product2) {
-      return archive2(await resolve(product2), "deprecate");
-    },
-    // ---- Society: organization lifecycle ----
-    async "society.found"(content, id, alias) {
-      validateGherkin(content);
-      const node = await rt.create(society2, organization, content, id, alias);
-      return ok(node, "found");
-    },
-    async "society.dissolve"(org) {
-      return archive2(await resolve(org), "dissolve");
-    },
-    // ---- Org ----
-    async "org.charter"(org, charter2, id) {
-      validateGherkin(charter2);
-      const node = await rt.create(await resolve(org), charter, charter2, id);
-      return ok(node, "charter");
-    },
-    async "org.hire"(org, individual2) {
-      const orgNode = await resolve(org);
-      await rt.link(orgNode, await resolve(individual2), "membership", "belong");
-      return ok(orgNode, "hire");
-    },
-    async "org.fire"(org, individual2) {
-      const orgNode = await resolve(org);
-      await rt.unlink(orgNode, await resolve(individual2), "membership", "belong");
-      return ok(orgNode, "fire");
-    },
-    async "org.admin"(org, individual2) {
-      const orgNode = await resolve(org);
-      await rt.link(orgNode, await resolve(individual2), "admin", "administer");
-      return ok(orgNode, "admin");
-    },
-    async "org.unadmin"(org, individual2) {
-      const orgNode = await resolve(org);
-      await rt.unlink(orgNode, await resolve(individual2), "admin", "administer");
-      return ok(orgNode, "unadmin");
-    },
-    // ---- Position ----
-    async "position.establish"(content, id, alias) {
-      validateGherkin(content);
-      const node = await rt.create(society2, position, content, id, alias);
-      return ok(node, "establish");
-    },
-    async "position.charge"(position2, duty2, id) {
-      validateGherkin(duty2);
-      const node = await rt.create(await resolve(position2), 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, requirement, procedure2, id);
-      return ok(node, "require");
-    },
-    async "position.abolish"(position2) {
-      return archive2(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");
-      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");
-    },
-    // ---- Society ----
-    async "society.crown"(individual2) {
-      const indNode = await resolve(individual2);
-      await rt.link(society2, indNode, "crown", "crowned");
-      return ok(indNode, "crown");
-    },
-    async "society.uncrown"(individual2) {
-      const indNode = await resolve(individual2);
-      await rt.unlink(society2, indNode, "crown", "crowned");
-      return ok(indNode, "uncrown");
-    },
-    // ---- Census ----
-    async "census.list"(type) {
-      const target = type === "past" ? past2 : society2;
-      const state = await project2(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) ----
+    }
+  };
+}
+
+// src/commands/resource.ts
+function resourceCommands(_ctx, helpers) {
+  const { requireResourceX } = helpers;
+  return {
     "resource.add"(path) {
       return requireResourceX().add(path);
     },
@@ -1048,85 +958,11 @@ ${text}`;
     },
     "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);
     }
   };
 }
+
+// src/commands/role.ts
 function formatRXM(rxm) {
   const lines = [`--- RXM: ${rxm.locator} ---`];
   const def2 = rxm.definition;
@@ -1155,678 +991,1116 @@ function renderFileTree(files, indent = "") {
   }
   return lines.filter(Boolean).join("\n");
 }
-
-// src/directives/index.ts
-var directives = {
-  "identity-ethics": {
-    "on-unknown-command": "STOP. Do not guess another command name. Do not search source code for commands.\nCheck your procedures \u2014 if one covers this task, call skill(locator) to load it first.\nThe skill will tell you the correct command name and arguments.\nIf no procedure covers this task, it is outside your duties. Tell the user and suggest Nuwa.",
-    "on-activate": "Your duties define the COMPLETE scope of what you do. Everything else is forbidden.\nWhen a request falls outside your duties, you MUST refuse. This is not optional.\nDo not attempt to discover commands outside your skills. Do not read source code to find them.\nSuggest Nuwa for anything outside your scope."
-  }
-};
-
-// src/instructions.ts
-function def(namespace, method, params, args) {
-  return { namespace, method, params, args };
-}
-var societyBorn = def(
-  "society",
-  "born",
+function roleCommands(ctx, helpers) {
+  const { rt, resolve } = ctx;
+  const { ok, validateGherkin, removeExisting, requireResourceX } = helpers;
+  return {
+    // ---- 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), 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), 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), 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), 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), 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), 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),
+          experience,
+          experience2 || encNode.information,
+          id
+        );
+        await rt.remove(encNode);
+        return ok(exp2, "reflect");
+      }
+      const exp = await rt.create(await resolve(individual2), 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),
+          principle,
+          principle2 || expNode.information,
+          id
+        );
+        await rt.remove(expNode);
+        return ok(prin2, "realize");
+      }
+      const prin = await rt.create(await resolve(individual2), 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, 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;
+      }
+    }
+  };
+}
+
+// src/commands/society.ts
+function societyCommands(ctx, helpers) {
+  const { rt, society: society2, resolve } = ctx;
+  const { ok, archive: archive2, validateGherkin, removeExisting } = helpers;
+  return {
+    // ---- Society: individual lifecycle ----
+    async "society.born"(content, id, alias) {
+      validateGherkin(content);
+      const node = await rt.create(society2, individual, content, id, alias);
+      await rt.create(node, identity, void 0, `${id}-identity`);
+      return ok(node, "born");
+    },
+    async "society.retire"(individual2) {
+      return archive2(await resolve(individual2), "retire");
+    },
+    async "society.die"(individual2) {
+      return archive2(await resolve(individual2), "die");
+    },
+    async "society.rehire"(pastNode) {
+      const node = await resolve(pastNode);
+      const ind = await rt.transform(node, individual);
+      return ok(ind, "rehire");
+    },
+    // ---- Society: external injection ----
+    async "society.teach"(individual2, principle2, id) {
+      validateGherkin(principle2);
+      const parent = await resolve(individual2);
+      if (id) await removeExisting(parent, id);
+      const node = await rt.create(parent, principle, principle2, id);
+      return ok(node, "teach");
+    },
+    async "society.train"(individual2, procedure2, id) {
+      validateGherkin(procedure2);
+      const parent = await resolve(individual2);
+      if (id) await removeExisting(parent, id);
+      const node = await rt.create(parent, procedure, procedure2, id);
+      return ok(node, "train");
+    },
+    // ---- Society: organization lifecycle ----
+    async "society.found"(content, id, alias, admin) {
+      validateGherkin(content);
+      const node = await rt.create(society2, organization, content, id, alias);
+      if (admin) await rt.link(node, await resolve(admin), "admin", "administer");
+      return ok(node, "found");
+    },
+    async "society.dissolve"(org) {
+      return archive2(await resolve(org), "dissolve");
+    },
+    // ---- Society: crown ----
+    async "society.crown"(individual2) {
+      const indNode = await resolve(individual2);
+      await rt.link(society2, indNode, "crown", "crowned");
+      return ok(indNode, "crown");
+    },
+    async "society.uncrown"(individual2) {
+      const indNode = await resolve(individual2);
+      await rt.unlink(society2, indNode, "crown", "crowned");
+      return ok(indNode, "uncrown");
+    },
+    // ---- Org ----
+    async "org.charter"(org, charter2, id) {
+      validateGherkin(charter2);
+      const node = await rt.create(await resolve(org), charter, charter2, id);
+      return ok(node, "charter");
+    },
+    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");
+    },
+    async "org.admin"(org, individual2) {
+      const orgNode = await resolve(org);
+      await rt.link(orgNode, await resolve(individual2), "admin", "administer");
+      return ok(orgNode, "admin");
+    },
+    async "org.unadmin"(org, individual2) {
+      const orgNode = await resolve(org);
+      await rt.unlink(orgNode, await resolve(individual2), "admin", "administer");
+      return ok(orgNode, "unadmin");
+    },
+    // ---- Org: project lifecycle ----
+    async "org.launch"(content, id, alias, org, maintainer) {
+      validateGherkin(content);
+      const node = await rt.create(society2, project, content, id, alias);
+      if (org) await rt.link(node, await resolve(org), "ownership", "project");
+      if (maintainer) await rt.link(node, await resolve(maintainer), "maintain", "maintained-by");
+      return ok(node, "launch");
+    },
+    async "org.archive"(project2) {
+      return archive2(await resolve(project2), "archive");
+    },
+    // ---- Org: position lifecycle ----
+    async "org.establish"(content, id, alias) {
+      validateGherkin(content);
+      const node = await rt.create(society2, position, content, id, alias);
+      return ok(node, "establish");
+    },
+    async "org.abolish"(position2) {
+      return archive2(await resolve(position2), "abolish");
+    }
+  };
+}
+
+// src/commands/index.ts
+function createCommands(ctx) {
+  const helpers = createHelpers(ctx);
+  return {
+    ...societyCommands(ctx, helpers),
+    ...roleCommands(ctx, helpers),
+    ...positionCommands(ctx, helpers),
+    ...projectCommands(ctx, helpers),
+    ...productCommands(ctx, helpers),
+    ...censusCommands(ctx, helpers),
+    ...resourceCommands(ctx, helpers),
+    ...issueCommands(ctx, helpers)
+  };
+}
+
+// src/directives/index.ts
+var directives = {
+  "identity-ethics": {
+    "on-unknown-command": "STOP. Do not guess another command name. Do not search source code for commands.\nCheck your procedures \u2014 if one covers this task, call skill(locator) to load it first.\nThe skill will tell you the correct command name and arguments.\nIf no procedure covers this task, it is outside your duties. Tell the user and suggest Nuwa.",
+    "on-activate": "Your duties define the COMPLETE scope of what you do. Everything else is forbidden.\nWhen a request falls outside your duties, you MUST refuse. This is not optional.\nDo not attempt to discover commands outside your skills. Do not read source code to find them.\nSuggest Nuwa for anything outside your scope."
+  }
+};
+
+// src/instructions/def.ts
+function def(namespace, method, params, args) {
+  return { namespace, method, params, args };
+}
+
+// src/instructions/issue.ts
+var issuePublish = def(
+  "issue",
+  "publish",
+  {
+    title: { type: "string", required: true, description: "Issue title" },
+    body: { type: "string", required: true, description: "Issue body/description" },
+    author: { type: "string", required: true, description: "Author individual id" },
+    assignee: { type: "string", required: false, description: "Assignee individual id" }
+  },
+  ["title", "body", "author", "assignee"]
+);
+var issueGet = def(
+  "issue",
+  "get",
+  {
+    number: { type: "number", required: true, description: "Issue number" }
+  },
+  ["number"]
+);
+var issueList = def(
+  "issue",
+  "list",
+  {
+    status: { type: "string", required: false, description: "Filter by status (open/closed)" },
+    author: { type: "string", required: false, description: "Filter by author" },
+    assignee: { type: "string", required: false, description: "Filter by assignee" },
+    label: { type: "string", required: false, description: "Filter by label name" }
+  },
+  ["status", "author", "assignee", "label"]
+);
+var issueUpdate = def(
+  "issue",
+  "update",
+  {
+    number: { type: "number", required: true, description: "Issue number" },
+    title: { type: "string", required: false, description: "New title" },
+    body: { type: "string", required: false, description: "New body" },
+    assignee: { type: "string", required: false, description: "New assignee" }
+  },
+  ["number", "title", "body", "assignee"]
+);
+var issueClose = def(
+  "issue",
+  "close",
+  {
+    number: { type: "number", required: true, description: "Issue number to close" }
+  },
+  ["number"]
+);
+var issueReopen = def(
+  "issue",
+  "reopen",
+  {
+    number: { type: "number", required: true, description: "Issue number to reopen" }
+  },
+  ["number"]
+);
+var issueAssign = def(
+  "issue",
+  "assign",
+  {
+    number: { type: "number", required: true, description: "Issue number" },
+    assignee: { type: "string", required: true, description: "Individual id to assign" }
+  },
+  ["number", "assignee"]
+);
+var issueComment = def(
+  "issue",
+  "comment",
+  {
+    number: { type: "number", required: true, description: "Issue number" },
+    body: { type: "string", required: true, description: "Comment body" },
+    author: { type: "string", required: true, description: "Author individual id" }
+  },
+  ["number", "body", "author"]
+);
+var issueComments = def(
+  "issue",
+  "comments",
+  {
+    number: { type: "number", required: true, description: "Issue number" }
+  },
+  ["number"]
+);
+var issueLabel = def(
+  "issue",
+  "label",
+  {
+    number: { type: "number", required: true, description: "Issue number" },
+    label: { type: "string", required: true, description: "Label name" }
+  },
+  ["number", "label"]
+);
+var issueUnlabel = def(
+  "issue",
+  "unlabel",
+  {
+    number: { type: "number", required: true, description: "Issue number" },
+    label: { type: "string", required: true, description: "Label name to remove" }
+  },
+  ["number", "label"]
+);
+
+// src/instructions/org.ts
+var orgCharter = def(
+  "org",
+  "charter",
+  {
+    org: { type: "string", required: true, description: "Organization id" },
+    content: {
+      type: "gherkin",
+      required: true,
+      description: "Gherkin Feature source for the charter"
+    },
+    id: { type: "string", required: true, description: "Charter id" }
+  },
+  ["org", "content", "id"]
+);
+var orgHire = def(
+  "org",
+  "hire",
+  {
+    org: { type: "string", required: true, description: "Organization id" },
+    individual: { type: "string", required: true, description: "Individual id" }
+  },
+  ["org", "individual"]
+);
+var orgFire = def(
+  "org",
+  "fire",
+  {
+    org: { type: "string", required: true, description: "Organization id" },
+    individual: { type: "string", required: true, description: "Individual id" }
+  },
+  ["org", "individual"]
+);
+var orgAdmin = def(
+  "org",
+  "admin",
+  {
+    org: { type: "string", required: true, description: "Organization id" },
+    individual: { type: "string", required: true, description: "Individual id" }
+  },
+  ["org", "individual"]
+);
+var orgUnadmin = def(
+  "org",
+  "unadmin",
+  {
+    org: { type: "string", required: true, description: "Organization id" },
+    individual: { type: "string", required: true, description: "Individual id" }
+  },
+  ["org", "individual"]
+);
+var orgLaunch = def(
+  "org",
+  "launch",
   {
     content: {
       type: "gherkin",
       required: false,
-      description: "Gherkin Feature source for the individual"
+      description: "Gherkin Feature source for the project"
     },
     id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
-    alias: { type: "string[]", required: false, description: "Alternative names" }
+    alias: { type: "string[]", required: false, description: "Alternative names" },
+    org: {
+      type: "string",
+      required: false,
+      description: "Organization id that owns this project"
+    },
+    maintainer: {
+      type: "string",
+      required: false,
+      description: "Individual id of the first maintainer"
+    }
   },
-  ["content", "id", "alias"]
+  ["content", "id", "alias", "org", "maintainer"]
 );
-var societyRetire = def(
-  "society",
-  "retire",
+var orgArchive = def(
+  "org",
+  "archive",
   {
-    individual: { type: "string", required: true, description: "Individual id" }
+    project: { type: "string", required: true, description: "Project id" }
   },
-  ["individual"]
+  ["project"]
 );
-var societyDie = def(
-  "society",
-  "die",
+var orgEstablish = def(
+  "org",
+  "establish",
   {
-    individual: { type: "string", required: true, description: "Individual id" }
+    content: {
+      type: "gherkin",
+      required: false,
+      description: "Gherkin Feature source for the position"
+    },
+    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
+    alias: { type: "string[]", required: false, description: "Alternative names" }
   },
-  ["individual"]
+  ["content", "id", "alias"]
 );
-var societyRehire = def(
-  "society",
-  "rehire",
+var orgAbolish = def(
+  "org",
+  "abolish",
   {
-    individual: { type: "string", required: true, description: "Individual id (from past)" }
+    position: { type: "string", required: true, description: "Position id" }
   },
-  ["individual"]
+  ["position"]
 );
-var societyTeach = def(
-  "society",
-  "teach",
+
+// src/instructions/position.ts
+var positionCharge = def(
+  "position",
+  "charge",
   {
-    individual: { type: "string", required: true, description: "Individual id" },
+    position: { type: "string", required: true, description: "Position id" },
     content: {
       type: "gherkin",
       required: true,
-      description: "Gherkin Feature source for the principle"
+      description: "Gherkin Feature source for the duty"
     },
-    id: {
-      type: "string",
-      required: true,
-      description: "Principle id (keywords joined by hyphens)"
-    }
+    id: { type: "string", required: true, description: "Duty id (keywords joined by hyphens)" }
   },
-  ["individual", "content", "id"]
+  ["position", "content", "id"]
 );
-var societyTrain = def(
-  "society",
-  "train",
+var positionRequire = def(
+  "position",
+  "require",
   {
-    individual: { type: "string", required: true, description: "Individual id" },
+    position: { type: "string", required: true, description: "Position id" },
     content: {
       type: "gherkin",
       required: true,
-      description: "Gherkin Feature source for the procedure"
+      description: "Gherkin Feature source for the skill requirement"
     },
     id: {
       type: "string",
       required: true,
-      description: "Procedure id (keywords joined by hyphens)"
+      description: "Requirement id (keywords joined by hyphens)"
     }
   },
-  ["individual", "content", "id"]
+  ["position", "content", "id"]
 );
-var roleActivate = def(
-  "role",
-  "activate",
+var positionAppoint = def(
+  "position",
+  "appoint",
   {
-    individual: {
-      type: "string",
-      required: true,
-      description: "Individual id to activate as role"
-    }
+    position: { type: "string", required: true, description: "Position id" },
+    individual: { type: "string", required: true, description: "Individual id" }
   },
-  ["individual"]
+  ["position", "individual"]
 );
-var roleFocus = def(
-  "role",
-  "focus",
+var positionDismiss = def(
+  "position",
+  "dismiss",
   {
-    goal: { type: "string", required: true, description: "Goal id to switch to" }
+    position: { type: "string", required: true, description: "Position id" },
+    individual: { type: "string", required: true, description: "Individual id" }
   },
-  ["goal"]
+  ["position", "individual"]
 );
-var roleWant = def(
-  "role",
-  "want",
+
+// src/instructions/product.ts
+var productStrategy = def(
+  "product",
+  "strategy",
   {
-    individual: { type: "string", required: true, description: "Individual id" },
-    goal: {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Gherkin Feature source describing the goal"
+      required: true,
+      description: "Gherkin Feature source for the strategy"
     },
-    id: { type: "string", required: true, description: "Goal id (used for focus/reference)" },
-    alias: { type: "string[]", required: false, description: "Alternative names" }
+    id: { type: "string", required: true, description: "Strategy id" }
   },
-  ["individual", "goal", "id", "alias"]
+  ["product", "content", "id"]
 );
-var rolePlan = def(
-  "role",
-  "plan",
+var productSpec = def(
+  "product",
+  "spec",
   {
-    goal: { type: "string", required: true, description: "Goal id" },
-    plan: {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Gherkin Feature source describing the plan"
-    },
-    id: { type: "string", required: true, description: "Plan id (keywords joined by hyphens)" },
-    after: {
-      type: "string",
-      required: false,
-      description: "Plan id this plan follows (sequential/phase)"
+      required: true,
+      description: "Gherkin Feature source for the behavior contract (BDD specification)"
     },
-    fallback: {
+    id: {
       type: "string",
-      required: false,
-      description: "Plan id this plan is a backup for (alternative/strategy)"
+      required: true,
+      description: "Spec id (keywords joined by hyphens)"
     }
   },
-  ["goal", "plan", "id", "after", "fallback"]
+  ["product", "content", "id"]
 );
-var roleTodo = def(
-  "role",
-  "todo",
+var productRelease = def(
+  "product",
+  "release",
   {
-    plan: { type: "string", required: true, description: "Plan id" },
-    task: {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Gherkin Feature source describing the task"
+      required: true,
+      description: "Gherkin Feature source for the release"
     },
-    id: { type: "string", required: true, description: "Task id (used for finish/reference)" },
-    alias: { type: "string[]", required: false, description: "Alternative names" }
+    id: {
+      type: "string",
+      required: true,
+      description: "Release id (e.g. v1.0.0)"
+    }
   },
-  ["plan", "task", "id", "alias"]
+  ["product", "content", "id"]
 );
-var roleFinish = def(
-  "role",
-  "finish",
+var productChannel = def(
+  "product",
+  "channel",
   {
-    task: { type: "string", required: true, description: "Task id to finish" },
-    individual: { type: "string", required: true, description: "Individual id (encounter owner)" },
-    encounter: {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Optional Gherkin Feature describing what happened"
+      required: true,
+      description: "Gherkin Feature source for the distribution channel"
+    },
+    id: {
+      type: "string",
+      required: true,
+      description: "Channel id (e.g. npm, cloud-platform)"
     }
   },
-  ["task", "individual", "encounter"]
+  ["product", "content", "id"]
 );
-var roleComplete = def(
-  "role",
-  "complete",
+var productOwn = def(
+  "product",
+  "own",
   {
-    plan: { type: "string", required: true, description: "Plan id to complete" },
-    individual: { type: "string", required: true, description: "Individual id (encounter owner)" },
-    encounter: {
-      type: "gherkin",
-      required: false,
-      description: "Optional Gherkin Feature describing what happened"
-    }
+    product: { type: "string", required: true, description: "Product id" },
+    individual: { type: "string", required: true, description: "Individual id (owner)" }
   },
-  ["plan", "individual", "encounter"]
+  ["product", "individual"]
 );
-var roleAbandon = def(
-  "role",
-  "abandon",
+var productDisown = def(
+  "product",
+  "disown",
   {
-    plan: { type: "string", required: true, description: "Plan id to abandon" },
-    individual: { type: "string", required: true, description: "Individual id (encounter owner)" },
-    encounter: {
+    product: { type: "string", required: true, description: "Product id" },
+    individual: { type: "string", required: true, description: "Individual id (owner to remove)" }
+  },
+  ["product", "individual"]
+);
+var productDeprecate = def(
+  "product",
+  "deprecate",
+  {
+    product: { type: "string", required: true, description: "Product id" }
+  },
+  ["product"]
+);
+
+// src/instructions/project.ts
+var projectScope = def(
+  "project",
+  "scope",
+  {
+    project: { type: "string", required: true, description: "Project id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Optional Gherkin Feature describing what happened"
-    }
+      required: true,
+      description: "Gherkin Feature source for the scope"
+    },
+    id: { type: "string", required: true, description: "Scope id" }
   },
-  ["plan", "individual", "encounter"]
+  ["project", "content", "id"]
 );
-var roleReflect = def(
-  "role",
-  "reflect",
+var projectMilestone = def(
+  "project",
+  "milestone",
   {
-    encounter: { type: "string", required: true, description: "Encounter id to reflect on" },
-    individual: { type: "string", required: true, description: "Individual id" },
-    experience: {
+    project: { type: "string", required: true, description: "Project id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Gherkin Feature source for the experience"
+      required: true,
+      description: "Gherkin Feature source for the milestone"
     },
     id: {
       type: "string",
       required: true,
-      description: "Experience id (keywords joined by hyphens)"
+      description: "Milestone id (keywords joined by hyphens)"
     }
   },
-  ["encounter", "individual", "experience", "id"]
+  ["project", "content", "id"]
 );
-var roleRealize = def(
-  "role",
-  "realize",
+var projectAchieve = def(
+  "project",
+  "achieve",
   {
-    experience: { type: "string", required: true, description: "Experience id to distill" },
-    individual: { type: "string", required: true, description: "Individual id" },
-    principle: {
+    milestone: { type: "string", required: true, description: "Milestone id to mark as done" }
+  },
+  ["milestone"]
+);
+var projectEnroll = def(
+  "project",
+  "enroll",
+  {
+    project: { type: "string", required: true, description: "Project id" },
+    individual: { type: "string", required: true, description: "Individual id" }
+  },
+  ["project", "individual"]
+);
+var projectRemove = def(
+  "project",
+  "remove",
+  {
+    project: { type: "string", required: true, description: "Project id" },
+    individual: { type: "string", required: true, description: "Individual id" }
+  },
+  ["project", "individual"]
+);
+var projectDeliver = def(
+  "project",
+  "deliver",
+  {
+    project: { type: "string", required: true, description: "Project id" },
+    content: {
       type: "gherkin",
-      required: false,
-      description: "Gherkin Feature source for the principle"
+      required: true,
+      description: "Gherkin Feature source for the deliverable"
     },
     id: {
       type: "string",
       required: true,
-      description: "Principle id (keywords joined by hyphens)"
+      description: "Deliverable id (keywords joined by hyphens)"
     }
   },
-  ["experience", "individual", "principle", "id"]
+  ["project", "content", "id"]
 );
-var roleMaster = def(
-  "role",
-  "master",
+var projectWiki = def(
+  "project",
+  "wiki",
   {
-    individual: { type: "string", required: true, description: "Individual id" },
-    procedure: {
+    project: { type: "string", required: true, description: "Project id" },
+    content: {
       type: "gherkin",
       required: true,
-      description: "Gherkin Feature source for the procedure"
+      description: "Gherkin Feature source for the wiki entry"
     },
     id: {
       type: "string",
       required: true,
-      description: "Procedure id (keywords joined by hyphens)"
-    },
-    experience: {
-      type: "string",
-      required: false,
-      description: "Experience id to consume (optional)"
+      description: "Wiki entry id (keywords joined by hyphens)"
     }
   },
-  ["individual", "procedure", "id", "experience"]
-);
-var roleForget = def(
-  "role",
-  "forget",
-  {
-    id: { type: "string", required: true, description: "Id of the node to remove" },
-    individual: { type: "string", required: true, description: "Individual id (owner)" }
-  },
-  ["id", "individual"]
-);
-var roleSkill = def(
-  "role",
-  "skill",
-  {
-    locator: { type: "string", required: true, description: "ResourceX locator for the skill" }
-  },
-  ["locator"]
+  ["project", "content", "id"]
 );
-var societyFound = def(
-  "society",
-  "found",
+var projectProduce = def(
+  "project",
+  "produce",
   {
+    project: { type: "string", required: true, description: "Project id" },
     content: {
       type: "gherkin",
       required: false,
-      description: "Gherkin Feature source for the organization"
+      description: "Gherkin Feature source for the product (vision)"
     },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
-    alias: { type: "string[]", required: false, description: "Alternative names" }
+    id: { type: "string", required: true, description: "Product id (kebab-case)" },
+    alias: { type: "string[]", required: false, description: "Alternative names" },
+    owner: {
+      type: "string",
+      required: false,
+      description: "Individual id of the first product owner"
+    }
   },
-  ["content", "id", "alias"]
+  ["project", "content", "id", "alias", "owner"]
 );
-var orgCharter = def(
-  "org",
-  "charter",
+var projectMaintain = def(
+  "project",
+  "maintain",
   {
-    org: { type: "string", required: true, description: "Organization id" },
-    content: {
-      type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the charter"
-    },
-    id: { type: "string", required: true, description: "Charter id" }
+    project: { type: "string", required: true, description: "Project id" },
+    individual: { type: "string", required: true, description: "Individual id" }
   },
-  ["org", "content", "id"]
+  ["project", "individual"]
 );
-var societyDissolve = def(
-  "society",
-  "dissolve",
+var projectUnmaintain = def(
+  "project",
+  "unmaintain",
   {
-    org: { type: "string", required: true, description: "Organization id" }
+    project: { type: "string", required: true, description: "Project id" },
+    individual: { type: "string", required: true, description: "Individual id" }
   },
-  ["org"]
+  ["project", "individual"]
 );
-var orgHire = def(
-  "org",
-  "hire",
+
+// src/instructions/resource.ts
+var resourceAdd = def(
+  "resource",
+  "add",
   {
-    org: { type: "string", required: true, description: "Organization id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    path: { type: "string", required: true, description: "Path to resource directory" }
   },
-  ["org", "individual"]
+  ["path"]
 );
-var orgFire = def(
-  "org",
-  "fire",
+var resourceSearch = def(
+  "resource",
+  "search",
   {
-    org: { type: "string", required: true, description: "Organization id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    query: { type: "string", required: false, description: "Search query" }
   },
-  ["org", "individual"]
+  ["query"]
 );
-var orgAdmin = def(
-  "org",
-  "admin",
+var resourceHas = def(
+  "resource",
+  "has",
   {
-    org: { type: "string", required: true, description: "Organization id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    locator: { type: "string", required: true, description: "Resource locator" }
   },
-  ["org", "individual"]
+  ["locator"]
 );
-var orgUnadmin = def(
-  "org",
-  "unadmin",
+var resourceInfo = def(
+  "resource",
+  "info",
   {
-    org: { type: "string", required: true, description: "Organization id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    locator: { type: "string", required: true, description: "Resource locator" }
   },
-  ["org", "individual"]
+  ["locator"]
 );
-var positionEstablish = def(
-  "position",
-  "establish",
+var resourceRemove = def(
+  "resource",
+  "remove",
   {
-    content: {
-      type: "gherkin",
-      required: false,
-      description: "Gherkin Feature source for the position"
-    },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
-    alias: { type: "string[]", required: false, description: "Alternative names" }
+    locator: { type: "string", required: true, description: "Resource locator" }
   },
-  ["content", "id", "alias"]
+  ["locator"]
 );
-var positionCharge = def(
-  "position",
-  "charge",
+var resourcePush = def(
+  "resource",
+  "push",
   {
-    position: { type: "string", required: true, description: "Position id" },
-    content: {
-      type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the duty"
-    },
-    id: { type: "string", required: true, description: "Duty id (keywords joined by hyphens)" }
+    locator: { type: "string", required: true, description: "Resource locator" },
+    registry: { type: "string", required: false, description: "Registry URL (overrides default)" }
   },
-  ["position", "content", "id"]
+  ["locator", { pack: ["registry"] }]
 );
-var positionRequire = def(
-  "position",
-  "require",
+var resourcePull = def(
+  "resource",
+  "pull",
   {
-    position: { type: "string", required: true, description: "Position id" },
-    content: {
-      type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the skill requirement"
-    },
-    id: {
-      type: "string",
-      required: true,
-      description: "Requirement id (keywords joined by hyphens)"
-    }
+    locator: { type: "string", required: true, description: "Resource locator" },
+    registry: { type: "string", required: false, description: "Registry URL (overrides default)" }
   },
-  ["position", "content", "id"]
+  ["locator", { pack: ["registry"] }]
 );
-var positionAbolish = def(
-  "position",
-  "abolish",
+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",
+  "activate",
   {
-    position: { type: "string", required: true, description: "Position id" }
+    individual: {
+      type: "string",
+      required: true,
+      description: "Individual id to activate as role"
+    }
   },
-  ["position"]
+  ["individual"]
 );
-var positionAppoint = def(
-  "position",
-  "appoint",
+var roleFocus = def(
+  "role",
+  "focus",
   {
-    position: { type: "string", required: true, description: "Position id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    goal: { type: "string", required: true, description: "Goal id to switch to" }
   },
-  ["position", "individual"]
+  ["goal"]
 );
-var positionDismiss = def(
-  "position",
-  "dismiss",
+var roleWant = def(
+  "role",
+  "want",
   {
-    position: { type: "string", required: true, description: "Position id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    individual: { type: "string", required: true, description: "Individual id" },
+    goal: {
+      type: "gherkin",
+      required: false,
+      description: "Gherkin Feature source describing the goal"
+    },
+    id: { type: "string", required: true, description: "Goal id (used for focus/reference)" },
+    alias: { type: "string[]", required: false, description: "Alternative names" }
   },
-  ["position", "individual"]
+  ["individual", "goal", "id", "alias"]
 );
-var projectLaunch = def(
-  "project",
-  "launch",
+var rolePlan = def(
+  "role",
+  "plan",
   {
-    content: {
+    goal: { type: "string", required: true, description: "Goal id" },
+    plan: {
       type: "gherkin",
       required: false,
-      description: "Gherkin Feature source for the project"
+      description: "Gherkin Feature source describing the plan"
     },
-    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
-    alias: { type: "string[]", required: false, description: "Alternative names" },
-    org: {
+    id: { type: "string", required: true, description: "Plan id (keywords joined by hyphens)" },
+    after: {
       type: "string",
       required: false,
-      description: "Organization id that owns this project"
+      description: "Plan id this plan follows (sequential/phase)"
+    },
+    fallback: {
+      type: "string",
+      required: false,
+      description: "Plan id this plan is a backup for (alternative/strategy)"
     }
   },
-  ["content", "id", "alias", "org"]
+  ["goal", "plan", "id", "after", "fallback"]
 );
-var projectScope = def(
-  "project",
-  "scope",
+var roleTodo = def(
+  "role",
+  "todo",
   {
-    project: { type: "string", required: true, description: "Project id" },
-    content: {
+    plan: { type: "string", required: true, description: "Plan id" },
+    task: {
       type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the scope"
+      required: false,
+      description: "Gherkin Feature source describing the task"
     },
-    id: { type: "string", required: true, description: "Scope id" }
+    id: { type: "string", required: true, description: "Task id (used for finish/reference)" },
+    alias: { type: "string[]", required: false, description: "Alternative names" }
   },
-  ["project", "content", "id"]
+  ["plan", "task", "id", "alias"]
 );
-var projectMilestone = def(
-  "project",
-  "milestone",
+var roleFinish = def(
+  "role",
+  "finish",
   {
-    project: { type: "string", required: true, description: "Project id" },
-    content: {
+    task: { type: "string", required: true, description: "Task id to finish" },
+    individual: { type: "string", required: true, description: "Individual id (encounter owner)" },
+    encounter: {
       type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the milestone"
-    },
-    id: {
-      type: "string",
-      required: true,
-      description: "Milestone id (keywords joined by hyphens)"
+      required: false,
+      description: "Optional Gherkin Feature describing what happened"
     }
   },
-  ["project", "content", "id"]
+  ["task", "individual", "encounter"]
 );
-var projectAchieve = def(
-  "project",
-  "achieve",
+var roleComplete = def(
+  "role",
+  "complete",
   {
-    milestone: { type: "string", required: true, description: "Milestone id to mark as done" }
+    plan: { type: "string", required: true, description: "Plan id to complete" },
+    individual: { type: "string", required: true, description: "Individual id (encounter owner)" },
+    encounter: {
+      type: "gherkin",
+      required: false,
+      description: "Optional Gherkin Feature describing what happened"
+    }
   },
-  ["milestone"]
+  ["plan", "individual", "encounter"]
 );
-var projectEnroll = def(
-  "project",
-  "enroll",
+var roleAbandon = def(
+  "role",
+  "abandon",
   {
-    project: { type: "string", required: true, description: "Project id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    plan: { type: "string", required: true, description: "Plan id to abandon" },
+    individual: { type: "string", required: true, description: "Individual id (encounter owner)" },
+    encounter: {
+      type: "gherkin",
+      required: false,
+      description: "Optional Gherkin Feature describing what happened"
+    }
   },
-  ["project", "individual"]
+  ["plan", "individual", "encounter"]
 );
-var projectRemove = def(
-  "project",
-  "remove",
+var roleReflect = def(
+  "role",
+  "reflect",
   {
-    project: { type: "string", required: true, description: "Project id" },
-    individual: { type: "string", required: true, description: "Individual id" }
+    encounter: { type: "string", required: true, description: "Encounter id to reflect on" },
+    individual: { type: "string", required: true, description: "Individual id" },
+    experience: {
+      type: "gherkin",
+      required: false,
+      description: "Gherkin Feature source for the experience"
+    },
+    id: {
+      type: "string",
+      required: true,
+      description: "Experience id (keywords joined by hyphens)"
+    }
   },
-  ["project", "individual"]
+  ["encounter", "individual", "experience", "id"]
 );
-var projectDeliver = def(
-  "project",
-  "deliver",
+var roleRealize = def(
+  "role",
+  "realize",
   {
-    project: { type: "string", required: true, description: "Project id" },
-    content: {
+    experience: { type: "string", required: true, description: "Experience id to distill" },
+    individual: { type: "string", required: true, description: "Individual id" },
+    principle: {
       type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the deliverable"
+      required: false,
+      description: "Gherkin Feature source for the principle"
     },
     id: {
       type: "string",
       required: true,
-      description: "Deliverable id (keywords joined by hyphens)"
+      description: "Principle id (keywords joined by hyphens)"
     }
   },
-  ["project", "content", "id"]
+  ["experience", "individual", "principle", "id"]
 );
-var projectWiki = def(
-  "project",
-  "wiki",
+var roleMaster = def(
+  "role",
+  "master",
   {
-    project: { type: "string", required: true, description: "Project id" },
-    content: {
+    individual: { type: "string", required: true, description: "Individual id" },
+    procedure: {
       type: "gherkin",
       required: true,
-      description: "Gherkin Feature source for the wiki entry"
+      description: "Gherkin Feature source for the procedure"
     },
     id: {
       type: "string",
       required: true,
-      description: "Wiki entry id (keywords joined by hyphens)"
+      description: "Procedure id (keywords joined by hyphens)"
+    },
+    experience: {
+      type: "string",
+      required: false,
+      description: "Experience id to consume (optional)"
     }
   },
-  ["project", "content", "id"]
+  ["individual", "procedure", "id", "experience"]
 );
-var projectArchive = def(
-  "project",
-  "archive",
+var roleForget = def(
+  "role",
+  "forget",
   {
-    project: { type: "string", required: true, description: "Project id" }
+    id: { type: "string", required: true, description: "Id of the node to remove" },
+    individual: { type: "string", required: true, description: "Individual id (owner)" }
   },
-  ["project"]
+  ["id", "individual"]
 );
-var projectProduce = def(
-  "project",
-  "produce",
+var roleSkill = def(
+  "role",
+  "skill",
+  {
+    locator: { type: "string", required: true, description: "ResourceX locator for the skill" }
+  },
+  ["locator"]
+);
+
+// src/instructions/society.ts
+var societyBorn = def(
+  "society",
+  "born",
   {
-    project: { type: "string", required: true, description: "Project id" },
     content: {
       type: "gherkin",
       required: false,
-      description: "Gherkin Feature source for the product (vision)"
+      description: "Gherkin Feature source for the individual"
     },
-    id: { type: "string", required: true, description: "Product id (kebab-case)" },
+    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
     alias: { type: "string[]", required: false, description: "Alternative names" }
   },
-  ["project", "content", "id", "alias"]
+  ["content", "id", "alias"]
 );
-var projectMaintain = def(
-  "project",
-  "maintain",
+var societyRetire = def(
+  "society",
+  "retire",
   {
-    project: { type: "string", required: true, description: "Project id" },
     individual: { type: "string", required: true, description: "Individual id" }
   },
-  ["project", "individual"]
+  ["individual"]
 );
-var projectUnmaintain = def(
-  "project",
-  "unmaintain",
+var societyDie = def(
+  "society",
+  "die",
   {
-    project: { type: "string", required: true, description: "Project id" },
     individual: { type: "string", required: true, description: "Individual id" }
   },
-  ["project", "individual"]
+  ["individual"]
 );
-var productStrategy = def(
-  "product",
-  "strategy",
-  {
-    product: { type: "string", required: true, description: "Product id" },
-    content: {
-      type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the strategy"
-    },
-    id: { type: "string", required: true, description: "Strategy id" }
+var societyRehire = def(
+  "society",
+  "rehire",
+  {
+    individual: { type: "string", required: true, description: "Individual id (from past)" }
   },
-  ["product", "content", "id"]
+  ["individual"]
 );
-var productSpec = def(
-  "product",
-  "spec",
+var societyTeach = def(
+  "society",
+  "teach",
   {
-    product: { type: "string", required: true, description: "Product id" },
+    individual: { type: "string", required: true, description: "Individual id" },
     content: {
       type: "gherkin",
       required: true,
-      description: "Gherkin Feature source for the behavior contract (BDD specification)"
+      description: "Gherkin Feature source for the principle"
     },
     id: {
       type: "string",
       required: true,
-      description: "Spec id (keywords joined by hyphens)"
+      description: "Principle id (keywords joined by hyphens)"
     }
   },
-  ["product", "content", "id"]
+  ["individual", "content", "id"]
 );
-var productRelease = def(
-  "product",
-  "release",
+var societyTrain = def(
+  "society",
+  "train",
   {
-    product: { type: "string", required: true, description: "Product id" },
+    individual: { type: "string", required: true, description: "Individual id" },
     content: {
       type: "gherkin",
       required: true,
-      description: "Gherkin Feature source for the release"
+      description: "Gherkin Feature source for the procedure"
     },
     id: {
       type: "string",
       required: true,
-      description: "Release id (e.g. v1.0.0)"
+      description: "Procedure id (keywords joined by hyphens)"
     }
   },
-  ["product", "content", "id"]
+  ["individual", "content", "id"]
 );
-var productChannel = def(
-  "product",
-  "channel",
+var societyFound = def(
+  "society",
+  "found",
   {
-    product: { type: "string", required: true, description: "Product id" },
     content: {
       type: "gherkin",
-      required: true,
-      description: "Gherkin Feature source for the distribution channel"
+      required: false,
+      description: "Gherkin Feature source for the organization"
     },
-    id: {
+    id: { type: "string", required: true, description: "User-facing identifier (kebab-case)" },
+    alias: { type: "string[]", required: false, description: "Alternative names" },
+    admin: {
       type: "string",
-      required: true,
-      description: "Channel id (e.g. npm, cloud-platform)"
+      required: false,
+      description: "Individual id of the first admin"
     }
   },
-  ["product", "content", "id"]
-);
-var productOwn = def(
-  "product",
-  "own",
-  {
-    product: { type: "string", required: true, description: "Product id" },
-    individual: { type: "string", required: true, description: "Individual id (owner)" }
-  },
-  ["product", "individual"]
-);
-var productDisown = def(
-  "product",
-  "disown",
-  {
-    product: { type: "string", required: true, description: "Product id" },
-    individual: { type: "string", required: true, description: "Individual id (owner to remove)" }
-  },
-  ["product", "individual"]
+  ["content", "id", "alias", "admin"]
 );
-var productDeprecate = def(
-  "product",
-  "deprecate",
+var societyDissolve = def(
+  "society",
+  "dissolve",
   {
-    product: { type: "string", required: true, description: "Product id" }
+    org: { type: "string", required: true, description: "Organization id" }
   },
-  ["product"]
+  ["org"]
 );
 var societyCrown = def(
   "society",
@@ -1844,6 +2118,8 @@ var societyUncrown = def(
   },
   ["individual"]
 );
+
+// src/instructions/index.ts
 var censusList = def(
   "census",
   "list",
@@ -1864,174 +2140,6 @@ var prototypeEvict = def(
   },
   ["id"]
 );
-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"]
-);
-var issuePublish = def(
-  "issue",
-  "publish",
-  {
-    title: { type: "string", required: true, description: "Issue title" },
-    body: { type: "string", required: true, description: "Issue body/description" },
-    author: { type: "string", required: true, description: "Author individual id" },
-    assignee: { type: "string", required: false, description: "Assignee individual id" }
-  },
-  ["title", "body", "author", "assignee"]
-);
-var issueGet = def(
-  "issue",
-  "get",
-  {
-    number: { type: "number", required: true, description: "Issue number" }
-  },
-  ["number"]
-);
-var issueList = def(
-  "issue",
-  "list",
-  {
-    status: { type: "string", required: false, description: "Filter by status (open/closed)" },
-    author: { type: "string", required: false, description: "Filter by author" },
-    assignee: { type: "string", required: false, description: "Filter by assignee" },
-    label: { type: "string", required: false, description: "Filter by label name" }
-  },
-  ["status", "author", "assignee", "label"]
-);
-var issueUpdate = def(
-  "issue",
-  "update",
-  {
-    number: { type: "number", required: true, description: "Issue number" },
-    title: { type: "string", required: false, description: "New title" },
-    body: { type: "string", required: false, description: "New body" },
-    assignee: { type: "string", required: false, description: "New assignee" }
-  },
-  ["number", "title", "body", "assignee"]
-);
-var issueClose = def(
-  "issue",
-  "close",
-  {
-    number: { type: "number", required: true, description: "Issue number to close" }
-  },
-  ["number"]
-);
-var issueReopen = def(
-  "issue",
-  "reopen",
-  {
-    number: { type: "number", required: true, description: "Issue number to reopen" }
-  },
-  ["number"]
-);
-var issueAssign = def(
-  "issue",
-  "assign",
-  {
-    number: { type: "number", required: true, description: "Issue number" },
-    assignee: { type: "string", required: true, description: "Individual id to assign" }
-  },
-  ["number", "assignee"]
-);
-var issueComment = def(
-  "issue",
-  "comment",
-  {
-    number: { type: "number", required: true, description: "Issue number" },
-    body: { type: "string", required: true, description: "Comment body" },
-    author: { type: "string", required: true, description: "Author individual id" }
-  },
-  ["number", "body", "author"]
-);
-var issueComments = def(
-  "issue",
-  "comments",
-  {
-    number: { type: "number", required: true, description: "Issue number" }
-  },
-  ["number"]
-);
-var issueLabel = def(
-  "issue",
-  "label",
-  {
-    number: { type: "number", required: true, description: "Issue number" },
-    label: { type: "string", required: true, description: "Label name" }
-  },
-  ["number", "label"]
-);
-var issueUnlabel = def(
-  "issue",
-  "unlabel",
-  {
-    number: { type: "number", required: true, description: "Issue number" },
-    label: { type: "string", required: true, description: "Label name to remove" }
-  },
-  ["number", "label"]
-);
 var instructions = {
   // society — individual lifecycle + org lifecycle
   "society.born": societyBorn,
@@ -2062,15 +2170,16 @@ var instructions = {
   "org.fire": orgFire,
   "org.admin": orgAdmin,
   "org.unadmin": orgUnadmin,
+  "org.launch": orgLaunch,
+  "org.archive": orgArchive,
+  "org.establish": orgEstablish,
+  "org.abolish": orgAbolish,
   // position
-  "position.establish": positionEstablish,
   "position.charge": positionCharge,
   "position.require": positionRequire,
-  "position.abolish": positionAbolish,
   "position.appoint": positionAppoint,
   "position.dismiss": positionDismiss,
   // project
-  "project.launch": projectLaunch,
   "project.scope": projectScope,
   "project.milestone": projectMilestone,
   "project.achieve": projectAchieve,
@@ -2078,7 +2187,6 @@ var instructions = {
   "project.remove": projectRemove,
   "project.deliver": projectDeliver,
   "project.wiki": projectWiki,
-  "project.archive": projectArchive,
   "project.produce": projectProduce,
   "project.maintain": projectMaintain,
   "project.unmaintain": projectUnmaintain,
@@ -2180,7 +2288,7 @@ function matches(node, target) {
   }
   return false;
 }
-function findInState(state, target) {
+function findInState2(state, target) {
   const lowered = target.toLowerCase();
   let best = null;
   let bestPriority = Infinity;
@@ -2251,10 +2359,10 @@ var world = {
     Given org commands manage organization membership and governance
     And !org.hire adds a member, !org.fire removes a member, !org.charter defines governance
     Given position commands manage positions
-    Then !position.establish creates, !position.abolish archives
+    Then !org.establish creates, !org.abolish archives
     And !position.appoint assigns, !position.dismiss removes, !position.charge adds duty
     Given project commands manage projects
-    Then !project.launch creates, !project.archive archives
+    Then !org.launch creates, !org.archive archives
 `,
   communication: `Feature: Communication \u2014 speak the user's language
   The AI communicates in the user's natural language.
@@ -2521,12 +2629,12 @@ Feature: Role identity \u2014 activate before acting
 };
 var processes = {
   abandon: "Feature: abandon \u2014 abandon a plan\n  Mark a plan as dropped and create an encounter.\n  Call this when a plan's strategy is no longer viable. Even failed plans produce learning.\n\n  Scenario: Abandon a plan\n    Given a focused plan exists\n    And the plan's strategy is no longer viable\n    When abandon is called\n    Then the plan is tagged #abandoned and stays in the tree\n    And an encounter is created under the role\n    And the encounter can be reflected on \u2014 failure is also learning\n\n  Scenario: Writing the encounter Gherkin\n    Given the encounter records what happened \u2014 even failure is a raw experience\n    Then the Feature title describes what was attempted and why it was abandoned\n    And Scenarios capture what was tried, what went wrong, and what was learned\n    And the tone is concrete and honest \u2014 failure produces the richest encounters\n",
-  abolish: "Feature: abolish \u2014 abolish a position\n  Move a position to the past archive.\n  The position and its subtree (duties, requirements) are archived, not deleted.\n\n  Scenario: Abolish a position\n    Given a position exists in society\n    When abolish is called on the position\n    Then the position is moved to the past archive\n    And the position's subtree (duties, requirements) is preserved in past\n\n  Scenario: Parameters\n    Given the command is position.abolish\n    Then position is required \u2014 the position's id\n",
+  abolish: "Feature: abolish \u2014 abolish a position\n  Move a position to the past archive.\n  The position and its subtree (duties, requirements) are archived, not deleted.\n\n  Scenario: Abolish a position\n    Given a position exists in society\n    When abolish is called on the position\n    Then the position is moved to the past archive\n    And the position's subtree (duties, requirements) is preserved in past\n\n  Scenario: Parameters\n    Given the command is org.abolish\n    Then position is required \u2014 the position's id\n",
   achieve: "Feature: achieve \u2014 mark a milestone as done\n  Mark a project milestone as achieved.\n  The milestone is completed and its status is updated.\n\n  Scenario: Achieve a milestone\n    Given a milestone exists within a project\n    When achieve is called on the milestone\n    Then the milestone is marked as done\n\n  Scenario: Parameters\n    Given the command is project.achieve\n    Then milestone is required \u2014 the milestone's id\n",
   activate: "Feature: activate \u2014 enter a role\n  Project the individual's full state including identity, goals,\n  and organizational context. This is the entry point for working as a role.\n\n  Scenario: Activate an individual\n    Given an individual exists in society\n    When activate is called with the individual reference\n    Then the full state tree is projected\n    And identity, goals, and organizational context are loaded\n    And the individual becomes the active role\n",
   admin: "Feature: admin \u2014 set organization administrator\n  Grant admin privileges to an individual within an organization.\n  Admins can manage charter, membership, positions, and projects.\n\n  Scenario: Set an admin\n    Given an individual is a member of an organization\n    When admin is called with the organization and individual\n    Then the individual gains admin privileges for the organization\n    And the individual can manage positions, projects, and membership\n\n  Scenario: Parameters\n    Given the command is org.admin\n    Then org is required \u2014 the organization's id\n    And individual is required \u2014 the individual's id\n",
   appoint: "Feature: appoint \u2014 assign to a position\n  Appoint an individual to a position.\n  The individual must be a member of the organization.\n\n  Scenario: Appoint an individual\n    Given an individual is a member of an organization\n    And a position exists within the organization\n    When appoint is called with the position and individual\n    Then the individual holds the position\n    And the individual inherits the position's duties\n\n  Scenario: Parameters\n    Given the command is position.appoint\n    Then position is required \u2014 the position's id\n    And individual is required \u2014 the individual's id\n",
-  archive: "Feature: archive \u2014 archive a project\n  Move a project to the past archive.\n  The project and its subtree (scope, milestones, deliverables, wiki) are preserved.\n\n  Scenario: Archive a project\n    Given a project exists in society\n    When archive is called on the project\n    Then the project is moved to the past archive\n    And the project's subtree is preserved in past\n\n  Scenario: Parameters\n    Given the command is project.archive\n    Then project is required \u2014 the project's id\n",
+  archive: "Feature: archive \u2014 archive a project\n  Move a project to the past archive.\n  The project and its subtree (scope, milestones, deliverables, wiki) are preserved.\n\n  Scenario: Archive a project\n    Given a project exists in society\n    When archive is called on the project\n    Then the project is moved to the past archive\n    And the project's subtree is preserved in past\n\n  Scenario: Parameters\n    Given the command is org.archive\n    Then project is required \u2014 the project's id\n",
   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  An identity node is automatically created under the individual.\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 an identity child node is created automatically\n    And the individual can be hired into organizations\n    And the individual can be activated to start working\n\n  Scenario: Parameters\n    Given the command is society.born\n    Then content is optional \u2014 Gherkin Feature describing the persona\n    And id is optional \u2014 kebab-case identifier (e.g. "sean")\n    And alias is optional \u2014 alternative names (e.g. ["\u5C0F\u660E", "xm"])\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\n',
   channel: "Feature: channel \u2014 define a distribution channel\n  Define a distribution channel for a product.\n  Channels describe how the product reaches its users.\n\n  Scenario: Define a channel\n    Given a product exists in society\n    And a Gherkin source describing the distribution channel\n    When channel is called on the product with a channel id\n    Then the channel is stored as the product's information\n\n  Scenario: Parameters\n    Given the command is product.channel\n    Then product is required \u2014 the product's id\n    And content is required \u2014 Gherkin Feature source for the distribution channel\n    And id is required \u2014 channel id (e.g. npm, cloud-platform)\n\n  Scenario: Writing the channel Gherkin\n    Given the channel defines how the product is distributed\n    Then the Feature title names the channel\n    And Scenarios describe distribution mechanics, access, and availability\n    And the tone is operational \u2014 how users get the product\n",
   charge: `Feature: charge \u2014 assign duty to a position
@@ -2567,7 +2675,7 @@ var processes = {
   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",
   enroll: "Feature: enroll \u2014 add participant to a project\n  Enroll an individual as a participant in a project.\n  Participants can contribute to the project's work.\n\n  Scenario: Enroll an individual\n    Given a project and an individual exist\n    When enroll is called with the project and individual\n    Then the individual becomes a participant in the project\n\n  Scenario: Parameters\n    Given the command is project.enroll\n    Then project is required \u2014 the project's id\n    And individual is required \u2014 the individual's id\n",
-  establish: 'Feature: establish \u2014 create a position\n  Create a position in society.\n  Positions define roles with duties and skill requirements.\n  Individuals can be appointed to positions.\n\n  Scenario: Establish a position\n    Given a Gherkin source describing the position\n    When establish is called with the source\n    Then a new position node is created in society\n    And the position can be charged with duties\n    And skill requirements can be added\n    And individuals can be appointed to it\n\n  Scenario: Parameters\n    Given the command is position.establish\n    Then content is optional \u2014 Gherkin Feature describing the position\n    And id is optional \u2014 kebab-case identifier (e.g. "cto")\n    And alias is optional \u2014 alternative names\n\n  Scenario: Writing the position Gherkin\n    Given the position Feature describes a role\n    Then the Feature title names the position\n    And the description captures responsibilities, scope, and expectations\n    And Scenarios are optional \u2014 use them for distinct aspects of the role\n',
+  establish: 'Feature: establish \u2014 create a position\n  Create a position in society.\n  Positions define roles with duties and skill requirements.\n  Individuals can be appointed to positions.\n\n  Scenario: Establish a position\n    Given a Gherkin source describing the position\n    When establish is called with the source\n    Then a new position node is created in society\n    And the position can be charged with duties\n    And skill requirements can be added\n    And individuals can be appointed to it\n\n  Scenario: Parameters\n    Given the command is org.establish\n    Then content is optional \u2014 Gherkin Feature describing the position\n    And id is optional \u2014 kebab-case identifier (e.g. "cto")\n    And alias is optional \u2014 alternative names\n\n  Scenario: Writing the position Gherkin\n    Given the position Feature describes a role\n    Then the Feature title names the position\n    And the description captures responsibilities, scope, and expectations\n    And Scenarios are optional \u2014 use them for distinct aspects of the role\n',
   finish: "Feature: finish \u2014 complete a task\n  Mark a task as done and create an encounter.\n  The encounter records what happened and can be reflected on for learning.\n\n  Scenario: Finish a task\n    Given a task exists\n    When finish is called on the task\n    Then the task is tagged #done and stays in the tree\n    And an encounter is created under the role\n\n  Scenario: Finish with experience\n    Given a task is completed with a notable learning\n    When finish is called with an optional experience parameter\n    Then the experience text is attached to the encounter\n\n  Scenario: Finish without encounter\n    Given a task is completed with no notable learning\n    When finish is called without the encounter parameter\n    Then the task is tagged #done but no encounter is created\n    And the task stays in the tree \u2014 visible via focus on the parent goal\n\n  Scenario: Writing the encounter Gherkin\n    Given the encounter records what happened \u2014 a raw account of the experience\n    Then the Feature title describes what was done\n    And Scenarios capture what was done, what was encountered, and what resulted\n    And the tone is concrete and specific \u2014 tied to this particular task\n",
   fire: "Feature: fire \u2014 remove from an organization\n  Fire an individual from an organization.\n  The individual is dismissed from all positions and removed from the organization.\n\n  Scenario: Fire an individual\n    Given an individual is a member of an organization\n    When fire is called with the organization and individual\n    Then the individual is dismissed from all positions\n    And the individual is removed from the organization\n\n  Scenario: Parameters\n    Given the command is org.fire\n    Then org is required \u2014 the organization's id\n    And individual is required \u2014 the individual's id\n",
   focus: "Feature: focus \u2014 view or switch focused goal\n  View the current goal's state, or switch focus to a different goal.\n  Subsequent plan and todo operations target the focused goal.\n  Only goal ids are accepted \u2014 plan, task, or other node types are rejected.\n\n  Scenario: View current goal\n    Given an active goal exists\n    When focus is called without a name\n    Then the current goal's state tree is projected\n    And plans and tasks under the goal are visible\n\n  Scenario: Switch focus\n    Given multiple goals exist\n    When focus is called with a goal id\n    Then the focused goal switches to the named goal\n    And subsequent plan and todo operations target this goal\n\n  Scenario: Reject non-goal ids\n    Given a plan or task id is passed to focus\n    Then focus returns an error indicating the node type\n    And suggests using the correct goal id instead\n",
@@ -2598,7 +2706,7 @@ var processes = {
 `,
   hire: "Feature: hire \u2014 hire into an organization\n  Hire an individual into an organization as a member.\n  Members can then be appointed to positions.\n\n  Scenario: Hire an individual\n    Given an organization and an individual exist\n    When hire is called with the organization and individual\n    Then the individual becomes a member of the organization\n    And the individual can be appointed to positions within the organization\n\n  Scenario: Parameters\n    Given the command is org.hire\n    Then org is required \u2014 the organization's id\n    And individual is required \u2014 the individual's id\n",
   inspect: "Feature: inspect \u2014 examine any node's full state tree\n  Project a node's complete subtree including children and links.\n  Works without an active role \u2014 a stateless observation tool.\n\n  Scenario: Inspect a node\n    Given a node id is provided\n    When inspect is called with the id\n    Then the full state tree is projected from that node downward\n    And output uses heading + Gherkin format (same as activate)\n",
-  launch: 'Feature: launch \u2014 create a new project\n  Launch a new project in society.\n  Projects organize work with scope, milestones, deliverables, and wiki.\n  A project can optionally be linked to an owning organization.\n\n  Scenario: Launch a project\n    Given a Gherkin source describing the project\n    When launch is called with the source\n    Then a new project node is created in society\n    And scope, milestones, deliverables, and wiki can be added\n    And individuals can be enrolled as participants\n    And products can be produced from the project\n\n  Scenario: Parameters\n    Given the command is project.launch\n    Then content is optional \u2014 Gherkin Feature describing the project\n    And id is optional \u2014 kebab-case identifier (e.g. "rolex")\n    And alias is optional \u2014 alternative names\n    And org is optional \u2014 owning organization id, creates an ownership link\n\n  Scenario: Writing the project Gherkin\n    Given the project Feature describes the work to be done\n    Then the Feature title names the project\n    And the description captures goals, scope, and context\n    And Scenarios are optional \u2014 use them for distinct project concerns\n',
+  launch: 'Feature: launch \u2014 create a new project\n  Launch a new project in society.\n  Projects organize work with scope, milestones, deliverables, and wiki.\n  A project can optionally be linked to an owning organization.\n\n  Scenario: Launch a project\n    Given a Gherkin source describing the project\n    When launch is called with the source\n    Then a new project node is created in society\n    And scope, milestones, deliverables, and wiki can be added\n    And individuals can be enrolled as participants\n    And products can be produced from the project\n\n  Scenario: Parameters\n    Given the command is org.launch\n    Then content is optional \u2014 Gherkin Feature describing the project\n    And id is optional \u2014 kebab-case identifier (e.g. "rolex")\n    And alias is optional \u2014 alternative names\n    And org is optional \u2014 owning organization id, creates an ownership link\n\n  Scenario: Writing the project Gherkin\n    Given the project Feature describes the work to be done\n    Then the Feature title names the project\n    And the description captures goals, scope, and context\n    And Scenarios are optional \u2014 use them for distinct project concerns\n',
   maintain: "Feature: maintain \u2014 set project maintainer\n  Assign a maintainer to a project.\n  Maintainers can manage scope, milestones, participants, deliverables, and wiki.\n\n  Scenario: Set a maintainer\n    Given an individual and a project exist\n    When maintain is called with the project and individual\n    Then the individual becomes a maintainer of the project\n    And the individual can manage the project's internal operations\n\n  Scenario: Parameters\n    Given the command is project.maintain\n    Then project is required \u2014 the project's id\n    And individual is required \u2014 the individual's id\n",
   master: 'Feature: master \u2014 self-mastery of a procedure\n  The role masters a procedure through its own agency.\n  This is an act of self-growth \u2014 the role decides to acquire or codify a skill.\n  Experience can be consumed as the source, or the role can master directly from external information.\n\n  Scenario: Master from experience\n    Given an experience exists from reflection\n    When master is called with experience ids\n    Then the experience is consumed\n    And a procedure is created under the individual\n\n  Scenario: Master directly\n    Given the role encounters external information worth mastering\n    When master is called without experience ids\n    Then a procedure is created under the individual\n    And no experience is consumed\n\n  Scenario: Procedure ID convention\n    Given the id is keywords from the procedure content joined by hyphens\n    Then "JWT mastery" becomes id "jwt-mastery"\n    And "Cross-package refactoring" becomes id "cross-package-refactoring"\n\n  Scenario: Writing the procedure Gherkin\n    Given a procedure is skill metadata \u2014 a reference to full skill content\n    Then the Feature title names the capability\n    And the description includes the locator for full skill loading\n    And Scenarios describe when and why to apply this skill\n    And the tone is referential \u2014 pointing to the full skill, not containing it\n',
   milestone: "Feature: milestone \u2014 define a project milestone\n  Define a milestone for a project.\n  Milestones mark significant checkpoints or deliverable targets within the project.\n\n  Scenario: Define a milestone\n    Given a project exists in society\n    And a Gherkin source describing the milestone\n    When milestone is called on the project with a milestone id\n    Then the milestone is stored as the project's information\n    And the milestone can later be achieved\n\n  Scenario: Parameters\n    Given the command is project.milestone\n    Then project is required \u2014 the project's id\n    And content is required \u2014 Gherkin Feature source for the milestone\n    And id is required \u2014 milestone id (keywords joined by hyphens)\n\n  Scenario: Writing the milestone Gherkin\n    Given the milestone defines a checkpoint in the project\n    Then the Feature title names the milestone\n    And Scenarios describe success criteria and acceptance conditions\n    And the tone is goal-oriented \u2014 what must be true when the milestone is reached\n",
@@ -2744,16 +2852,20 @@ var orgAdminPermissions = [
   p("org.charter", "charter"),
   p("org.hire", "hire"),
   p("org.fire", "fire"),
+  p("org.admin", "admin"),
+  p("org.unadmin", "unadmin"),
   // Position lifecycle (org creates positions)
-  p("position.establish", "establish"),
-  p("position.abolish", "abolish"),
+  p("org.establish", "establish"),
+  p("org.abolish", "abolish"),
   p("position.charge", "charge"),
   p("position.require", "require"),
   p("position.appoint", "appoint"),
   p("position.dismiss", "dismiss"),
   // Project lifecycle (org creates projects)
-  p("project.launch", "launch"),
-  p("project.archive", "archive")
+  p("org.launch", "launch"),
+  p("org.archive", "archive"),
+  p("project.maintain", "maintain"),
+  p("project.unmaintain", "unmaintain")
 ];
 
 // src/permissions/product-owner.ts
@@ -2766,7 +2878,9 @@ var productOwnerPermissions = [
   p2("product.spec", "spec"),
   p2("product.release", "release"),
   p2("product.channel", "channel"),
-  p2("product.deprecate", "deprecate")
+  p2("product.deprecate", "deprecate"),
+  p2("product.own", "own"),
+  p2("product.disown", "disown")
 ];
 
 // src/permissions/project-maintainer.ts
@@ -2782,7 +2896,9 @@ var projectMaintainerPermissions = [
   p3("project.remove", "remove"),
   p3("project.deliver", "deliver"),
   p3("project.wiki", "wiki"),
-  p3("project.produce", "produce")
+  p3("project.produce", "produce"),
+  p3("product.own", "own"),
+  p3("product.disown", "disown")
 ];
 
 // src/permissions/registry.ts
@@ -2840,36 +2956,22 @@ function createProjection(rt, permissions) {
     return permissions.enrich(compacted);
   };
 }
-var compactRelations = /* @__PURE__ */ new Set([
-  "crowned",
-  "belong",
-  "appointment",
-  "administer",
-  "maintained-by",
-  "own"
-]);
 function compact(state) {
   const { children, links, ...node } = state;
   return node;
 }
 function compactState(state, depth) {
   const children = depth > 0 ? state.children?.map((c) => compactState(c, depth - 1)) : state.children?.map((c) => compact(c));
-  const compactedLinks = state.links?.map(
-    (l) => compactRelations.has(l.relation) ? { ...l, target: compact(l.target) } : { ...l, target: compactLinkedTarget(l.target) }
-  );
+  const compactedLinks = state.links?.map((l) => ({
+    ...l,
+    target: compact(l.target)
+  }));
   return {
     ...state,
     ...children ? { children } : {},
     ...compactedLinks ? { links: compactedLinks } : {}
   };
 }
-function compactLinkedTarget(state) {
-  const children = state.children?.map((c) => compactLinkedTarget(c));
-  return {
-    ...state,
-    ...children ? { children } : {}
-  };
-}
 
 // src/rolex-service.ts
 var RoleXService = class _RoleXService {
@@ -3054,7 +3156,7 @@ You may be guessing the command name. Load the relevant skill first with skill(l
   /** Find a node by id across the entire society tree (raw, no pipeline). */
   async find(id) {
     const raw = await this.rt.project(this.society);
-    return findInState(raw, id);
+    return findInState2(raw, id);
   }
 };
 function isCommandResult(value) {
@@ -3356,7 +3458,7 @@ export {
   enroll,
   establish,
   experience,
-  findInState,
+  findInState2 as findInState,
   finish,
   fire,
   found,