@rolexjs/core 0.10.0 → 0.11.0-dev.0

package/dist/index.d.ts

@@ -1,347 +1,79 @@
-import { Scenario as Scenario$1, Feature as Feature$1 } from '@cucumber/messages';
+import * as _rolexjs_system from '@rolexjs/system';
+import { Runtime, Prototype } from '@rolexjs/system';
+export { Create, GraphOp, Link, Process, Prototype, Relation, Remove, Runtime, State, Structure, Transform, Unlink, create, createPrototype, createRuntime, link, mergeState, process, relation, remove, structure, transform, unlink } from '@rolexjs/system';
+import { ResourceX } from 'resourcexjs';
 
 /**
- * Scenario — A unit of behavior within a Feature.
+ * Platform — external integration point for RoleX.
  *
- * Extends Gherkin's Scenario with verifiability marking.
- * Verifiable scenarios become persistent test cases.
- * Non-verifiable scenarios are one-time acceptance criteria.
- */
-
-/**
- * A Gherkin Scenario enriched with verification metadata.
- */
-interface Scenario extends Scenario$1 {
-    readonly verifiable: boolean;
-}
-
-/**
- * Feature — The atomic unit in the RDD model.
- *
- * Extends Gherkin's Feature with RDD dimension classification
- * and explicit Scenario relationship.
- */
-
-/**
- * A Gherkin Feature enriched with RDD semantics.
- */
-interface Feature extends Feature$1 {
-    readonly type: "persona" | "knowledge" | "experience" | "voice" | "goal" | "plan" | "task" | "duty";
-    readonly scenarios: Scenario[];
-}
-
-/**
- * Identity — The role's complete self.
- *
- * NOT a Feature itself — it is a container that wraps
- * multiple Features (*.identity.feature files).
- * Always loaded, independent of any goal.
- */
-
-/**
- * The identity foundation of a role. Wraps many Features.
- */
-interface Identity {
-    readonly features: Feature[];
-}
-
-/**
- * Goal — The driver of action.
- *
- * A Goal IS-A Feature with type='goal'.
- * Dynamic and phase-specific. What the role wants to achieve.
- * Expressed as *.goal.feature files.
- */
-
-/**
- * A goal that a role wants to achieve in a given phase.
- */
-interface Goal extends Feature {
-    readonly type: "goal";
-}
-
-/**
- * Role — The primary organizing unit in RDD.
- *
- * Every role operates through dimensions:
- * Identity → Goal → Plan → Task/Skill
- *
- * Identity is static (always present).
- * Goals are dynamic (change per phase).
- */
-
-/**
- * A role in the RDD (Role-Driven Development) model.
- */
-interface Role {
-    readonly name: string;
-    readonly identity: Identity;
-    readonly goals: Goal[];
-}
-
-/**
- * Plan — The bridge between goal and execution.
- *
- * A Plan IS-A Feature with type='plan'.
- * Expressed as *.plan.feature files.
- */
-
-/**
- * A plan that decomposes a goal into executable tasks.
- */
-interface Plan extends Feature {
-    readonly type: "plan";
-}
-
-/**
- * Task — Concrete unit of work within a plan.
- *
- * A Task IS-A Feature with type='task'.
- * Expressed as *.task.feature files.
- */
-
-/**
- * A concrete unit of work.
- */
-interface Task extends Feature {
-    readonly type: "task";
-}
-
-/**
- * Duty — Responsibilities defined by a Position.
- *
- * A Duty IS-A Feature with type='duty'.
- * Expressed as *.duty.feature files within a position directory.
- * Injected into role identity when the role is on_duty.
- */
-
-/**
- * A duty (responsibility) assigned through a position.
- */
-interface Duty extends Feature {
-    readonly type: "duty";
-}
-
-/**
- * Skill — Execution capability for a task.
- *
- * Compatible with existing skill systems:
- * Claude Code skills, ResourceX resources, MCP tools, etc.
- */
-/**
- * A capability that a role uses to execute a task.
- */
-interface Skill {
-    /** Skill identifier, e.g. "commit", "bdd", "dev-flow" */
-    readonly name: string;
-    /** Reference to the concrete implementation: skill path, resource locator, tool URI */
-    readonly reference: string;
-}
-
-/**
- * states.ts — Role and Position state definitions.
- *
- * Role:     free → member → on_duty
- * Position: vacant → filled
- */
-type RoleState = "free" | "member" | "on_duty";
-type PositionState = "vacant" | "filled";
-/**
- * Derive a role's state from assignment data.
- */
-declare function getRoleState(assignment: {
-    org: string;
-    position?: string;
-} | null): RoleState;
-/**
- * Derive a position's state from assignment data.
- */
-declare function getPositionState(assignedRole: string | null): PositionState;
-
-/**
- * Platform — The abstraction layer for role storage.
+ * A Platform provides the runtime environment that Rolex operates in.
+ * Different platforms serve different deployment contexts:
  *
- * Defines how roles, organizations, and positions are stored and managed.
- * LocalPlatform uses the filesystem (.rolex/ directories).
- * Future platforms could use databases, cloud storage, etc.
+ *   LocalPlatform  — filesystem persistence (development, local agents)
+ *   CloudPlatform  — remote storage (future)
  *
- * Three-entity architecture:
- *   Role         = WHO  (identity, goals)
- *   Organization = WHERE (structure, nesting)
- *   Position     = WHAT  (duties, boundaries)
- *
- * All methods are stateless — entity names are passed per call.
+ * Platform holds the Runtime (graph engine) and will hold additional
+ * services as the framework grows (auth, events, plugins, etc.).
  */
 
