@rolexjs/core 1.4.0-dev-20260306030100 → 1.4.0-dev-20260309051522

package/dist/index.d.ts

@@ -115,6 +115,11 @@ declare const scope: _rolexjs_system.Structure;
 declare const milestone: _rolexjs_system.Structure;
 declare const deliverable: _rolexjs_system.Structure;
 declare const wiki: _rolexjs_system.Structure;
+declare const product: _rolexjs_system.Structure;
+declare const strategy: _rolexjs_system.Structure;
+declare const spec: _rolexjs_system.Structure;
+declare const release: _rolexjs_system.Structure;
+declare const channel: _rolexjs_system.Structure;
 
 declare const activate: _rolexjs_system.Process;
 declare const want: _rolexjs_system.Process;
@@ -142,13 +147,22 @@ declare const milestoneProject: _rolexjs_system.Process;
 declare const deliverProject: _rolexjs_system.Process;
 declare const wikiProject: _rolexjs_system.Process;
 
+declare const ownProduct: _rolexjs_system.Process;
+declare const disownProduct: _rolexjs_system.Process;
+declare const strategyProduct: _rolexjs_system.Process;
+declare const specProduct: _rolexjs_system.Process;
+declare const releaseProduct: _rolexjs_system.Process;
+declare const channelProduct: _rolexjs_system.Process;
+
 declare const born: _rolexjs_system.Process;
 declare const found: _rolexjs_system.Process;
 declare const establish: _rolexjs_system.Process;
 declare const launch: _rolexjs_system.Process;
+declare const publish: _rolexjs_system.Process;
 declare const retire: _rolexjs_system.Process;
 declare const die: _rolexjs_system.Process;
 declare const archive: _rolexjs_system.Process;
+declare const deprecate: _rolexjs_system.Process;
 declare const dissolve: _rolexjs_system.Process;
 declare const abolish: _rolexjs_system.Process;
 declare const rehire: _rolexjs_system.Process;
