@rolexjs/core 1.5.0-dev-20260317103808 → 1.6.0

package/dist/index.d.ts

@@ -1,6 +1,8 @@
 import * as _rolexjs_system from '@rolexjs/system';
-import { Runtime, Initializer, Structure, State } from '@rolexjs/system';
+import { Runtime, Initializer } from '@rolexjs/system';
 export { Create, GraphOp, Link, Process, Relation, Remove, Runtime, State, Structure, Transform, Unlink, create, createRuntime, link, process, relation, remove, structure, transform, unlink } from '@rolexjs/system';
+import { IssueXProvider } from '@issuexjs/core';
+import { ResourceXProvider, CustomExecutor } from '@resourcexjs/core';
 
 /**
  * Platform — external integration point for RoleX.
@@ -20,41 +22,11 @@ interface ContextData {
     focusedGoalId: string | null;
     focusedPlanId: string | null;
 }
-/** A single migration within a prototype. */
-interface Migration {
-    version: number;
-    id: string;
-    checksum: string;
-    instructions: Array<{
-        op: string;
-        args: Record<string, unknown>;
-    }>;
-}
-/** The unified prototype data structure. */
-interface PrototypeData {
-    id: string;
-    source: string;
-    migrations: Migration[];
-}
-/** Migration history entry — records a single executed migration. */
-interface MigrationRecord {
-    prototypeId: string;
-    migrationId: string;
-    version: number;
-    checksum: string;
-    executedAt: string;
-}
-/** Prototype registry — tracks which prototypes are settled and their migration history. */
-interface PrototypeRepository {
-    settle(id: string, source: string): Promise<void>;
-    evict(id: string): Promise<void>;
-    list(): Promise<Record<string, string>>;
-    /** Record a migration as executed. */
-    recordMigration(prototypeId: string, migrationId: string, version: number, checksum: string): Promise<void>;
-    /** Get all executed migrations for a prototype, ordered by execution time. */
-    getMigrationHistory(prototypeId: string): Promise<MigrationRecord[]>;
-    /** Check if a specific migration has been executed. */
-    hasMigration(prototypeId: string, migrationId: string): Promise<boolean>;
+/** Prototype registry — tracks which prototypes are settled. */
+interface PrototypeRegistry {
+    settle(id: string, source: string): void;
+    evict(id: string): void;
+    list(): Record<string, string>;
 }
 /**
  * RoleXRepository — unified data access layer.
@@ -66,7 +38,7 @@ interface RoleXRepository {
     /** Graph operation engine. */
     readonly runtime: Runtime;
     /** Prototype registry — tracks which prototypes are settled. */
-    readonly prototype: PrototypeRepository;
+    readonly prototype: PrototypeRegistry;
     /** Save role context to persistent storage. */
     saveContext(roleId: string, data: ContextData): Promise<void>;
     /** Load role context from persistent storage. Returns null if none exists. */
@@ -75,8 +47,16 @@ interface RoleXRepository {
 interface Platform {
     /** Unified data access layer — graph, prototypes, contexts. */
     readonly repository: RoleXRepository;
+    /** ResourceX provider — injected storage backend for resource management. */
+    readonly resourcexProvider?: ResourceXProvider;
+    /** Custom executor for ResourceX resolver execution (e.g., QuickJS Wasm for Workers). */
+    readonly resourcexExecutor?: CustomExecutor;
+    /** IssueX provider — injected storage backend for issue tracking. */
+    readonly issuexProvider?: IssueXProvider;
     /** Initializer — bootstrap the world on first run. */
     readonly initializer?: Initializer;
+    /** Prototype sources to settle on genesis (local paths or ResourceX locators). */
+    readonly bootstrap?: readonly string[];
 }
 
 declare const society: _rolexjs_system.Structure;
@@ -103,15 +83,7 @@ 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 issue: _rolexjs_system.Structure;
-declare const comment: _rolexjs_system.Structure;
 
-declare const activate: _rolexjs_system.Process;
 declare const want: _rolexjs_system.Process;
 declare const planGoal: _rolexjs_system.Process;
 declare const todo: _rolexjs_system.Process;
@@ -136,14 +108,6 @@ declare const scopeProject: _rolexjs_system.Process;
 declare const milestoneProject: _rolexjs_system.Process;
 declare const deliverProject: _rolexjs_system.Process;
 declare const wikiProject: _rolexjs_system.Process;
-declare const produceProject: _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;
@@ -152,788 +116,10 @@ declare const launch: _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;
 
-/**
- * Projection — the single projection pipeline for RoleX.
- *
- * Pipeline: raw project → compact(depth) → enrich permissions.
- *
- * All projections go through this pipeline. No special cases.
- * Control behavior via ProjectionContext.
- *
- * Rules:
- *   - Root (depth 0): full
- *   - Level 1 children: full (with content)
- *   - Level 2+ grandchildren: compact (name/id/tag only, no subtree)
- *   - All link targets: compact (name/id/tag only, no subtree)
- */
-
-interface ProjectionContext {
-    /** Children expansion depth. Default 1: one level fully expanded, then compact. */
-    depth?: number;
-}
-interface Projection {
-    /** Project a node through the full pipeline: raw → compact → enrich. */
-    (node: Structure, ctx?: ProjectionContext): Promise<State>;
-}
-
-/**
- * Commands — shared type definitions.
- */
-
-interface CommandResult {
-    state: State;
-    process: string;
-}
-interface CommandContext {
-    rt: Runtime;
-    society: Structure;
-    past: Structure;
-    resolve(id: string): Structure | Promise<Structure>;
-    find(id: string): (Structure | null) | Promise<Structure | null>;
-    project: Projection;
-    prototype?: PrototypeRepository;
-}
-/**
- * CommandResultMap — typed return type for every command.
- *
- * This is the source of truth for what each command returns.
- * Renderer and consumers use this to know the shape of each result.
- */
-interface CommandResultMap {
-    "society.born": CommandResult;
-    "society.retire": CommandResult;
-    "society.die": CommandResult;
-    "society.rehire": CommandResult;
-    "society.teach": CommandResult;
-    "society.train": CommandResult;
-    "role.focus": CommandResult;
-    "role.want": CommandResult;
-    "role.plan": CommandResult;
-    "role.todo": CommandResult;
-    "role.finish": CommandResult;
-    "role.complete": CommandResult;
-    "role.abandon": CommandResult;
-    "role.reflect": CommandResult;
-    "role.realize": CommandResult;
-    "role.master": CommandResult;
-    "role.forget": CommandResult;
-    "project.scope": CommandResult;
-    "project.milestone": CommandResult;
-    "project.achieve": CommandResult;
-    "project.enroll": CommandResult;
-    "project.remove": CommandResult;
-    "project.deliver": CommandResult;
-    "project.wiki": CommandResult;
-    "project.produce": CommandResult;
-    "project.maintain": CommandResult;
-    "project.unmaintain": CommandResult;
-    "product.strategy": CommandResult;
-    "product.spec": CommandResult;
-    "product.release": CommandResult;
-    "product.channel": CommandResult;
-    "product.own": CommandResult;
-    "product.disown": CommandResult;
-    "product.deprecate": CommandResult;
-    "society.found": CommandResult;
-    "org.charter": CommandResult;
-    "society.dissolve": CommandResult;
-    "org.hire": CommandResult;
-    "org.fire": CommandResult;
-    "org.admin": CommandResult;
-    "org.unadmin": CommandResult;
-    "org.launch": CommandResult;
-    "org.archive": CommandResult;
-    "org.establish": CommandResult;
-    "org.abolish": CommandResult;
-    "position.charge": CommandResult;
-    "position.require": CommandResult;
-    "position.appoint": CommandResult;
-    "position.dismiss": CommandResult;
-    "society.crown": CommandResult;
-    "society.uncrown": CommandResult;
-    "survey.list": CommandResult;
-    "issue.publish": CommandResult;
-    "issue.get": CommandResult;
-    "issue.list": CommandResult;
-    "issue.update": CommandResult;
-    "issue.close": CommandResult;
-    "issue.reopen": CommandResult;
-    "issue.assign": CommandResult;
-    "issue.comment": CommandResult;
-    "issue.comments": CommandResult;
-    "issue.label": CommandResult;
-    "issue.unlabel": CommandResult;
-}
-type Commands = Record<string, (...args: any[]) => any>;
-
-/**
- * Commands — platform-agnostic command implementations.
- *
- * Every RoleX command is a pure function of (Runtime, args) -> CommandResult.
- * No platform-specific code — all I/O goes through injected interfaces.
- *
- * Usage:
- *   const commands = createCommands({ rt, society, past, resolve, find, resourcex });
- *   const result = commands["society.born"]("Feature: Sean", "sean");
- */
-
-declare function createCommands(ctx: CommandContext): Commands;
-
-/**
- * Renderer — framework for rendering command results.
- *
- * Renderer interface and RendererRouter live here in prototype
- * because this layer owns all command types and structures.
- * Concrete renderers are registered by the upper layer (rolexjs).
- */
-
-/** Renders a command result into a string (typically Markdown). */
-interface Renderer {
-    render(command: string, result: CommandResult): string;
-}
-/**
- * RendererRouter — routes commands to namespace-specific renderers.
- *
- * Registered renderers handle their namespace (e.g. "role" handles "role.want").
- * Unregistered commands fall through to the default renderer (JSON serialization).
- */
-declare class RendererRouter implements Renderer {
-    private readonly renderers;
-    /** Register a renderer for a command namespace. */
-    register(namespace: string, renderer: Renderer): this;
-    /** Route a command to the appropriate renderer. */
-    render(command: string, result: CommandResult): string;
-}
-
-/**
- * Role — rich domain model (充血模型) for an individual.
- *
- * Role is a self-contained operation domain that holds:
- *   - State projection (read cache from graph)
- *   - Cursors (focusedGoalId, focusedPlanId)
- *   - Cognitive registries (encounters, experiences)
- *   - Domain behaviors (focus, want, plan, todo, finish, etc.)
- *
- * Design:
- *   - Role = Actor State, RoleX = ActorSystem
- *   - Ownership validation: hasNode() ensures isolation
- *   - KV-serializable: snapshot() / restore()
- *   - Single instance per individual
- */
-
-/** Serializable role state for KV persistence. */
-interface RoleSnapshot {
-    id: string;
-    focusedGoalId: string | null;
-    focusedPlanId: string | null;
-    encounterIds: string[];
-    experienceIds: string[];
-}
-/** Internal dependencies injected by RoleX at activate time. */
-interface RoleDeps {
-    commands: Commands;
-    renderer: Renderer;
-    onSave(snapshot: RoleSnapshot): void | Promise<void>;
-}
-declare class Role {
-    readonly id: string;
-    private focusedGoalId;
-    private focusedPlanId;
-    private readonly encounterIds;
-    private readonly experienceIds;
-    /** Set of all node ids under this individual — for ownership validation. */
-    private readonly nodeIds;
-    private deps;
-    constructor(id: string, deps: RoleDeps);
-    /** Populate from state projection. Builds nodeIds set + cognitive registries. */
-    hydrate(state: State): void;
-    private walkState;
-    private hasNode;
-    private requireOwnership;
-    private requireGoalId;
-    private requirePlanId;
-    private fmt;
-    private save;
-    /** Serialize to KV-compatible snapshot. */
-    snapshot(): RoleSnapshot;
-    /** Restore cursors and cognitive state from a snapshot. */
-    restore(snap: RoleSnapshot): void;
-    /** Project the individual's state tree (used after activate). */
-    project(): Promise<string>;
-    /** Focus: view or switch focused goal. Validates ownership. */
-    focus(goal?: string): Promise<string>;
-    /** Want: declare a goal under this individual. */
-    want(goal?: string, id?: string, alias?: readonly string[]): Promise<string>;
-    /** Plan: create a plan for the focused goal. */
-    plan(plan?: string, id?: string, after?: string, fallback?: string): Promise<string>;
-    /** Todo: add a task to the focused plan. */
-    todo(task?: string, id?: string, alias?: readonly string[]): Promise<string>;
-    /** Finish: complete a task, optionally record an encounter. */
-    finish(task: string, encounter?: string): Promise<string>;
-    /** Complete: close a plan as done, record encounter. */
-    complete(plan?: string, encounter?: string): Promise<string>;
-    /** Abandon: drop a plan, record encounter. */
-    abandon(plan?: string, encounter?: string): Promise<string>;
-    /** Reflect: consume encounters → experience. */
-    reflect(encounters: string[], experience?: string, id?: string): Promise<string>;
-    /** Realize: consume experiences → principle. */
-    realize(experiences: string[], principle?: string, id?: string): Promise<string>;
-    /** Master: create procedure, optionally consuming experiences. */
-    master(procedure: string, id?: string, experiences?: string[]): Promise<string>;
-    /** Forget: remove any node under this individual by id. */
-    forget(nodeId: string): Promise<string>;
-    private cognitiveHint;
-}
-
-/**
- * RoleXService — runtime orchestrator (internal).
- *
- * Wires Platform → Commands, manages Role lifecycle, handles ResourceX/IssueX.
- * Not exposed publicly — consumed by the RoleX entry point.
- *
- * Key responsibilities:
- *   - Initialize world roots (society, past)
- *   - Create and cache Role instances (one per individual)
- *   - Apply prototypes on first run
- *   - Dispatch direct commands
- */
-
-interface RoleX {
-    activate(individual: string): Promise<Role>;
-    inspect(id: string, options?: {
-        raw?: boolean;
-    }): Promise<string | State>;
-    survey(type?: string, options?: {
-        raw?: boolean;
-    }): Promise<string | readonly State[]>;
-    direct<T = unknown>(locator: string, args?: Record<string, unknown>, options?: {
-        raw?: boolean;
-    }): Promise<T>;
-}
-declare class RoleXService implements RoleX {
-    private rt;
-    private commands;
-    private project;
-    private repo;
-    private readonly initializer?;
-    private readonly renderer;
-    private readonly prototypes;
-    private society;
-    private past;
-    /** Cached Role instances — one per individual. */
-    private readonly roles;
-    /** Expose commands for the RPC handler. */
-    get commandMap(): Commands;
-    /** Permission registry — maps relation names to permissions. */
-    private readonly permissions;
-    private constructor();
-    static create(platform: Platform, renderer: Renderer, prototypes?: readonly PrototypeData[]): Promise<RoleXService>;
-    private init;
-    activate(individual: string): Promise<Role>;
-    private findOrAutoBorn;
-    private saveSnapshot;
-    private restoreSnapshot;
-    inspect(id: string, options?: {
-        raw?: boolean;
-    }): Promise<string | State>;
-    survey(type?: string, options?: {
-        raw?: boolean;
-    }): Promise<string | readonly State[]>;
-    direct<T = unknown>(locator: string, args?: Record<string, unknown>, options?: {
-        raw?: boolean;
-    }): Promise<T>;
-    /** Find a node by id across the entire society tree (raw, no pipeline). */
-    private find;
-}
-
-/**
- * JSON-RPC 2.0 types and handler for RoleX.
- *
- * The RpcHandler is the single dispatch point for all RoleX operations.
- * It accepts JSON-RPC 2.0 requests and delegates to the command layer
- * via toArgs() for named-to-positional argument conversion.
- */
-
-interface JsonRpcRequest {
-    jsonrpc: "2.0";
-    method: string;
-    params?: Record<string, unknown>;
-    id?: string | number | null;
-}
-interface JsonRpcResponse<T = unknown> {
-    jsonrpc: "2.0";
-    id: string | number | null;
-    result?: T;
-    error?: JsonRpcError;
-}
-interface JsonRpcError {
-    code: number;
-    message: string;
-    data?: unknown;
-}
-interface RpcHandlerDeps {
-    commands: Commands;
-    /** Custom method handlers for methods not in the commands map (e.g. activate, inspect, survey). */
-    methods?: Record<string, (params: Record<string, unknown>) => Promise<unknown>>;
-}
-declare class RpcHandler {
-    private commands;
-    private methods;
-    constructor(deps: RpcHandlerDeps);
-    handle<T = unknown>(request: JsonRpcRequest): Promise<JsonRpcResponse<T>>;
-}
-
-/**
- * Namespace interfaces and factories for RoleX builder API.
- *
- * Each namespace is a typed wrapper over the JSON-RPC caller function.
- * Methods accept named parameter objects (matching JSON-RPC params)
- * and return typed results.
- */
-
-type Caller = (method: string, params?: Record<string, unknown>) => Promise<any>;
-interface SocietyNamespace {
-    born(params: {
-        content?: string;
-        id: string;
-        alias?: string[];
-    }): Promise<CommandResult>;
-    retire(params: {
-        individual: string;
-    }): Promise<CommandResult>;
-    die(params: {
-        individual: string;
-    }): Promise<CommandResult>;
-    rehire(params: {
-        individual: string;
-    }): Promise<CommandResult>;
-    teach(params: {
-        individual: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    train(params: {
-        individual: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    found(params: {
-        content?: string;
-        id: string;
-        alias?: string[];
-        admin?: string;
-    }): Promise<CommandResult>;
-    dissolve(params: {
-        org: string;
-    }): Promise<CommandResult>;
-    crown(params: {
-        individual: string;
-    }): Promise<CommandResult>;
-    uncrown(params: {
-        individual: string;
-    }): Promise<CommandResult>;
-}
-interface IndividualNamespace {
-    activate(params: {
-        individual: string;
-    }): Promise<Role>;
-}
-interface OrgNamespace {
-    charter(params: {
-        org: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    hire(params: {
-        org: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    fire(params: {
-        org: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    admin(params: {
-        org: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    unadmin(params: {
-        org: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    launch(params: {
-        content?: string;
-        id: string;
-        alias?: string[];
-        org?: string;
-        maintainer?: string;
-    }): Promise<CommandResult>;
-    archive(params: {
-        project: string;
-    }): Promise<CommandResult>;
-    establish(params: {
-        content?: string;
-        id: string;
-        alias?: string[];
-    }): Promise<CommandResult>;
-    abolish(params: {
-        position: string;
-    }): Promise<CommandResult>;
-}
-interface PositionNamespace {
-    charge(params: {
-        position: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    require(params: {
-        position: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    appoint(params: {
-        position: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    dismiss(params: {
-        position: string;
-        individual: string;
-    }): Promise<CommandResult>;
-}
-interface ProjectNamespace {
-    scope(params: {
-        project: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    milestone(params: {
-        project: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    achieve(params: {
-        milestone: string;
-    }): Promise<CommandResult>;
-    enroll(params: {
-        project: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    remove(params: {
-        project: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    deliver(params: {
-        project: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    wiki(params: {
-        project: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    produce(params: {
-        project: string;
-        content?: string;
-        id: string;
-        alias?: string[];
-        owner?: string;
-    }): Promise<CommandResult>;
-    maintain(params: {
-        project: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    unmaintain(params: {
-        project: string;
-        individual: string;
-    }): Promise<CommandResult>;
-}
-interface ProductNamespace {
-    strategy(params: {
-        product: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    spec(params: {
-        product: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    release(params: {
-        product: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    channel(params: {
-        product: string;
-        content: string;
-        id: string;
-    }): Promise<CommandResult>;
-    own(params: {
-        product: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    disown(params: {
-        product: string;
-        individual: string;
-    }): Promise<CommandResult>;
-    deprecate(params: {
-        product: string;
-    }): Promise<CommandResult>;
-}
-interface IssueNamespace {
-    publish(params: {
-        title: string;
-        body: string;
-        author: string;
-        assignee?: string;
-    }): Promise<CommandResult>;
-    get(params: {
-        number: number;
-    }): Promise<CommandResult>;
-    list(params?: {
-        status?: string;
-        author?: string;
-        assignee?: string;
-        label?: string;
-    }): Promise<CommandResult>;
-    update(params: {
-        number: number;
-        title?: string;
-        body?: string;
-        assignee?: string;
-    }): Promise<CommandResult>;
-    close(params: {
-        number: number;
-    }): Promise<CommandResult>;
-    reopen(params: {
-        number: number;
-    }): Promise<CommandResult>;
-    assign(params: {
-        number: number;
-        assignee: string;
-    }): Promise<CommandResult>;
-    comment(params: {
-        number: number;
-        body: string;
-        author: string;
-    }): Promise<CommandResult>;
-    comments(params: {
-        number: number;
-    }): Promise<CommandResult>;
-    label(params: {
-        number: number;
-        label: string;
-    }): Promise<CommandResult>;
-    unlabel(params: {
-        number: number;
-        label: string;
-    }): Promise<CommandResult>;
-}
-
-/**
- * Schema types for RoleX instruction definitions.
- *
- * These types define the structure of every RoleX operation:
- * parameter types, descriptions, and positional arg ordering.
- */
-/** Supported parameter types for instruction definitions. */
-type ParamType = "string" | "number" | "gherkin" | "string[]" | "record";
-/** Definition of a single parameter in an instruction. */
-interface ParamDef {
-    type: ParamType;
-    required: boolean;
-    description: string;
-}
-/**
- * A single positional argument entry.
- *
- * - `string` — simple lookup: `args[name]`
- * - `{ pack: [...] }` — collect named args into an options object;
- *   returns `undefined` if all values are absent.
- */
-type ArgEntry = string | {
-    pack: readonly string[];
-};
-/** Full definition of a RoleX instruction (one namespace.method). */
-interface InstructionDef {
-    namespace: string;
-    method: string;
-    /** Parameter definitions — keyed by param name, used for MCP/CLI schema generation. */
-    params: Record<string, ParamDef>;
-    /** Positional argument order — maps named args to method call positions. */
-    args: readonly ArgEntry[];
-}
-/** RoleX tool definition — schema for a top-level tool (activate, want, use, etc.). */
-interface ToolDef {
-    /** Tool name (e.g. "activate", "use"). */
-    name: string;
-    /** Full Gherkin description of the tool's behavior. */
-    description: string;
-    /** Parameter definitions — keyed by param name. */
-    params: Record<string, ParamDef>;
-}
-
-/**
- * RoleX tool definitions — the single source of truth for all tool schemas.
- *
- * Channel-agnostic: MCP, CLI, REST, A2A each convert to their own format.
- * Each ToolDef is self-contained: name + description + params.
- */
-
-/**
- * Protocol — the complete interface contract for channel adapters.
- *
- * Any adapter (MCP, CLI, REST, A2A) only needs this object
- * to know what tools exist and what instructions to present.
- */
-interface Protocol {
-    /** All tool definitions — self-contained with description + parameter schemas. */
-    tools: ToolDef[];
-    /** World-level instructions — the cognitive framework for AI roles. */
-    instructions: string;
-}
-/** The protocol instance — single source of truth for all channel adapters. */
-declare const protocol: Protocol;
-
-/**
- * RoleX Builder — synchronous factory with lazy initialization.
- *
- * Usage:
- *   const rx = createBuilder({ platform, renderer });
- *   const role = await rx.individual.activate({ individual: "sean" });
- *   await rx.society.born({ id: "alice", content: "Feature: Alice" });
- */
-
-interface RoleXInternal {
-    service: RoleXService;
-}
-interface RoleXBuilder {
-    /** Society-level operations — born, retire, crown, teach, train, found, dissolve. */
-    readonly society: SocietyNamespace;
-    /** Individual operations — activate. */
-    readonly individual: IndividualNamespace;
-    /** Organization operations — charter, hire, fire, admin, launch, establish. */
-    readonly org: OrgNamespace;
-    /** Position operations — charge, require, appoint, dismiss. */
-    readonly position: PositionNamespace;
-    /** Project operations — scope, milestone, enroll, deliver, produce. */
-    readonly project: ProjectNamespace;
-    /** Product operations — strategy, spec, release, channel, own. */
-    readonly product: ProductNamespace;
-    /** Issue tracking integration. */
-    readonly issue: IssueNamespace;
-    /** Inspect any node's full state — world-level observation. */
-    inspect(params: {
-        id: string;
-        raw?: boolean;
-    }): Promise<string | State>;
-    /** Survey the world — list individuals, organizations, positions. */
-    survey(params?: {
-        type?: string;
-        raw?: boolean;
-    }): Promise<string | readonly State[]>;
-    /** Tool schemas + world instructions — the unified contract for any channel adapter. */
-    readonly protocol: Protocol;
-    /** Universal JSON-RPC 2.0 dispatch. */
-    rpc<T = unknown>(request: JsonRpcRequest): Promise<JsonRpcResponse<T>>;
-    /** Internal access for testing — not part of the public contract. */
-    _internal(): Promise<RoleXInternal>;
-}
-interface BuilderConfig {
-    platform: Platform;
-    renderer: Renderer;
-    /** Built-in prototypes to apply on initialization (e.g. genesis). */
-    prototypes?: readonly PrototypeData[];
-}
-declare function createBuilder(config: BuilderConfig): RoleXBuilder;
-
-/**
- * Find — unified node lookup with priority-based disambiguation.
- *
- * When multiple nodes share the same id (allowed after relaxing
- * global uniqueness), prefer "addressable" nodes over internal metadata.
- *
- * Priority (lower = preferred):
- *   0: individual, organization, position   — top-level entities
- *   1: goal                                  — execution roots
- *   2: plan, task                            — execution nodes
- *   3: procedure, principle                  — individual knowledge
- *   4: encounter, experience                 — cognition artifacts
- *   5: identity, charter                     — structural definitions
- *   6: duty, requirement, background, etc.   — internal metadata
- */
-
-/**
- * Find a node by id or alias in a state tree.
- *
- * When multiple nodes match, returns the one with the highest priority
- * (top-level entities > execution nodes > knowledge > metadata).
- */
-declare function findInState(state: State, target: string): Structure | null;
-
-/**
- * applyPrototype — apply a prototype's migrations incrementally.
- *
- * Pure function: receives data + storage + executor, no framework coupling.
- * Checks migration history, executes only unapplied migrations, records each.
- */
-
-/** Result of applying a prototype. */
-interface ApplyResult {
-    prototypeId: string;
-    applied: number;
-    skipped: number;
-    upToDate: boolean;
-}
-/**
- * Apply a prototype — execute unapplied migrations in version order.
- *
- * @param data - The prototype data structure with migrations
- * @param repo - Storage layer for migration history
- * @param direct - Executor for prototype instructions
- */
-declare function applyPrototype(data: PrototypeData, repo: PrototypeRepository, direct: (op: string, args: Record<string, unknown>) => Promise<unknown>): Promise<ApplyResult>;
-
-/**
- * descriptions — AUTO-GENERATED by scripts/gen-descriptions.ts
- *
- * DO NOT EDIT MANUALLY. Run `bun run gen:desc` to regenerate.
- *
- * Source: descriptions/{system}/{process}.feature (69 files)
- */
-declare const WORLD_TOPICS: readonly ["cognition", "cognitive-priority", "command-system", "communication", "execution", "gherkin", "identity-ethics", "inspect", "issue", "memory", "role-identity", "skill-system", "state-origin", "survey", "use-protocol"];
-type WorldTopic = (typeof WORLD_TOPICS)[number];
-declare const world: Record<WorldTopic, string>;
-declare const processes: Record<string, string>;
-
-declare const directives: Record<string, Record<string, string>>;
-
-/**
- * Dispatch — schema-driven argument mapping.
- *
- * Replaces the hand-written toArgs switch in rolex.ts with a single
- * lookup against the instruction registry.
- */
-/**
- * Map named arguments to positional arguments for a given operation.
- *
- * @param op - Operation key in "namespace.method" format (e.g. "society.born")
- * @param args - Named arguments from the caller
- * @returns Positional argument array matching the method signature
- */
-declare function toArgs(op: string, args: Record<string, unknown>): unknown[];
-
-/**
- * Instruction set — schema definitions for all RoleX operations.
- *
- * Covers every namespace.method that can be dispatched through `use()`.
- */
-
-declare const instructions: Record<string, InstructionDef>;
+declare const activate: _rolexjs_system.Process;
 
-export { type ApplyResult, type ArgEntry, type BuilderConfig, type Caller, type CommandContext, type CommandResult, type CommandResultMap, type Commands, type ContextData, type IndividualNamespace, type InstructionDef, type IssueNamespace, type JsonRpcError, type JsonRpcRequest, type JsonRpcResponse, type Migration, type MigrationRecord, type OrgNamespace, type ParamDef, type ParamType, type Platform, type PositionNamespace, type ProductNamespace, type ProjectNamespace, type Protocol, type PrototypeData, type PrototypeRepository, type Renderer, RendererRouter, Role, type RoleDeps, type RoleSnapshot, type RoleX, type RoleXBuilder, type RoleXInternal, type RoleXRepository, RoleXService, RpcHandler, type SocietyNamespace, type ToolDef, abandon, abolish, activate, applyPrototype, appoint, archive, background, born, channel, channelProduct, charge, charter, charterOrg, comment, complete, createBuilder, createCommands, deliverProject, deliverable, deprecate, die, directives, dismiss, disownProduct, dissolve, duty, encounter, enroll, establish, experience, findInState, finish, fire, found, goal, hire, identity, individual, instructions, issue, launch, master, milestone, milestoneProject, mindset, organization, ownProduct, past, plan, planGoal, position, principle, procedure, processes, produceProject, product, project, protocol, realize, reflect, rehire, release, releaseProduct, removeParticipant, requirement, retire, scope, scopeProject, society, spec, specProduct, strategy, strategyProduct, task, toArgs, todo, tone, want, wiki, wikiProject, world };
+export { type ContextData, type Platform, type PrototypeRegistry, type RoleXRepository, abandon, abolish, activate, appoint, archive, background, born, charge, charter, charterOrg, complete, deliverProject, deliverable, die, dismiss, dissolve, duty, encounter, enroll, establish, experience, finish, fire, found, goal, hire, identity, individual, launch, master, milestone, milestoneProject, mindset, organization, past, plan, planGoal, position, principle, procedure, project, realize, reflect, rehire, removeParticipant, requirement, retire, scope, scopeProject, society, task, todo, tone, want, wiki, wikiProject };