-/**
- * Assignment — tracks which org/position a role is assigned to.
- */
-interface Assignment {
-    readonly org: string;
-    readonly position?: string;
-}
-/**
- * OrganizationConfig — stored config for an organization.
- */
-interface OrganizationConfig {
-    readonly parent?: string;
-    readonly positions: string[];
-}
-/**
- * RolexConfig — The single source of truth for society state.
- *
- * Always exists. Defined in core, persisted by Platform.
- */
-interface RolexConfig {
-    roles: string[];
-    organizations: Record<string, OrganizationConfig>;
-    assignments: Record<string, Assignment>;
-}
-/**
- * Organization info (runtime view).
- */
-interface OrganizationInfo {
-    readonly name: string;
-    readonly parent?: string;
-    readonly positions: string[];
-    readonly members: string[];
-}
-/**
- * Position info (runtime view).
- */
-interface PositionInfo {
-    readonly name: string;
-    readonly org: string;
-    readonly state: PositionState;
-    readonly assignedRole: string | null;
-    readonly duties: Duty[];
-}
-/**
- * Role directory entry with state information.
- */
-interface RoleEntry {
-    readonly name: string;
-    readonly state: RoleState;
-    readonly org?: string;
-    readonly position?: string;
-}
-/**
- * Society directory — all known roles, organizations, and positions.
- */
-interface Directory {
-    readonly roles: readonly RoleEntry[];
-    readonly organizations: readonly OrganizationInfo[];
-}
-/**
- * Platform interface — abstracts entity storage and retrieval.
- */
 interface Platform {
-    /** List all born roles in society */
-    allBornRoles(): string[];
-    /** Create a new role with its persona */
-    born(name: string, source: string): Feature;
-    /** Found an organization, optionally with a parent org and description */
-    found(name: string, source?: string, parent?: string): void;
-    /** Get organization info by name */
-    getOrganization(name: string): OrganizationInfo | null;
-    /** List all organizations */
-    allOrganizations(): OrganizationInfo[];
-    /** Hire a role into an organization */
-    hire(roleId: string, orgName: string): void;
-    /** Fire a role from an organization (auto-dismisses if on_duty) */
-    fire(roleId: string, orgName: string): void;
-    /** Establish a position within an organization */
-    establish(positionName: string, source: string, orgName: string): void;
-    /** Appoint a role to a position */
-    appoint(roleId: string, positionName: string, orgName: string): void;
-    /** Dismiss a role from their position (back to member) */
-    dismiss(roleId: string): void;
-    /** Get duties for a position */
-    positionDuties(positionName: string, orgName: string): Duty[];
-    /** Get a role's current assignment */
-    getAssignment(roleId: string): Assignment | null;
-    /** Get position info */
-    getPosition(positionName: string, orgName: string): PositionInfo | null;
-    /** Load all identity features for a role (includes duties if on_duty) */
-    identity(roleId: string): Feature[];
-    /** Add a growth dimension to a role's identity */
-    growup(roleId: string, type: "knowledge" | "experience" | "voice", name: string, source: string): Feature;
-    /** Find the current active goal for a role (with plan + tasks context) */
-    activeGoal(roleId: string): (Goal & {
-        plan: Plan | null;
-        tasks: Task[];
-    }) | null;
-    /** List all active (uncompleted) goals for a role */
-    allActiveGoals(roleId: string): Goal[];
-    /** Get the currently focused goal name for a role */
-    getFocusedGoal(roleId: string): string | null;
-    /** Set the focused goal for a role by name */
-    setFocusedGoal(roleId: string, name: string): void;
-    /** Create a new goal from Gherkin source */
-    createGoal(roleId: string, name: string, source: string, testable?: boolean): Goal;
-    /** Create a plan for the current active goal */
-    createPlan(roleId: string, source: string): Plan;
-    /** Create a task for the current active goal */
-    createTask(roleId: string, name: string, source: string, testable?: boolean): Task;
-    /** Mark the current active goal as done, optionally with experience reflection */
-    completeGoal(roleId: string, experience?: string): void;
-    /** Abandon the current active goal, optionally with experience reflection */
-    abandonGoal(roleId: string, experience?: string): void;
-    /** Mark a task as done */
-    completeTask(roleId: string, name: string): void;
-    /** Reflect: distill experiences into knowledge, removing the original experiences */
-    reflect(roleId: string, experienceNames: string[], knowledgeName: string, knowledgeSource: string): Feature;
-}
-
-/**
- * transitions.ts — State machine definitions and transition logic.
- *
- * Role transitions:
- *   free --(hire)--> member --(appoint)--> on_duty
- *   on_duty --(dismiss)--> member --(fire)--> free
- *   on_duty --(fire)--> free  (auto-dismiss)
- *
- * Position transitions:
- *   vacant --(appoint)--> filled --(dismiss)--> vacant
- */
-
-interface Transition<S extends string> {
-    readonly from: S;
-    readonly to: S;
-    readonly action: string;
-}
-declare const ROLE_MACHINE: Transition<RoleState>[];
-declare const POSITION_MACHINE: Transition<PositionState>[];
-/**
- * Find a transition by current state and action.
- */
-declare function findTransition<S extends string>(machine: Transition<S>[], from: S, action: string): Transition<S> | null;
-/**
- * Check if a transition is valid.
- */
-declare function canTransition<S extends string>(machine: Transition<S>[], from: S, action: string): boolean;
-/**
- * Execute a transition — returns new state or throws.
- */
-declare function transition<S extends string>(machine: Transition<S>[], from: S, action: string): S;
-
-/**
- * relations.ts — One-to-one relationship constraints.
- *
- * - A role can belong to at most one organization
- * - A role can hold at most one position
- * - A position can be held by at most one role
- */
-interface OneToOneConstraint {
-    readonly entity: string;
-    readonly relation: string;
-    readonly description: string;
-}
-declare const RELATIONS: OneToOneConstraint[];
-/**
- * Validate that a one-to-one assignment does not conflict.
- * Throws if the entity is already assigned.
- */
-declare function validateOneToOne(entityName: string, currentValue: string | null, newValue: string, constraintDesc: string): void;
-
-export { type Assignment, type Directory, type Duty, type Feature, type Goal, type Identity, type OneToOneConstraint, type OrganizationConfig, type OrganizationInfo, POSITION_MACHINE, type Plan, type Platform, type PositionInfo, type PositionState, RELATIONS, ROLE_MACHINE, type Role, type RoleEntry, type RoleState, type RolexConfig, type Scenario, type Skill, type Task, type Transition, canTransition, findTransition, getPositionState, getRoleState, transition, validateOneToOne };
+    /** Graph operation engine (may include transparent persistence). */
+    readonly runtime: Runtime;
+    /** Prototype source for merging base State into instances on activate. */
+    readonly prototype?: Prototype;
+    /** Resource management capability (optional — requires resourcexjs). */
+    readonly resourcex?: ResourceX;
+    /** Register a prototype: bind id to a ResourceX source (path or locator). */
+    registerPrototype?(id: string, source: string): void;
+}
+
+declare const society: _rolexjs_system.Structure;
+declare const individual: _rolexjs_system.Structure;
+declare const organization: _rolexjs_system.Structure;
+declare const past: _rolexjs_system.Structure;
+declare const identity: _rolexjs_system.Structure;
+declare const background: _rolexjs_system.Structure;
+declare const tone: _rolexjs_system.Structure;
+declare const mindset: _rolexjs_system.Structure;
+declare const encounter: _rolexjs_system.Structure;
+declare const experience: _rolexjs_system.Structure;
+declare const knowledge: _rolexjs_system.Structure;
+declare const principle: _rolexjs_system.Structure;
+declare const procedure: _rolexjs_system.Structure;
+declare const goal: _rolexjs_system.Structure;
+declare const plan: _rolexjs_system.Structure;
+declare const task: _rolexjs_system.Structure;
+declare const charter: _rolexjs_system.Structure;
+declare const position: _rolexjs_system.Structure;
+declare const duty: _rolexjs_system.Structure;
+
+declare const want: _rolexjs_system.Process;
+declare const planGoal: _rolexjs_system.Process;
+declare const todo: _rolexjs_system.Process;
+declare const finish: _rolexjs_system.Process;
+declare const complete: _rolexjs_system.Process;
+declare const abandon: _rolexjs_system.Process;
+
+declare const reflect: _rolexjs_system.Process;
+declare const realize: _rolexjs_system.Process;
+declare const master: _rolexjs_system.Process;
+
+declare const hire: _rolexjs_system.Process;
+declare const fire: _rolexjs_system.Process;
+declare const appoint: _rolexjs_system.Process;
+declare const dismiss: _rolexjs_system.Process;
+declare const charterOrg: _rolexjs_system.Process;
+declare const charge: _rolexjs_system.Process;
+
+declare const born: _rolexjs_system.Process;
+declare const found: _rolexjs_system.Process;
+declare const establish: _rolexjs_system.Process;
+declare const retire: _rolexjs_system.Process;
+declare const die: _rolexjs_system.Process;
+declare const dissolve: _rolexjs_system.Process;
+declare const abolish: _rolexjs_system.Process;
+declare const rehire: _rolexjs_system.Process;
+
+declare const activate: _rolexjs_system.Process;
+
+export { type Platform, abandon, abolish, activate, appoint, background, born, charge, charter, charterOrg, complete, die, dismiss, dissolve, duty, encounter, establish, experience, finish, fire, found, goal, hire, identity, individual, knowledge, master, mindset, organization, past, plan, planGoal, position, principle, procedure, realize, reflect, rehire, retire, society, task, todo, tone, want };