@@ -213,6 +227,14 @@ interface CommandResultMap {
     "project.deliver": CommandResult;
     "project.wiki": CommandResult;
     "project.archive": CommandResult;
+    "product.create": CommandResult;
+    "product.strategy": CommandResult;
+    "product.spec": CommandResult;
+    "product.release": CommandResult;
+    "product.channel": CommandResult;
+    "product.own": CommandResult;
+    "product.disown": CommandResult;
+    "product.deprecate": CommandResult;
     "org.found": CommandResult;
     "org.charter": CommandResult;
     "org.dissolve": CommandResult;
@@ -546,4 +568,4 @@ interface Protocol {
 /** The protocol instance — single source of truth for all channel adapters. */
 declare const protocol: Protocol;
 
-export { type ApplyResult, type ArgEntry, type CommandContext, type CommandResult, type CommandResultMap, type Commands, type ContextData, type InstructionDef, type Migration, type MigrationRecord, type ParamDef, type ParamType, type Platform, type Protocol, type PrototypeData, type PrototypeRepository, type Renderer, RendererRouter, Role, type RoleDeps, type RoleSnapshot, type RoleX, type RoleXRepository, RoleXService, type ToolDef, abandon, abolish, activate, applyPrototype, appoint, archive, background, born, charge, charter, charterOrg, complete, createCommands, deliverProject, deliverable, die, directives, dismiss, dissolve, duty, encounter, enroll, establish, experience, findInState, finish, fire, found, goal, hire, identity, individual, instructions, launch, master, milestone, milestoneProject, mindset, organization, past, plan, planGoal, position, principle, procedure, processes, project, protocol, realize, reflect, rehire, removeParticipant, requirement, retire, scope, scopeProject, society, task, toArgs, todo, tone, want, wiki, wikiProject, world };
+export { type ApplyResult, type ArgEntry, type CommandContext, type CommandResult, type CommandResultMap, type Commands, type ContextData, type InstructionDef, type Migration, type MigrationRecord, type ParamDef, type ParamType, type Platform, type Protocol, type PrototypeData, type PrototypeRepository, type Renderer, RendererRouter, Role, type RoleDeps, type RoleSnapshot, type RoleX, type RoleXRepository, RoleXService, type ToolDef, abandon, abolish, activate, applyPrototype, appoint, archive, background, born, channel, channelProduct, charge, charter, charterOrg, complete, createCommands, deliverProject, deliverable, deprecate, die, directives, dismiss, disownProduct, dissolve, duty, encounter, enroll, establish, experience, findInState, finish, fire, found, goal, hire, identity, individual, instructions, launch, master, milestone, milestoneProject, mindset, organization, ownProduct, past, plan, planGoal, position, principle, procedure, processes, product, project, protocol, publish, realize, reflect, rehire, release, releaseProduct, removeParticipant, requirement, retire, scope, scopeProject, society, spec, specProduct, strategy, strategyProduct, task, toArgs, todo, tone, want, wiki, wikiProject, world };

package/dist/index.js

@@ -1,14 +1,14 @@
 // src/index.ts
 import {
-  create as create5,
+  create as create6,
   createRuntime,
-  link as link3,
-  process as process6,
+  link as link4,
+  process as process7,
   relation as relation2,
   remove,
   structure as structure3,
   transform as transform4,
-  unlink as unlink3
+  unlink as unlink4
 } from "@rolexjs/system";
 
 // src/structures.ts
@@ -52,6 +52,16 @@ var milestone = structure(
 );
 var deliverable = structure("deliverable", "Project output and delivery", project);
 var wiki = structure("wiki", "Project-level knowledge base entry", project);
+var product = structure(
+  "product",
+  "A product with vision, contracts, and releases",
+  society,
+  [relation("ownership", "Who owns this product", individual)]
+);
+var strategy = structure("strategy", "Product strategy \u2014 how to win", product);
+var spec = structure("spec", "Product behavior contract \u2014 BDD specification", product);
+var release = structure("release", "Product version release", product);
+var channel = structure("channel", "Product distribution channel", product);
 
 // src/execution.ts
 import { create, process, transform } from "@rolexjs/system";
@@ -171,38 +181,84 @@ var deliverProject = process4(
 );
 var wikiProject = process4("wiki", "Add a wiki entry to a project", project, create3(wiki));
 
+// src/product.ts
+import { create as create4, link as link3, process as process5, unlink as unlink3 } from "@rolexjs/system";
+var ownProduct = process5(
+  "own",
+  "Assign an owner to the product",
+  product,
+  link3(product, "ownership")
+);
+var disownProduct = process5(
+  "disown",
+  "Remove an owner from the product",
+  product,
+  unlink3(product, "ownership")
+);
+var strategyProduct = process5(
+  "strategy",
+  "Define the strategy for a product",
+  product,
+  create4(strategy)
+);
+var specProduct = process5(
+  "spec",
+  "Add a behavior contract to a product",
+  product,
+  create4(spec)
+);
+var releaseProduct = process5(
+  "release",
+  "Add a version release to a product",
+  product,
+  create4(release)
+);
+var channelProduct = process5(
+  "channel",
+  "Add a distribution channel to a product",
+  product,
+  create4(channel)
+);
+
 // src/lifecycle.ts
-import { create as create4, process as process5, transform as transform3 } from "@rolexjs/system";
-var born = process5(
+import { create as create5, process as process6, transform as transform3 } from "@rolexjs/system";
+var born = process6(
   "born",
   "An individual is born into society",
   society,
-  create4(individual)
+  create5(individual)
 );
-var found = process5("found", "Found an organization", society, create4(organization));
-var establish = process5("establish", "Establish a position", society, create4(position));
-var launch = process5("launch", "Launch a project", society, create4(project));
-var retire = process5(
+var found = process6("found", "Found an organization", society, create5(organization));
+var establish = process6("establish", "Establish a position", society, create5(position));
+var launch = process6("launch", "Launch a project", society, create5(project));
+var publish = process6("publish", "Publish a product", society, create5(product));
+var retire = process6(
   "retire",
   "Retire an individual",
   individual,
   transform3(individual, past)
 );
-var die = process5("die", "An individual dies", individual, transform3(individual, past));
-var archive = process5("archive", "Archive a project", project, transform3(project, past));
-var dissolve = process5(
+var die = process6("die", "An individual dies", individual, transform3(individual, past));
+var archive = process6("archive", "Archive a project", project, transform3(project, past));
+var deprecate = process6(
+  "deprecate",
+  "Deprecate a product",
+  product,
+  transform3(product, past)
+);
+var dissolve = process6(
   "dissolve",
   "Dissolve an organization",
   organization,
   transform3(organization, past)
 );
-var abolish = process5(
+var abolish = process6(
   "abolish",
   "Abolish a position",
   position,
   transform3(position, past)
 );
-var rehire = process5(
+var rehire = process6(
   "rehire",
   "Rehire a retired individual",
   past,
@@ -280,8 +336,8 @@ var Role = class {
   // ================================================================
   fmt(command, result) {
     const rendered = this.deps.renderer.render(command, result);
-    const process7 = command.includes(".") ? command.slice(command.indexOf(".") + 1) : command;
-    const ch = this.cognitiveHint(process7);
+    const process8 = command.includes(".") ? command.slice(command.indexOf(".") + 1) : command;
+    const ch = this.cognitiveHint(process8);
     if (!ch) return rendered;
     const lines = rendered.split("\n");
     lines.splice(2, 0, `I \u2192 ${ch}`);
@@ -510,8 +566,8 @@ var Role = class {
   // ================================================================
   //  Cognitive hints
   // ================================================================
-  cognitiveHint(process7) {
-    switch (process7) {
+  cognitiveHint(process8) {
+    switch (process8) {
       case "activate":
         if (!this.focusedGoalId)
           return "I have no goal yet. I should call `want` to declare one, or `focus` to review existing goals.";
@@ -590,13 +646,13 @@ import { parse } from "@rolexjs/parser";
 import { structure as structure2 } from "@rolexjs/system";
 function createCommands(ctx) {
   const { rt, society: society2, past: past2, resolve, resourcex, issuex } = ctx;
-  async function ok(node, process7) {
-    return { state: await rt.project(node), process: process7 };
+  async function ok(node, process8) {
+    return { state: await rt.project(node), process: process8 };
   }
-  async function archive2(node, process7) {
+  async function archive2(node, process8) {
     const target = structure2(node.name, node.description ?? "", past);
     const archived = await rt.transform(node, target);
-    return ok(archived, process7);
+    return ok(archived, process8);
   }
   function validateGherkin(source) {
     if (!source) return;
@@ -821,6 +877,45 @@ ${text}`;
     async "project.archive"(project2) {
       return archive2(await resolve(project2), "archive");
     },
+    // ---- Product ----
+    async "product.create"(content, id, alias) {
+      validateGherkin(content);
+      const node = await rt.create(society2, product, content, id, alias);
+      return ok(node, "create");
+    },
+    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");
+    },
     // ---- Org ----
     async "org.found"(content, id, alias) {
       validateGherkin(content);
@@ -1549,6 +1644,114 @@ var projectArchive = def(
   },
   ["project"]
 );
+var productCreate = def(
+  "product",
+  "create",
+  {
+    content: {
+      type: "gherkin",
+      required: false,
+      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" }
+  },
+  ["content", "id", "alias"]
+);
+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" }
+  },
+  ["product", "content", "id"]
+);
+var productSpec = def(
+  "product",
+  "spec",
+  {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
+      type: "gherkin",
+      required: true,
+      description: "Gherkin Feature source for the behavior contract (BDD specification)"
+    },
+    id: {
+      type: "string",
+      required: true,
+      description: "Spec id (keywords joined by hyphens)"
+    }
+  },
+  ["product", "content", "id"]
+);
+var productRelease = def(
+  "product",
+  "release",
+  {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
+      type: "gherkin",
+      required: true,
+      description: "Gherkin Feature source for the release"
+    },
+    id: {
+      type: "string",
+      required: true,
+      description: "Release id (e.g. v1.0.0)"
+    }
+  },
+  ["product", "content", "id"]
+);
+var productChannel = def(
+  "product",
+  "channel",
+  {
+    product: { type: "string", required: true, description: "Product id" },
+    content: {
+      type: "gherkin",
+      required: true,
+      description: "Gherkin Feature source for the distribution channel"
+    },
+    id: {
+      type: "string",
+      required: true,
+      description: "Channel id (e.g. npm, cloud-platform)"
+    }
+  },
+  ["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"]
+);
+var productDeprecate = def(
+  "product",
+  "deprecate",
+  {
+    product: { type: "string", required: true, description: "Product id" }
+  },
+  ["product"]
+);
 var censusList = def(
   "census",
   "list",
@@ -1556,7 +1759,7 @@ var censusList = def(
     type: {
       type: "string",
       required: false,
-      description: "Filter by type (individual, organization, position, project, past)"
+      description: "Filter by type (individual, organization, position, project, product, past)"
     }
   },
   ["type"]
@@ -1782,6 +1985,15 @@ var instructions = {
   "project.deliver": projectDeliver,
   "project.wiki": projectWiki,
   "project.archive": projectArchive,
+  // product
+  "product.create": productCreate,
+  "product.strategy": productStrategy,
+  "product.spec": productSpec,
+  "product.release": productRelease,
+  "product.channel": productChannel,
+  "product.own": productOwn,
+  "product.disown": productDisown,
+  "product.deprecate": productDeprecate,
   // census
   "census.list": censusList,
   // prototype
@@ -2280,6 +2492,95 @@ var world = {
     Then tool names and concept names are appropriate \u2014 they are the domain language
     And this rule applies to end-user communication, not developer communication`,
   execution: "Feature: Execution \u2014 the doing cycle\n  The role pursues goals through a structured lifecycle.\n  activate \u2192 want \u2192 plan \u2192 todo \u2192 finish \u2192 complete or abandon.\n\n  Scenario: Declare a goal\n    Given I know who I am via activate\n    When I want something \u2014 a desired outcome\n    Then I declare it with want(id, goal)\n    And focus automatically switches to this new goal\n\n  Scenario: Plan and create tasks\n    Given I have a focused goal\n    Then I call plan(id, plan) to break it into logical phases\n    And I call todo(id, task) to create concrete, actionable tasks\n\n  Scenario: Execute and finish\n    Given I have tasks to work on\n    When I complete a task\n    Then I call finish(id) to mark it done\n    And an encounter is created \u2014 a raw record of what happened\n    And I optionally capture what happened via the encounter parameter\n\n  Scenario: Complete or abandon a plan\n    Given tasks are done or the plan's strategy is no longer viable\n    When the plan is fulfilled I call complete()\n    Or when the plan should be dropped I call abandon()\n    Then an encounter is created for the cognition cycle\n\n  Scenario: Goals are long-term directions\n    Given goals are managed with want and forget\n    When a goal is no longer needed\n    Then I call forget to remove it\n    And learning is captured at the plan and task level through encounters\n\n  Scenario: Multiple goals\n    Given I may have several active goals\n    When I need to switch between them\n    Then I call focus(id) to change the currently focused goal\n    And subsequent plan and todo operations target the focused goal",
+  issue: `Feature: Issue \u2014 persistent structured collaboration beyond a single context
+  AI individuals face a fundamental challenge: context breaks.
+  Each new session starts fresh \u2014 identity and knowledge survive, but the working state is lost.
+  Like humans writing journals and memos, individuals need externalized records
+  that persist across sessions and across individuals.
+
+  Issue is the externalized, structured collaboration primitive of the RoleX world.
+  It enables both self-collaboration (same individual, different sessions)
+  and inter-individual collaboration (different individuals, asynchronous).
+
+  Scenario: Why issues exist
+    Given AI individuals have a context window limit
+    And each new session loses the previous working state
+    And multiple individuals may need to coordinate without being active simultaneously
+    When structured, persistent, discoverable records are needed
+    Then issues serve as externalized working memory for the society
+    And they survive context breaks, session restarts, and individual switches
+
+  Scenario: Self-collaboration \u2014 continuity across sessions
+    Given an individual is working on something that spans multiple sessions
+    When the context window resets or a new session begins
+    Then the individual can publish or check issues to restore working context
+    And comments serve as a journal \u2014 recording progress, decisions, and next steps
+    And the issue persists until explicitly closed, regardless of how many sessions pass
+
+  Scenario: Inter-individual collaboration \u2014 asynchronous coordination
+    Given multiple individuals need to work together
+    And they are never active simultaneously
+    When one individual publishes an issue or leaves a comment
+    Then other individuals can discover it, respond, and contribute
+    And assignee indicates who should act next
+    And labels categorize across concerns
+
+  Scenario: Relationship to goals and tasks
+    Given goals express intent \u2014 what I want to achieve
+    And tasks express action \u2014 what I am doing right now
+    When an issue is something that needs ongoing attention and discussion
+    Then issues may inspire goals, or goals may spawn issues
+    And issues may be resolved by tasks, or tasks may surface new issues
+    But issues are independent \u2014 they belong to the society, not to any single individual's goal tree
+
+  Scenario: Publish a new issue
+    Given I need to raise a topic for attention
+    When I call use("!issue.publish", { title, body, author, assignee? })
+    Then a new issue is created with an auto-incremented number
+    And author should be the active individual's id
+
+  Scenario: Browse and view issues
+    Given I need to see what issues exist
+    When I call use("!issue.list", { status?, author?, assignee?, label? })
+    Then matching issues are returned ordered by number descending
+    When I need details of a specific issue
+    Then I call use("!issue.get", { number })
+
+  Scenario: Update, close, and reopen
+    Given I need to manage an issue's lifecycle
+    When I call use("!issue.update", { number, title?, body?, assignee? })
+    Then the specified fields are updated
+    When resolved I call use("!issue.close", { number })
+    And if it needs more work I call use("!issue.reopen", { number })
+
+  Scenario: Assign and discuss
+    Given I need to delegate or discuss
+    When I call use("!issue.assign", { number, assignee })
+    Then the issue is assigned to another individual
+    When I call use("!issue.comment", { number, body, author })
+    Then a comment is added to the threaded discussion
+    And I can view all comments with use("!issue.comments", { number })
+
+  Scenario: Label for categorization
+    Given I want to categorize issues
+    When I call use("!issue.label", { number, label })
+    Then the label is attached \u2014 auto-created if new
+    And I can remove it with use("!issue.unlabel", { number, label })
+
+  Scenario: Command reference
+    Given the following commands are available:
+      | command          | required args          | optional args                   |
+      | !issue.publish   | title, body, author    | assignee                        |
+      | !issue.get       | number                 |                                 |
+      | !issue.list      |                        | status, author, assignee, label |
+      | !issue.update    | number                 | title, body, assignee           |
+      | !issue.close     | number                 |                                 |
+      | !issue.reopen    | number                 |                                 |
+      | !issue.assign    | number, assignee       |                                 |
+      | !issue.comment   | number, body, author   |                                 |
+      | !issue.comments  | number                 |                                 |
+      | !issue.label     | number, label          |                                 |
+      | !issue.unlabel   | number, label          |                                 |`,
   gherkin: 'Feature: Gherkin \u2014 the universal language\n  Everything in RoleX is expressed as Gherkin Feature files.\n  Gherkin is not just for testing \u2014 it is the language of identity, goals, and knowledge.\n\n  Scenario: Feature and Scenario convention\n    Given RoleX uses Gherkin to represent goals, plans, tasks, experience, and knowledge\n    Then a Feature represents one independent concern \u2014 one topic, explained fully\n    And Scenarios represent different situations or conditions within that concern\n    And Given/When/Then provides narrative structure within each scenario\n\n  Scenario: Writing Gherkin for RoleX\n    Given the AI creates goals, plans, tasks, and experiences as Gherkin\n    Then keep it descriptive and meaningful \u2014 living documentation, not test boilerplate\n    And use Feature as the title \u2014 what this concern is about\n    And use Scenario for specific situations within that concern\n    And each Feature focuses on one concern \u2014 separate unrelated topics into their own Features\n\n  Scenario: Valid step keywords\n    Given the only valid step keywords are Given, When, Then, And, But\n    When writing steps that express causality or explanation\n    Then use And to chain the reason as a follow-up fact\n    And example: "Then use RoleX tools" followed by "And RoleX tools feed the growth loop"\n\n  Scenario: Expressing causality\n    Given you want to write "Then X because Y"\n    Then rewrite as two steps \u2014 "Then X" followed by "And Y" stating the reason as a fact',
   memory: `Feature: Memory \u2014 when to reflect
   Reflection is how encounters become experience.
@@ -2610,18 +2911,22 @@ export {
   archive,
   background,
   born,
+  channel,
+  channelProduct,
   charge,
   charter,
   charterOrg,
   complete,
-  create5 as create,
+  create6 as create,
   createCommands,
   createRuntime,
   deliverProject,
   deliverable,
+  deprecate,
   die,
   directives,
   dismiss,
+  disownProduct,
   dissolve,
   duty,
   encounter,
@@ -2638,26 +2943,31 @@ export {
   individual,
   instructions,
   launch,
-  link3 as link,
+  link4 as link,
   master,
   milestone,
   milestoneProject,
   mindset,
   organization,
+  ownProduct,
   past,
   plan,
   planGoal,
   position,
   principle,
   procedure,
-  process6 as process,
+  process7 as process,
   processes,
+  product,
   project,
   protocol,
+  publish,
   realize,
   reflect,
   rehire,
   relation2 as relation,
+  release,
+  releaseProduct,
   remove,
   removeParticipant,
   requirement,
@@ -2665,13 +2975,17 @@ export {
   scope,
   scopeProject,
   society,
+  spec,
+  specProduct,
+  strategy,
+  strategyProduct,
   structure3 as structure,
   task,
   toArgs,
   todo,
   tone,
   transform4 as transform,
-  unlink3 as unlink,
+  unlink4 as unlink,
   want,
   wiki,
   wikiProject,