package/dist/index.js

@@ -1,67 +1,225 @@
-// src/model/states.ts
-function getRoleState(assignment) {
-  if (!assignment) return "free";
-  if (assignment.position) return "on_duty";
-  return "member";
-}
-function getPositionState(assignedRole) {
-  return assignedRole ? "filled" : "vacant";
-}
+// src/index.ts
+import {
+  create as create4,
+  createPrototype,
+  createRuntime,
+  link as link2,
+  mergeState,
+  process as process6,
+  relation as relation2,
+  remove,
+  structure as structure2,
+  transform as transform4,
+  unlink as unlink2
+} from "@rolexjs/system";
 
-// src/model/transitions.ts
-var ROLE_MACHINE = [
-  { from: "free", to: "member", action: "hire" },
-  { from: "member", to: "on_duty", action: "appoint" },
-  { from: "on_duty", to: "member", action: "dismiss" },
-  { from: "member", to: "free", action: "fire" },
-  { from: "on_duty", to: "free", action: "fire" }
-];
-var POSITION_MACHINE = [
-  { from: "vacant", to: "filled", action: "appoint" },
-  { from: "filled", to: "vacant", action: "dismiss" }
-];
-function findTransition(machine, from, action) {
-  return machine.find((t) => t.from === from && t.action === action) ?? null;
-}
-function canTransition(machine, from, action) {
-  return findTransition(machine, from, action) !== null;
-}
-function transition(machine, from, action) {
-  const t = findTransition(machine, from, action);
-  if (!t) {
-    throw new Error(`Invalid transition: cannot "${action}" from state "${from}"`);
-  }
-  return t.to;
-}
+// src/structures.ts
+import { relation, structure } from "@rolexjs/system";
+var society = structure("society", "The RoleX world", null);
+var individual = structure("individual", "A single agent in society", society);
+var organization = structure("organization", "A group of individuals", society, [
+  relation("membership", "Who belongs to this organization", individual)
+]);
+var past = structure("past", "Things no longer active", society);
+var identity = structure("identity", "Who I am", individual);
+var background = structure("background", "My personal background", identity);
+var tone = structure("tone", "My tone of communication", identity);
+var mindset = structure("mindset", "How I think and approach problems", identity);
+var encounter = structure("encounter", "A specific event I went through", individual);
+var experience = structure("experience", "What I learned from encounters", individual);
+var knowledge = structure("knowledge", "What I know", individual);
+var principle = structure("principle", "My rules of conduct", knowledge);
+var procedure = structure("procedure", "My skill references and metadata", knowledge);
+var goal = structure("goal", "What I am pursuing", individual);
+var plan = structure("plan", "How to achieve a goal", goal);
+var task = structure("task", "Concrete unit of work", plan);
+var charter = structure("charter", "The rules and mission", organization);
+var position = structure("position", "A role held by an individual", organization, [
+  relation("appointment", "Who holds this position", individual)
+]);
+var duty = structure("duty", "Responsibilities of this position", position);
 
-// src/model/relations.ts
-var RELATIONS = [
-  {
-    entity: "role",
-    relation: "organization",
-    description: "A role can belong to at most one organization"
-  },
-  { entity: "role", relation: "position", description: "A role can hold at most one position" },
-  {
-    entity: "position",
-    relation: "role",
-    description: "A position can be held by at most one role"
-  }
-];
-function validateOneToOne(entityName, currentValue, newValue, constraintDesc) {
-  if (currentValue && currentValue !== newValue) {
-    throw new Error(`${constraintDesc}: "${entityName}" is already assigned to "${currentValue}"`);
-  }
-}
+// src/execution.ts
+import { create, process, transform } from "@rolexjs/system";
+var want = process("want", "Declare a goal", individual, create(goal));
+var planGoal = process("plan", "Create a plan for a goal", goal, create(plan));
+var todo = process("todo", "Create a task in a plan", plan, create(task));
+var finish = process(
+  "finish",
+  "Complete a task, record as encounter",
+  task,
+  transform(task, encounter)
+);
+var complete = process(
+  "complete",
+  "Complete a plan, record as encounter",
+  plan,
+  transform(plan, encounter)
+);
+var abandon = process(
+  "abandon",
+  "Abandon a plan, record as encounter",
+  plan,
+  transform(plan, encounter)
+);
+
+// src/cognition.ts
+import { process as process2, transform as transform2 } from "@rolexjs/system";
+var reflect = process2(
+  "reflect",
+  "Reflect on encounters, distill into experience",
+  encounter,
+  transform2(encounter, experience)
+);
+var realize = process2(
+  "realize",
+  "Realize a principle from experience",
+  experience,
+  transform2(experience, principle)
+);
+var master = process2(
+  "master",
+  "Master a procedure from experience",
+  experience,
+  transform2(experience, procedure)
+);
+
+// src/organization.ts
+import { create as create2, link, process as process3, unlink } from "@rolexjs/system";
+var hire = process3(
+  "hire",
+  "Hire an individual into the organization",
+  organization,
+  link(organization, "membership")
+);
+var fire = process3(
+  "fire",
+  "Fire an individual from the organization",
+  organization,
+  unlink(organization, "membership")
+);
+var appoint = process3(
+  "appoint",
+  "Appoint a member to a position",
+  position,
+  link(position, "appointment")
+);
+var dismiss = process3(
+  "dismiss",
+  "Dismiss from a position",
+  position,
+  unlink(position, "appointment")
+);
+var charterOrg = process3(
+  "charter",
+  "Define the charter for an organization",
+  organization,
+  create2(charter)
+);
+var charge = process3("charge", "Add a duty to a position", position, create2(duty));
+
+// src/lifecycle.ts
+import { create as create3, process as process4, transform as transform3 } from "@rolexjs/system";
+var born = process4(
+  "born",
+  "An individual is born into society",
+  society,
+  create3(individual)
+);
+var found = process4("found", "Found an organization", society, create3(organization));
+var establish = process4(
+  "establish",
+  "Establish a position in an organization",
+  organization,
+  create3(position)
+);
+var retire = process4(
+  "retire",
+  "Retire an individual",
+  individual,
+  transform3(individual, past)
+);
+var die = process4("die", "An individual dies", individual, transform3(individual, past));
+var dissolve = process4(
+  "dissolve",
+  "Dissolve an organization",
+  organization,
+  transform3(organization, past)
+);
+var abolish = process4(
+  "abolish",
+  "Abolish a position",
+  position,
+  transform3(position, past)
+);
+var rehire = process4(
+  "rehire",
+  "Rehire a retired individual",
+  past,
+  transform3(past, individual)
+);
+
+// src/role.ts
+import { process as process5 } from "@rolexjs/system";
+var activate = process5(
+  "activate",
+  "Activate a role \u2014 load cognition into context",
+  individual
+);
 export {
-  POSITION_MACHINE,
-  RELATIONS,
-  ROLE_MACHINE,
-  canTransition,
-  findTransition,
-  getPositionState,
-  getRoleState,
-  transition,
-  validateOneToOne
+  abandon,
+  abolish,
+  activate,
+  appoint,
+  background,
+  born,
+  charge,
+  charter,
+  charterOrg,
+  complete,
+  create4 as create,
+  createPrototype,
+  createRuntime,
+  die,
+  dismiss,
+  dissolve,
+  duty,
+  encounter,
+  establish,
+  experience,
+  finish,
+  fire,
+  found,
+  goal,
+  hire,
+  identity,
+  individual,
+  knowledge,
+  link2 as link,
+  master,
+  mergeState,
+  mindset,
+  organization,
+  past,
+  plan,
+  planGoal,
+  position,
+  principle,
+  procedure,
+  process6 as process,
+  realize,
+  reflect,
+  rehire,
+  relation2 as relation,
+  remove,
+  retire,
+  society,
+  structure2 as structure,
+  task,
+  todo,
+  tone,
+  transform4 as transform,
+  unlink2 as unlink,
+  want
 };
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/model/states.ts","../src/model/transitions.ts","../src/model/relations.ts"],"sourcesContent":["/**\n * states.ts — Role and Position state definitions.\n *\n * Role:     free → member → on_duty\n * Position: vacant → filled\n */\n\nexport type RoleState = \"free\" | \"member\" | \"on_duty\";\nexport type PositionState = \"vacant\" | \"filled\";\n\n/**\n * Derive a role's state from assignment data.\n */\nexport function getRoleState(assignment: { org: string; position?: string } | null): RoleState {\n  if (!assignment) return \"free\";\n  if (assignment.position) return \"on_duty\";\n  return \"member\";\n}\n\n/**\n * Derive a position's state from assignment data.\n */\nexport function getPositionState(assignedRole: string | null): PositionState {\n  return assignedRole ? \"filled\" : \"vacant\";\n}\n","/**\n * transitions.ts — State machine definitions and transition logic.\n *\n * Role transitions:\n *   free --(hire)--> member --(appoint)--> on_duty\n *   on_duty --(dismiss)--> member --(fire)--> free\n *   on_duty --(fire)--> free  (auto-dismiss)\n *\n * Position transitions:\n *   vacant --(appoint)--> filled --(dismiss)--> vacant\n */\n\nimport type { RoleState, PositionState } from \"./states.js\";\n\nexport interface Transition<S extends string> {\n  readonly from: S;\n  readonly to: S;\n  readonly action: string;\n}\n\nexport const ROLE_MACHINE: Transition<RoleState>[] = [\n  { from: \"free\", to: \"member\", action: \"hire\" },\n  { from: \"member\", to: \"on_duty\", action: \"appoint\" },\n  { from: \"on_duty\", to: \"member\", action: \"dismiss\" },\n  { from: \"member\", to: \"free\", action: \"fire\" },\n  { from: \"on_duty\", to: \"free\", action: \"fire\" },\n];\n\nexport const POSITION_MACHINE: Transition<PositionState>[] = [\n  { from: \"vacant\", to: \"filled\", action: \"appoint\" },\n  { from: \"filled\", to: \"vacant\", action: \"dismiss\" },\n];\n\n/**\n * Find a transition by current state and action.\n */\nexport function findTransition<S extends string>(\n  machine: Transition<S>[],\n  from: S,\n  action: string\n): Transition<S> | null {\n  return machine.find((t) => t.from === from && t.action === action) ?? null;\n}\n\n/**\n * Check if a transition is valid.\n */\nexport function canTransition<S extends string>(\n  machine: Transition<S>[],\n  from: S,\n  action: string\n): boolean {\n  return findTransition(machine, from, action) !== null;\n}\n\n/**\n * Execute a transition — returns new state or throws.\n */\nexport function transition<S extends string>(machine: Transition<S>[], from: S, action: string): S {\n  const t = findTransition(machine, from, action);\n  if (!t) {\n    throw new Error(`Invalid transition: cannot \"${action}\" from state \"${from}\"`);\n  }\n  return t.to;\n}\n","/**\n * relations.ts — One-to-one relationship constraints.\n *\n * - A role can belong to at most one organization\n * - A role can hold at most one position\n * - A position can be held by at most one role\n */\n\nexport interface OneToOneConstraint {\n  readonly entity: string;\n  readonly relation: string;\n  readonly description: string;\n}\n\nexport const RELATIONS: OneToOneConstraint[] = [\n  {\n    entity: \"role\",\n    relation: \"organization\",\n    description: \"A role can belong to at most one organization\",\n  },\n  { entity: \"role\", relation: \"position\", description: \"A role can hold at most one position\" },\n  {\n    entity: \"position\",\n    relation: \"role\",\n    description: \"A position can be held by at most one role\",\n  },\n];\n\n/**\n * Validate that a one-to-one assignment does not conflict.\n * Throws if the entity is already assigned.\n */\nexport function validateOneToOne(\n  entityName: string,\n  currentValue: string | null,\n  newValue: string,\n  constraintDesc: string\n): void {\n  if (currentValue && currentValue !== newValue) {\n    throw new Error(`${constraintDesc}: \"${entityName}\" is already assigned to \"${currentValue}\"`);\n  }\n}\n"],"mappings":";AAaO,SAAS,aAAa,YAAkE;AAC7F,MAAI,CAAC,WAAY,QAAO;AACxB,MAAI,WAAW,SAAU,QAAO;AAChC,SAAO;AACT;AAKO,SAAS,iBAAiB,cAA4C;AAC3E,SAAO,eAAe,WAAW;AACnC;;;ACJO,IAAM,eAAwC;AAAA,EACnD,EAAE,MAAM,QAAQ,IAAI,UAAU,QAAQ,OAAO;AAAA,EAC7C,EAAE,MAAM,UAAU,IAAI,WAAW,QAAQ,UAAU;AAAA,EACnD,EAAE,MAAM,WAAW,IAAI,UAAU,QAAQ,UAAU;AAAA,EACnD,EAAE,MAAM,UAAU,IAAI,QAAQ,QAAQ,OAAO;AAAA,EAC7C,EAAE,MAAM,WAAW,IAAI,QAAQ,QAAQ,OAAO;AAChD;AAEO,IAAM,mBAAgD;AAAA,EAC3D,EAAE,MAAM,UAAU,IAAI,UAAU,QAAQ,UAAU;AAAA,EAClD,EAAE,MAAM,UAAU,IAAI,UAAU,QAAQ,UAAU;AACpD;AAKO,SAAS,eACd,SACA,MACA,QACsB;AACtB,SAAO,QAAQ,KAAK,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,WAAW,MAAM,KAAK;AACxE;AAKO,SAAS,cACd,SACA,MACA,QACS;AACT,SAAO,eAAe,SAAS,MAAM,MAAM,MAAM;AACnD;AAKO,SAAS,WAA6B,SAA0B,MAAS,QAAmB;AACjG,QAAM,IAAI,eAAe,SAAS,MAAM,MAAM;AAC9C,MAAI,CAAC,GAAG;AACN,UAAM,IAAI,MAAM,+BAA+B,MAAM,iBAAiB,IAAI,GAAG;AAAA,EAC/E;AACA,SAAO,EAAE;AACX;;;AClDO,IAAM,YAAkC;AAAA,EAC7C;AAAA,IACE,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,aAAa;AAAA,EACf;AAAA,EACA,EAAE,QAAQ,QAAQ,UAAU,YAAY,aAAa,uCAAuC;AAAA,EAC5F;AAAA,IACE,QAAQ;AAAA,IACR,UAAU;AAAA,IACV,aAAa;AAAA,EACf;AACF;AAMO,SAAS,iBACd,YACA,cACA,UACA,gBACM;AACN,MAAI,gBAAgB,iBAAiB,UAAU;AAC7C,UAAM,IAAI,MAAM,GAAG,cAAc,MAAM,UAAU,6BAA6B,YAAY,GAAG;AAAA,EAC/F;AACF;","names":[]}
+{"version":3,"sources":["../src/index.ts","../src/structures.ts","../src/execution.ts","../src/cognition.ts","../src/organization.ts","../src/lifecycle.ts","../src/role.ts"],"sourcesContent":["/**\n * @rolexjs/core — RoleX Concept World\n *\n * Domain-specific structures and processes built on @rolexjs/system.\n *\n * Structures — the concept tree (19 concepts, 2 relations)\n * Processes  — how the world changes (24 processes, 4 layers)\n *\n *   Layer 1: Execution   — want, plan, todo, finish, complete, abandon\n *   Layer 2: Cognition   — reflect, realize, master\n *   Layer 3: Organization — hire, fire, appoint, dismiss, charter, charge\n *   Layer 4: Lifecycle   — born, found, establish, retire, die, dissolve, abolish, rehire\n *   + Role: activate\n */\n\n// Re-export system primitives\nexport {\n  type Create,\n  create,\n  createPrototype,\n  createRuntime,\n  type GraphOp,\n  type Link,\n  link,\n  mergeState,\n  type Process,\n  type Prototype,\n  process,\n  type Relation,\n  type Remove,\n  type Runtime,\n  relation,\n  remove,\n  type State,\n  type Structure,\n  structure,\n  type Transform,\n  transform,\n  type Unlink,\n  unlink,\n} from \"@rolexjs/system\";\n\n// Platform\nexport type { Platform } from \"./platform.js\";\n\n// ===== Structures =====\n\nexport {\n  background,\n  // Organization\n  charter,\n  duty,\n  // Individual — Cognition\n  encounter,\n  experience,\n  // Individual — Execution\n  goal,\n  // Individual — Identity\n  identity,\n  // Level 1\n  individual,\n  // Individual — Knowledge\n  knowledge,\n  mindset,\n  organization,\n  past,\n  plan,\n  position,\n  principle,\n  procedure,\n  // Level 0\n  society,\n  task,\n  tone,\n} from \"./structures.js\";\n\n// ===== Processes — Layer 1: Execution =====\n\nexport { abandon, complete, finish, planGoal, todo, want } from \"./execution.js\";\n\n// ===== Processes — Layer 2: Cognition =====\n\nexport { master, realize, reflect } from \"./cognition.js\";\n\n// ===== Processes — Layer 3: Organization =====\n\nexport { appoint, charge, charterOrg, dismiss, fire, hire } from \"./organization.js\";\n\n// ===== Processes — Layer 4: Lifecycle =====\n\nexport { abolish, born, die, dissolve, establish, found, rehire, retire } from \"./lifecycle.js\";\n\n// ===== Role =====\n\nexport { activate } from \"./role.js\";\n","/**\n * RoleX Concept World — all structure definitions.\n *\n * Every node is a Structure — simultaneously concept, container,\n * and information carrier. Tree (parent-child) provides the\n * hierarchical backbone. Relations provide cross-branch links.\n *\n * ┌─────────────────────────────────────────────────────────┐\n * │ society                                                 │\n * │ ├── individual          \"A single agent in society\"     │\n * │ │   ├── identity        \"Who I am\"                      │\n * │ │   │   ├── background  \"My personal background\"        │\n * │ │   │   ├── tone        \"My tone of communication\"      │\n * │ │   │   └── mindset     \"How I think\"                   │\n * │ │   ├── encounter       \"A specific event I went through\"│\n * │ │   ├── experience      \"What I learned from encounters\" │\n * │ │   ├── knowledge       \"What I know\"                   │\n * │ │   │   ├── principle   \"My rules of conduct\"           │\n * │ │   │   └── procedure   \"My skill references and metadata\"│\n * │ │   └── goal            \"What I am pursuing\"            │\n * │ │       └── plan        \"How to achieve a goal\"         │\n * │ │           └── task    \"Concrete unit of work\"         │\n * │ ├── organization        \"A group of individuals\"        │\n * │ │   │  ∿ membership → individual                        │\n * │ │   ├── charter         \"The rules and mission\"         │\n * │ │   └── position        \"A role held by an individual\"  │\n * │ │       │  ∿ appointment → individual                   │\n * │ │       └── duty        \"Responsibilities of position\"  │\n * │ └── past                \"Things no longer active\"        │\n * └─────────────────────────────────────────────────────────┘\n */\nimport { relation, structure } from \"@rolexjs/system\";\n\n// ================================================================\n//  Level 0 — Root\n// ================================================================\n\nexport const society = structure(\"society\", \"The RoleX world\", null);\n\n// ================================================================\n//  Level 1 — Three pillars\n// ================================================================\n\nexport const individual = structure(\"individual\", \"A single agent in society\", society);\nexport const organization = structure(\"organization\", \"A group of individuals\", society, [\n  relation(\"membership\", \"Who belongs to this organization\", individual),\n]);\nexport const past = structure(\"past\", \"Things no longer active\", society);\n\n// ================================================================\n//  Individual — Identity\n// ================================================================\n\nexport const identity = structure(\"identity\", \"Who I am\", individual);\nexport const background = structure(\"background\", \"My personal background\", identity);\nexport const tone = structure(\"tone\", \"My tone of communication\", identity);\nexport const mindset = structure(\"mindset\", \"How I think and approach problems\", identity);\n\n// ================================================================\n//  Individual — Cognition\n// ================================================================\n\nexport const encounter = structure(\"encounter\", \"A specific event I went through\", individual);\nexport const experience = structure(\"experience\", \"What I learned from encounters\", individual);\n\n// ================================================================\n//  Individual — Knowledge\n// ================================================================\n\nexport const knowledge = structure(\"knowledge\", \"What I know\", individual);\nexport const principle = structure(\"principle\", \"My rules of conduct\", knowledge);\nexport const procedure = structure(\"procedure\", \"My skill references and metadata\", knowledge);\n\n// ================================================================\n//  Individual — Execution\n// ================================================================\n\nexport const goal = structure(\"goal\", \"What I am pursuing\", individual);\nexport const plan = structure(\"plan\", \"How to achieve a goal\", goal);\nexport const task = structure(\"task\", \"Concrete unit of work\", plan);\n\n// ================================================================\n//  Organization\n// ================================================================\n\nexport const charter = structure(\"charter\", \"The rules and mission\", organization);\nexport const position = structure(\"position\", \"A role held by an individual\", organization, [\n  relation(\"appointment\", \"Who holds this position\", individual),\n]);\nexport const duty = structure(\"duty\", \"Responsibilities of this position\", position);\n","/**\n * Execution cycle — the doing loop.\n *\n * want → plan → todo → finish → (encounter) → want → ...\n *                plan → complete → (encounter)\n *                plan → abandon  → (encounter)\n *\n * Goals are long-term directions. Plans are the completable unit —\n * they can be completed or abandoned. Tasks finish individually.\n * All transforms produce encounters — feeding the cognition cycle.\n */\nimport { create, process, transform } from \"@rolexjs/system\";\nimport { encounter, goal, individual, plan, task } from \"./structures.js\";\n\nexport const want = process(\"want\", \"Declare a goal\", individual, create(goal));\nexport const planGoal = process(\"plan\", \"Create a plan for a goal\", goal, create(plan));\nexport const todo = process(\"todo\", \"Create a task in a plan\", plan, create(task));\n\nexport const finish = process(\n  \"finish\",\n  \"Complete a task, record as encounter\",\n  task,\n  transform(task, encounter)\n);\nexport const complete = process(\n  \"complete\",\n  \"Complete a plan, record as encounter\",\n  plan,\n  transform(plan, encounter)\n);\nexport const abandon = process(\n  \"abandon\",\n  \"Abandon a plan, record as encounter\",\n  plan,\n  transform(plan, encounter)\n);\n","/**\n * Cognition cycle — the learning loop.\n *\n * encounter → reflect → experience → realize → principle\n *                                   → master  → procedure\n *\n * Encounters are raw events (produced by the execution cycle).\n * Reflection distills them into experience. From experience,\n * principles are realized and procedures are mastered.\n */\nimport { process, transform } from \"@rolexjs/system\";\nimport { encounter, experience, principle, procedure } from \"./structures.js\";\n\nexport const reflect = process(\n  \"reflect\",\n  \"Reflect on encounters, distill into experience\",\n  encounter,\n  transform(encounter, experience)\n);\nexport const realize = process(\n  \"realize\",\n  \"Realize a principle from experience\",\n  experience,\n  transform(experience, principle)\n);\nexport const master = process(\n  \"master\",\n  \"Master a procedure from experience\",\n  experience,\n  transform(experience, procedure)\n);\n","/**\n * Organization management — hiring, firing, and structuring.\n *\n * hire / fire         — membership (who belongs)\n * appoint / dismiss   — appointment (who holds a position)\n * charter             — define org rules and mission\n * charge              — add duties to a position\n */\nimport { create, link, process, unlink } from \"@rolexjs/system\";\nimport { charter, duty, organization, position } from \"./structures.js\";\n\n// Membership\nexport const hire = process(\n  \"hire\",\n  \"Hire an individual into the organization\",\n  organization,\n  link(organization, \"membership\")\n);\nexport const fire = process(\n  \"fire\",\n  \"Fire an individual from the organization\",\n  organization,\n  unlink(organization, \"membership\")\n);\n\n// Appointment\nexport const appoint = process(\n  \"appoint\",\n  \"Appoint a member to a position\",\n  position,\n  link(position, \"appointment\")\n);\nexport const dismiss = process(\n  \"dismiss\",\n  \"Dismiss from a position\",\n  position,\n  unlink(position, \"appointment\")\n);\n\n// Structure\nexport const charterOrg = process(\n  \"charter\",\n  \"Define the charter for an organization\",\n  organization,\n  create(charter)\n);\nexport const charge = process(\"charge\", \"Add a duty to a position\", position, create(duty));\n","/**\n * Lifecycle — creation, retirement, and dissolution.\n *\n * born / found / establish   — bring things into existence\n * retire / die               — individual → past\n * dissolve                   — organization → past\n * abolish                    — position → past\n * rehire                     — past → individual (return from retirement)\n *\n * No real deletion — everything transforms to the \"past\" branch.\n */\nimport { create, process, transform } from \"@rolexjs/system\";\nimport { individual, organization, past, position, society } from \"./structures.js\";\n\n// Creation\nexport const born = process(\n  \"born\",\n  \"An individual is born into society\",\n  society,\n  create(individual)\n);\nexport const found = process(\"found\", \"Found an organization\", society, create(organization));\nexport const establish = process(\n  \"establish\",\n  \"Establish a position in an organization\",\n  organization,\n  create(position)\n);\n\n// Retirement & death\nexport const retire = process(\n  \"retire\",\n  \"Retire an individual\",\n  individual,\n  transform(individual, past)\n);\nexport const die = process(\"die\", \"An individual dies\", individual, transform(individual, past));\n\n// Dissolution\nexport const dissolve = process(\n  \"dissolve\",\n  \"Dissolve an organization\",\n  organization,\n  transform(organization, past)\n);\nexport const abolish = process(\n  \"abolish\",\n  \"Abolish a position\",\n  position,\n  transform(position, past)\n);\n\n// Return\nexport const rehire = process(\n  \"rehire\",\n  \"Rehire a retired individual\",\n  past,\n  transform(past, individual)\n);\n","/**\n * Role projection — activating a role loads cognition into context.\n *\n * A role is not a Structure — it is a State (projection).\n * What to load is defined by the upper layer.\n */\nimport { process } from \"@rolexjs/system\";\nimport { individual } from \"./structures.js\";\n\nexport const activate = process(\n  \"activate\",\n  \"Activate a role — load cognition into context\",\n  individual\n);\n"],"mappings":"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","names":["create","link","process","relation","structure","transform","unlink","process","transform","process","transform","create","process","process","create","create","process","transform","process","create","transform","process","process"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rolexjs/core",
-  "version": "0.10.0",
+  "version": "0.11.0-dev.0",
   "description": "RoleX Core - AI Agent Role Management Framework",
   "keywords": [
     "rolex",
@@ -23,6 +23,7 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
       "default": "./dist/index.js"
     }
   },
@@ -32,15 +33,16 @@
   ],
   "scripts": {
     "build": "tsup",
-    "test": "bun test || true",
-    "lint": "eslint .",
+    "test": "echo 'no tests yet'",
+    "lint": "biome lint .",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
-  "dependencies": {},
-  "devDependencies": {
-    "@cucumber/messages": "^32.0.1"
+  "dependencies": {
+    "@rolexjs/system": "workspace:*",
+    "resourcexjs": "^2.8.0"
   },
+  "devDependencies": {},
   "publishConfig": {
     "access": "public"
   }