Core domain terms used across Nexus OSS documentation, plans, and code. Each entry is a concise definition of what the term means in this project.
The product thesis: Nexus is the local-first creative-writing tool where a World's Timeline is the central instrument, AI agents are harnessed through Canvas, and Computable modules make worlds react. Each pillar below names a product thesis, not a single crate. See STRATEGY.md § Vision → Three pillars for the crate/spec mapping.
The control-strategy pillar: how an author harnesses AI agents to execute creative work — orchestration, capability routing, agent hosting, and presets. Maps to the orchestration engine + agent host + capability registry + presets. The user-visible pillar entry labels Harness; Preset stays as the mechanism name under Harness. Specs: orchestration-engine.md, agent-host.md, capability-registry.md.
The product-thesis pillar that worlds react via WASM compute — combat resolution, dice, relationship-graph computation, user-authored modules. Distinct from Compute (Capability) below: Computable is the pillar (the product claim that worlds react); Compute (Capability) is the mechanism (the WASM execution unit an author/agent invokes). The pillar names the thesis; the capability names the implementation unit. Specs: compute-module-abi.md, wasm-host.md.
The Canvas hero pattern: a World's Timeline is the primary Canvas surface for World entry — authors open a World and meet its when axis before its entity graph or chapter structure. CanvasSurfaceKind = "timeline" is a peer surface alongside Strategy / Outline (Timeline-companion) / World KB, and is the default World-entry surface. Outline remains the default for Work entry. Timeline is not a single flat event list: it is three zoom layers — Brief, Narrative, and Moment — with domain-differentiated use (World: Brief+Narrative; Work: Narrative+Moment via peer work-timeline).
Spine vs projection (locked product model):
- Spine: World + Timeline + KnowledgeEntry + Fork — the truth of the narrative universe. Timeline is the World's when axis (three layers). KnowledgeEntry is one primitive with exactly one canonical owner scope (World / Character / ActorWorldBinding — see KnowledgeEntry); Character and binding owner scopes ship; World remains the pre-Actor default.
- Projection: Work + Outline + Manuscript — the authoring plan and prose bound to a World. Outline is the Work's structural projection (chapters / scenes); Work Timeline is a peer projection for Narrative+Moment.
Authors should feel: World first for World building (Timeline, Brief-led); Work first for chapter writing (Outline), with Work Timeline reachable for scene precision. Dual entry defaults encode that. Spec: canvas-strategy-surface.md.
The Actor model is accepted product direction. The Character bearer, ActorWorldBinding, three KE owner scopes, Character KnowledgeView, one-host execution, Character SOUL/Memory, and ToM L1/L2 all ship, together with the developer maintenance loop (identity edit, reversible archive/restore, post-create WorldSheet maintenance, KE content/detail/edit/delete, run-connected --remember; PR #241). The creator character run entrance that carried --remember is retired (actor-product-model §11.6); the retained prompt wire still carries the remember member. Durable authority: actor-product-model.md.
The cross-cutting narrative identity primitive — who can think and act in a story. Outward line: Nexus Actors are who can think and act — Creators conduct the story; Characters live it. ActorRef is a closed v1 sum: Creator | Character — a product-identity model, not a unified actors-table storage commitment (existing Creator storage remains). Actor is not a fourth pillar: it cuts across Harness (executes an Actor), Canvas (surfaces one), and Computable (worlds react to one). One Agent Host / runtime / provider plane serves both kinds; a Character session executes under the owning Creator's admission boundary with an isolated ACP conversation history.
Identity axes — keep these separate:
| Axis | What it is | Why it is not (or is) Actor identity |
|---|---|---|
| User Entrance | User-layer usage identity (developer | content-creator) selecting SPA layout trees — see Entrance |
UI routing state; creates, swaps, or hides no agent or narrative identity |
| Creator profile | Shipped operational identity aggregate (creator_id): admission boundary, ownership, SOUL/Memory bearer |
The Creator Actor kind's operational record — the profile is storage; Actor is the narrative-identity reading of it |
| Orchestration role | Workflow-function routing inside presets (GraphNode.agent / WorkerAgentConfig.role) |
Names which worker executes a step; never names who in the story |
ACP session (HostSessionId) |
Transport conversation identity between Nexus and an agent | A session is a pipe: isolated per Actor/World view, but carries no identity semantics |
| Holder | The l5 MindState/belief/observation holder field — an in-world epistemic subject reference |
A ToM data pointer, not identity. Character mapping is additive on belief holder; the carrier KE and observation placement remain unchanged |
actor_kind=character |
ActorRef discriminant value marking a first-class Character identity row |
This one is Actor vocabulary — the identity axis; it does not denote a KB lore row |
block_type=character |
Shipped World KB lore taxonomy value on KnowledgeEntry | Lore about a person inside a World (a WorldSheet) — a separate axis from actor_kind=character: taxonomy vs identity |
The local user's shipped identity aggregate — author profile, preferences, memories — and the operational owner / admission identity for everything Nexus executes. Under the Actor model the Creator is the first Actor kind: the god/orchestrator/narrative driver who conducts the story — owns Worlds (via the shipped WorldMembership aggregate — Creator↔World only, world-membership.schema.json), carries SOUL + Memory (Creator Memory), and holds omniscient read over all KnowledgeEntries in owned Worlds, including creator-only facts. Existing creator_id storage and FKs are not re-keyed, and Creator execution stays byte-stable when no Character is bound. Distinct from Entrance (User-layer layout identity), orchestration roles, and ACP sessions — see the axis table under Actor.
The second Actor kind: a durable, Creator-owned narrative identity that lives inside the story. A Character carries its own SOUL, Memory, ToM (built additively on the l5 MindState/belief/observation foundation), and image/persona assets. A Character is not a World-scoped KnowledgeEntry(block_type=character) — those remain WorldSheets (lore). A Character associates with one or more Worlds only through explicit ActorWorldBindings — creation atomically establishes an initial binding, and an active Character never has zero active bindings. Character SOUL/Memory uses a distinct bearer from Creator Memory — Character writes never enter Creator memory rows. Character execution requires the requesting Creator to own both the Character and the World plus an active binding; a missing/invalid binding or incomplete view fails closed — never falls back to the Creator/god context or a default ACP session.
The association record linking a Character to one World — Character↔World cardinality is exactly one-or-more (one or more bindings per active Character, each to exactly one World). Bindings support add/list/remove, an optional WorldSheet at create/add, and last-active-binding refusal. Character creation establishes an initial ActorWorldBinding atomically; no active Character may have zero active bindings, so removing the last binding fails (reject; zero mutation), and transitioning the Character out of active state is a separate later lifecycle contract (explicit archive) — never an implicit effect of binding removal and never an active orphan. A binding carries the binding-local isolated Character KE scope and may link optional WorldSheets. Naming: WorldMembership is reserved for the shipped Creator↔World aggregate and MUST NOT name Character↔World — ActorWorldBinding is the only Character↔World term. Execution gate: a Character session requires an active binding plus Creator ownership of both ends.
A World-scoped KnowledgeEntry(block_type=character) read under the Actor model: character lore owned by a World — World-local truth, optionally linked from an ActorWorldBinding as that World's sheet about a Character; unbound sheets remain pure lore. Existing character KEs stay WorldSheets; no silent migration. A WorldSheet is data about a person in a World; a Character (actor_kind=character) is who can think and act — separate axes.
The composed, authorized knowledge scope a Character perceives inside one active ActorWorldBinding: authorized World KE + Character-owned KE + binding-local KE. One KnowledgeEntry primitive with exactly one canonical owner scope per entry:
- World-owned KE remains World-local truth.
- Character-owned KE lives in the Character knowledge space and is visible in every active binding of that Character without copying (no mount join).
- ActorWorldBinding-owned KE (binding-local) belongs to one binding and is isolated from the Character's other Worlds — private to that World life.
Cross-World sharing is explicit — it never implicitly copies all World facts or memories. Contrast the Creator view over an owned World: omniscient, including creator-only facts.
Subordinate execution context paired with an ActorRef — logically {world_id, optional binding_id/branch_id/event_id} (it does not repeat an actor id; Character execution requires the binding id, Creator omits it) — describing from where an Actor acts or reads within a session. Viewpoint is not an identity, not an Actor kind, and not the name of any Character↔World association.
The core creative container — a narrative universe with its own knowledge base, timeline, and structured state. Worlds are the top-level organizational unit in Nexus. World history is immutable: changes go through Fork, never in-place mutation.
The fundamental unit of structured knowledge in a world. KnowledgeEntries have typed attributes (character, location, event, concept, etc.), taxonomy labels, and an immutable identity. Computable KnowledgeEntries accumulate mutable state over WASM compute invocations.
Canonical owner scope (Actor-model alignment): KnowledgeEntry stays one primitive, and each entry has exactly one canonical owner scope — World, Character, or ActorWorldBinding. Character and binding owners ship alongside World. World-owned KE remains World-local; Character-owned KE is visible across that Character's bindings without copying; ActorWorldBinding-owned KE is isolated to that World life. Current block_type=character rows are WorldSheets. KE content maintenance is available. The per-scope composition a Character perceives is the Character KnowledgeView.
The default-on mechanism (DF-74) that selects and orders World KB entries for a moment by their modules.activation fire-conditions (keys / secondary_keys / logic / constant / priority / order / match), with optional relation-hop expansion (≤2 hops) from firing entries. Worlds whose entries carry no activation module are assembled byte-identically to the pre-activation path. Applied during Moment Context Assembly; dialect and contract: spoke-adapter-architecture.md §7.4.
A short-horizon, author-written instruction (DF-75) that injects into the assembled prompt as a distinct section above lore, below system/personality — the clean-room Author's-Note analogue. One paragraph, not a second system prompt; never silently generated. Scoped per-Work with an optional World override (closest scope wins; not creator-global). Lifetime is governed by TTL (generations — one injecting assemble = one count; chapters — one per chapter advance for novel Works) and optionally clear-on-scene-change (focused event_id change proxy). Product-local only — never a SPOKE object: not a modules.* entry, not a KnowledgeEntry, never on the spoke wire or in AssemblePacket traces (AC-I3). Author surface: CLI (nexus42 creator moment-directive set|show|clear); observation via platform context assemble-moment output. Not stage-gated — its TTL governs lifetime, not generation stage. Spec: spoke-adapter-architecture.md §7.4. Cross-ref: Lore Activation, Preset (Injection) Slot, Moment Context Assembly.
A named, ordered region of the assembled prompt (DF-75) filled by activated lore — the slot layer that shapes the ## World Knowledge Base block after Lore Activation decides what fires. Shipped slots: world.before (before-defs anchors), the default fallback (the flat block — the byte-equivalence anchor), world.after (post-defs reminders), open kb.outlet.<name> (author-named outlets, sorted; unknown names are not errors), and style.post_history (the one reserved well-known outlet, tail of the lore block) — plus the moment.directive slot (top-level section, filled by the Moment Directive). Emit order is locked (spec §2/Q5); within-slot order keeps the priority-then-order. Slot filling is generation-stage gated (spec §4): style.post_history fills only for produce/review; system_maintenance runs no lore slots; direct-CLI unspecified keeps everything on. Disambiguation: distinct from Preset under Compute & AI Domain (a pre-configured bundle of compute capabilities) — this entry is the injection slot in the assembled prompt, not a preset manifest. Spec: spoke-adapter-architecture.md §7.4.
The read-only observation surface for Moment Context Assembly (DF-76) — what the author sees when they want to know why this moment assembled the way it did. The inspector consumes the enriched inspector packet — a separate emission path from the assembled prompt (never changes assembled bytes, AC-I6) — built by build_inspector_packet (nexus-moment-context-assembly/src/inspector.rs) and presented in the Control Room panel, the daemon route POST /v1/daemon/inspector/moment, and the CLI assemble-moment --inspect / --emit-packet. It surfaces: activation trace (modules.activation_trace — full per-entry fire/miss with reasons, in the spoke assemble-module recipe vocabulary; consumer-only — nexus presents the trace, it does not clone the spoke assemble wire), placement (modules.placement — accepted entries only), slot map (slot_map — which accepted entry landed in which named slot, captured post stage-gate), token budget (budget — chars/4 primary/hop estimates + cap/remaining), and directive status (moment_directive — status/metadata only; the directive body never appears, AC-I3). Read-only: it observes assemble_moment output; it never re-runs activation, never mutates the World KB, never injects content. Spec: spoke-adapter-architecture.md §7.4 (inspector packet field surface).
A portable World-lore transport (DF-77) — a single JSON handbook envelope carrying ordered KnowledgeEntry records, their Relations, optional SourceAnchors, and modules.pack catalog metadata (title, version, creator, optional description). Pack I/O moves lore between Worlds or hosts via creator world kb pack export|import and daemon routes POST /v1/daemon/worlds/:world_id/kb/pack/export|import. Imported rows carry source_provenance_kind = pack_import (shared IMPORT_PROVENANCE constant). Consumer-only: the handbook shape is product transport, not a spoke-operations surface — nexus builds/parses via nexus_spoke_adapter::pack and orchestrates writes through the core-owned dispatch_world_pack_import (crates/nexus-core/src/world_pack.rs; import_world_pack on the nexus-core-node service facade). Conflict policies: skip (default), rename (canonical_name disambiguation with imported suffix), overwrite (CAS body replace; status preserved). modules.activation fire-conditions round-trip with lore (no force-enable on import). Cross-ref: Lore Activation, Moment Context Assembly, spoke-adapter-architecture.md §11.
A reference that ties a KnowledgeEntry to its provenance — which artifact (manuscript chapter, outline node, etc.) produced it and at what position.
A SPOKE-standard mechanism for carrying nexus-specific fields on spoke-schema objects. extensions.nexus is a typed namespace on spoke KnowledgeEntry (and other spoke types) that holds nexus-local identity, provenance, and lifecycle metadata — e.g., world_id, created_from_command_id, and provenance fields. Accessors live in nexus-spoke-adapter::extensions. This avoids requiring spoke to declare every nexus product field in its core schema. The nexus-spoke-adapter exposes a dual-surface API: Surface A (pure delegates, frozen) for consumers that manage their own storage, and Surface B (injection-orchestration via port traits) for consumers that want spoke to compose the full lifecycle. See spoke-adapter-architecture.md for the adoption guide.
The structured prose output within a world — organized into chapters, scenes, and narrative flow. A world may have multiple manuscripts representing parallel storylines or drafts.
The ordered sequence of events and KnowledgeEntries in a world — the "when" axis of the narrative. Timeline entries are append-only; rewrites create Forks. A Timeline is experienced as three zoom layers — Brief (world-global shape), Narrative (event-level), Moment (scene/beat-precise) — not a single flat event list. World Timeline leads with Brief+Narrative; Work Timeline (peer surface) leads with Narrative+Moment. See Timeline-first World building.
Timeline's world-global layer — era / age / multi-decade markers and world-shape summary so an author can see the world's history at a glance. Brief is the hero layer for World Timeline (World entry defaults to Brief when Brief data exists, else Narrative with an honest empty-state). Time span is large by design; density is minimal (era landmarks, not every event). Not a separate container from Timeline, and not the same as a free-text World Summary / manifesto alone — Brief is a when-axis projection. The data carrier is block_type=era KnowledgeEntry, a cross-profile world-shape marker (not a profile-specific category like novel_category / game_bible_category). Work Brief is not yet a Canvas layer (Outline covers Work structure; tracker DF-V1123-WORK-BRIEF). Cross-ref: Timeline, Timeline-first World building, Narrative.
Timeline's event-level layer — human-paced events in order (days/weeks/years): battles, treaties, journeys. Shared by World Timeline and Work Timeline. This is the Timeline surface reframed as one of three layers (balanced event axis + relationship edges + Context clusters). Disambiguation: not "narrative writing" (prose craft) and not a synonym for Manuscript — here Narrative means the event-granularity Timeline zoom layer. Cross-ref: Timeline, Brief, Moment, KnowledgeEntry.
Timeline's scene/beat-precise layer — sub-scene time (minutes/hours within a scene), manuscript-anchored, so an author can scrutinize what happens in an exact scene. Moment is the hero layer for Work Timeline (peer CanvasSurfaceKind = "work-timeline"; Work entry stays Outline). World Timeline does not ship a Moment layer (DF-V1123-WORLD-MOMENT). Disambiguation: distinct from Moment Context Assembly (the session process that packs KnowledgeEntries + memory for an agent task). Scope hierarchy already includes Moment under World > Timeline > Event > Moment (entity-scope-model.md); the Canvas projects Moment as a Timeline layer. Cross-ref: Timeline, Narrative, Outline, Manuscript.
The only mechanism for changing world history. Creates a divergent branch from a point in the timeline. Original history is preserved. Forks are the structural equivalent of version control branches for narrative.
A named selection of KnowledgeEntries for context assembly — defines which knowledge is visible during a specific creative moment (e.g., "current chapter scope", "scene scope").
A world's structural type that determines which narrative tools and capabilities are available. Examples: novel, essay, game-bible.
A structured, non-linear representation of a work's planned content — nodes representing chapters, scenes, beats, arcs, arranged on the infinite canvas. Outlines are editable and drive manuscript generation.
A WASM-powered execution unit within a world — the mechanism an author or agent invokes. Examples: combat engine resolution, dice rolling, relationship graph computation. Compute modules are embedded (shipped with the binary) or user-authored. Distinct from the Computable pillar in Three Pillars above: this entry is the capability mechanism; Computable is the product thesis that worlds react via such capabilities.
One execution of a compute module against a World — the direct-lane (Control Room) product concept over the compute_sessions row. A Run moves running → succeeded | failed; a succeeded Run stays Needs review until the author explicitly Accepts (→ Applied) or Discards (→ Discarded). The direct lane never auto-applies (review-then-apply); the preset narrative.compute path may auto-apply inside a Harness session. Run history is retained, and terminal Runs can be cleared per World (Clear history — never running/needs-review rows). Author-facing vocabulary (Run / Proposal / Accept / Discard): daemon-api-surface-conventions.md §12.3. Cross-ref: Compute (Capability), Compute result, Computable. Wire surface: daemon-api-surface-conventions.md §12.3.
A Timeline node created when an author accepts a Run's proposals — event_type: "compute_result", appended canon (never provisional) with extensions.nexus.compute provenance (module id/version, run id, source_kind: "direct_invoke"). Preset-path compute events share the same event family so accepted reactions speak one visual language; failed/discarded Runs never produce Timeline nodes (the Timeline stays narrative truth, not an ops log). Cross-ref: Run, Timeline, Computable.
A pre-configured bundle of compute capabilities with a YAML manifest. Presets define which capabilities are available, how they sequence, and what prompts/rules they use. Example: "combat-engine" preset. Disambiguation: distinct from the Preset (Injection) Slot under Creative Writing Domain (a named ordered region of the assembled prompt) — this entry is the capability bundle, not an assembly slot.
A built-in preset shipped with the app under presets/_system/<name>/, addressed by a qualified id with the _system. prefix (e.g. _system.maintenance). The on-disk directory is the stripped name — resolving an id to a path must strip the prefix first (see .mstar/knowledge/conventions/system-preset-qualified-id-resolution.md). System presets are read-only and hidden from author-facing management surfaces (e.g. Sessions list, preset Delete).
The creator's persistent memory pipeline — a structured I/O system ("SOUL") that stores and retrieves personal context across sessions. This is not World KB; it's the author's own memory (writing preferences, character voice notes, etc.). Creator-scoped only: under the Actor model (roadmap), a Character's SOUL/Memory uses a distinct bearer — Character writes never enter Creator memory rows. See Actor.
The process of assembling the right set of KnowledgeEntries, timeline state, and creator memory for a given creative moment. Produces a "moment context" that an agent sees when performing a task (e.g., "write next chapter"). Not the Timeline Moment layer (scene/beat Canvas projection on Work Timeline) — this entry is the session context-assembly concept.
The iterative process: write → reflect → generate findings → human review → apply changes. Separates automated quality analysis from human decision-making.
The process: persist new text → extract structured knowledge → promote to World KB. Runs on a schedule, not inline with writing.
Repo-root DESIGN.md and DESIGN.dark.md — the cross-application source of truth for Nexus brand tokens, VI palette, logo usage rules, and accessibility intent. All app surfaces derive from this layer; they must not redefine shared brand values.
The profile-specific, read-only typographic treatment applied to the manuscript reading surface in apps/web. Driven by DESIGN.md reading-chrome-* tokens and the Work's work_profile (novel, essay, game-bible, script). Reading Chrome is strictly presentational: it never mutates body_path, outline, or timeline state.
The sidebar footer UI component that lists Creator avatar icons and switches the active creator_id for the SPA's data queries — shipped (apps/web FooterProfiles); the earlier claim that the multi-creator UI was still missing is stale. Switching updates the client-side active-Creator context and, in the desktop build, calls the Electron switch_active_creator IPC, which repoints the workspace root and reports restart-honesty copy when the path differs from the running service's startup-captured root (the browser build performs no fake switch). The multi-Creator service surface is /v1/daemon/creators + /v1/daemon/creators/active served by apps/nexus-service. Single-creator case: exactly one avatar plus a "+" affordance to add a new Creator.
Publishable npm workspace package (packages/nexus-ui) exporting brand assets (SVG logos), token data, CSS theme entry points, and the shared presentational React components — Button, Badge, Card, Input/Label/Textarea, Select, ToastProvider/Toaster (with the useToast hook; Toast itself is a type, not a component), Tabs, TransportErrorBlock, the Compute Run Studio primitives (RunFormFields, EntityPickerField, ProposalSections, RunStatusBadge, RunsTable), and NexusLogo/NexusMark. PNG logo sources and canonical font binaries are Git LFS–tracked for provenance; canonical SVGs are regular-git text. Consumers import the package entry, never a deep @42ch/nexus-ui/src/* path; cn is the shared class-merge utility.
The standard protocol for agent-to-agent communication. Nexus is an ACP client (not an ACP agent/server). It sends requests to the user's local agents and receives structured responses.
The adapter layer that translates between Nexus's internal capability model and external ACP agents. Allows Nexus to ask any ACP-compliant agent to perform tasks without being tied to a specific provider.
The single admitted runtime owner of one workspace on the current host: it holds that workspace's engine, effect/commit authority, Host and run-observation resources, and it is what a service boot publishes readiness for. Exactly one may exist per workspace — a second open is refused, never silently joined — and its lifetime ends in a close that either confirms that every retained owner released its authority or reports the retained set as interrupted.
The monotonic generation counter of a workspace's engine/owner lifetime. It identifies which owner generation a handle, session token or event cursor belongs to, so a reference minted before a close or restart is refused instead of silently resolving against the new owner. A streaming cursor carries the epoch it was minted in; a cursor from a prior epoch is answered as lost history, not replayed.
A close in which every retained owner has released its authority, so a fresh owner may take the home. The other outcome is interrupted: owners stay retained, the lease stays held, the pending set is reported, and a later close retries the settlement. A close that cannot verify release reports interrupted — it never claims a confirmation it cannot establish.
The retained wire family — the HTTP surface reachable under /v1/daemon/*, exposing world/knowledge, creator, orchestration, and manuscript endpoints to the CLI, SPA, and desktop shell. It is not a live daemon process: browser/Electron clients reach it through the standalone TypeScript service (apps/nexus-service) over nexus-core, while retained CLI leaves call core directly — the URL prefix does not imply a Rust daemon host. By default it binds to loopback; a non-loopback bind (fail-closed) requires --allow-remote plus --tls-cert/--tls-key (off-loopback TLS is mandatory) with an API key (NEXUS42_DAEMON_API_KEY). NEXUS_DAEMON_REMOTE_BIND is not this service's gate — it governs the core Connect peer-tools lane only (crates/nexus-core/src/connect/accept.rs). Conventions: daemon-api-surface-conventions.md; host boundary: rust-core-service-boundary.md.
The opt-in spoke-connect surface for third-party narrative reasoning (PD-09 / FL-R / DF-72 N-C0): a separate OS process started by nexus42 connect start (Cargo feature connect-host, default off) that peers over spoke-connect with integrator runtimes and advertises an honest HostCapabilityManifest (installation host_id = ~/.nexus42/device-id; roles ["data-store", "checker", "assembler", "computable-engine"]; extensions.nexus.served_ops = ["upsert", "promote", "relate", "check", "assemble", "compute", "tools.nexus.list_observed_peers", "tools.nexus.list_modules"] — the six core ops plus the local tool ops (DF-84); compute ships via N-C2 E2, so the connect surface is the semantic reasoning-complete milestone wire form; the literal "reasoning-complete" string stays absent because the manifest schema defines open-string arrays, not that enum). It is the third consumption surface alongside Daemon HTTP — Adapter-full, not Product-full: it never exposes Harness UI, ACP-as-server, or Canvas, and non-served inbound ops are refused (op_unsupported). Capability-token / world scoping must exist before multi-tenant exposure. See Daemon API (creator UI SSOT) and the FL-R roadmap record. Spec: spoke-adapter-architecture.md §10.
The first-launch flow (Entrance → Agent → Workspace → Done) gated by a setup_completed marker in ~/.nexus42/config.toml. The Entrance step persists the Entrance through the desktop Electron IPC (set_entrance — desktop-only: the browser build skips the step) before completion. Triggers again if the marker is cleared. Every app launch (not only first) verifies the daemon is running before entering the main UI.
The combined registry-list + PATH-scan operation the Daemon API exposes at POST /v1/daemon/agent-host/scan, returning candidate agents annotated with local-install availability. The scan probes only registry-known binary names, with bounded concurrency and short --version timeouts (no user-supplied commands are executed during scan).
SQLite-based (via sqlx) persistent storage. Contains World KB tables, creator profiles, timeline data, and orchestration state. Single database per home directory.
The single source of truth for all cross-language types. schemas/ directory defines the JSON Schema, and codegen produces Rust types (crates/nexus-contracts/) and TypeScript types (@42ch/nexus-contracts npm package).
The infinite canvas surface that visually organizes creative material — worlds, manuscripts, outlines, KnowledgeEntries, and relationships — into a navigable spatial layout.
The local-first "Control Room + Setup" web interface (apps/web). A React SPA served by the daemon over HTTP (127.0.0.1:8420), providing the infinite canvas, workspace management, and structured writing tools. Reuses the @42ch/nexus-contracts TypeScript types — never hand-writes wire DTOs.
On Creator hub routes (/works, /worlds), the content region flips between two modes: Create page (no World/Work selected — card CTAs to create) and Controller Panel stub (entity selected — placeholder + Back that clears selection). Mode SSOT was CreatorEntitySelectionContext (provider removed in #442 as dead glue; the pattern doc keeps the design for reintroducing it), orthogonal to canvas routes under /works/:workId/*. See creator-shell-content-mode-pattern.md.
The User-layer usage identity — developer | content-creator — that selects between the two first-party SPA layout trees: Create (a reduced tree that hides the operator chrome — agent catalog, preset manager, sessions, schedule, rules authoring, inspector, Connect, capability browser) and Develop (the full Control Room plus the Develop hub v1 land route /developer). Orthogonal to Creator: switching entrance never creates, swaps, or hides Creator profiles, and the profile switcher stays available in both trees. v1 is web/desktop persisted state only — browser localStorage (nexus-entrance) and desktop Electron IPC (get_entrance / set_entrance writing the entrance key of ~/.nexus42/config.toml, same durability class as setup_completed); no daemon User entity, no schema, no wire contract (wire_contracts_changed: false). Default = content-creator; unset/failed reads resolve to it without writing. Specs: web-rebuild-ia.md (proposed) §29, desktop-shell.md §13.
The Electron desktop client (apps/desktop-electron) — the shipped desktop host (the former native desktop composition is not a supported concurrent runtime). It wraps the web SPA (apps/web/dist) in a native window, forks the standalone TypeScript service (apps/nexus-service) as the runtime serving /v1/daemon/* and owns that service's lifecycle, and adds OS-level capabilities (Open with…, Reveal in Finder, Copy Path, active-Creator switch, entrance/setup persistence) behind a typed preload bridge (window.nexusDesktop.invoke). The web bundle detects desktop mode from that bridge alone and selects DesktopClient + ElectronDesktopCapabilities over BrowserClient; browser mode degrades honestly — it never performs a fake desktop switch. Distribution is an unsigned macOS app/DMG for both architectures; GUI, Gatekeeper, and installed-deployment qualification remain unverified. Spec: desktop-shell.md.
Paths are relative to the repo root. Each entry links the term to its authoritative spec doc under .mstar/specs/.
| Term | Related concepts | Spec doc |
|---|---|---|
| Harness | Orchestration Engine, Agent Host, Capability Registry, Preset | orchestration-engine.md |
| Computable (pillar) | Compute (Capability), WASM host, compute-module-abi | compute-module-abi.md |
| Timeline-first World building | World, Timeline, Brief, Narrative, Moment, Outline, Workspace (Canvas), Fork | canvas-strategy-surface.md |
| Term | Related concepts | Spec doc |
|---|---|---|
| Actor | Creator, Character, ActorWorldBinding, Viewpoint | actor-product-model.md — durable authority (the Character stages and developer maintenance both shipped) |
| Creator | Actor, WorldMembership (Creator↔World), Creator Memory, World | creator-workflow.md (shipped operational owner); actor-product-model.md (Actor-kind reframing) |
| Character | Actor, ActorWorldBinding, WorldSheet, Character KnowledgeView | actor-product-model.md — shipped (identity edit and reversible archive included) |
| ActorWorldBinding | Character, World, WorldSheet (≠ WorldMembership) | actor-product-model.md — shipped (WorldSheet maintenance included) |
| WorldSheet | KnowledgeEntry (block_type=character), ActorWorldBinding |
entity-scope-model.md (shipped KE taxonomy); actor-product-model.md (binding linkage) |
| Character KnowledgeView | Character, ActorWorldBinding, KnowledgeEntry, Scope | actor-product-model.md — shipped (KE content maintenance included) |
| Viewpoint | Actor, World, Moment Context Assembly | actor-product-model.md (subordinate execution context) |
| Term | Related concepts | Spec doc |
|---|---|---|
| World | Fork, Timeline, Manuscript, Scope | entity-scope-model.md |
| KnowledgeEntry | SourceAnchor, Taxonomy, Computable | entity-scope-model.md |
| SourceAnchor | KnowledgeEntry, Provenance | entity-scope-model.md |
| Manuscript | World, Timeline, Chapter, Moment (layer) | entity-scope-model.md |
| Timeline | World, KnowledgeEntry, Fork, Brief, Narrative, Moment | entity-scope-model.md |
| Brief | Timeline, Narrative, Timeline-first World building | entity-scope-model.md; canvas-strategy-surface.md |
| Narrative (Timeline layer) | Timeline, Brief, Moment, KnowledgeEntry | entity-scope-model.md; canvas-strategy-surface.md |
| Moment (Timeline layer) | Timeline, Narrative, Outline, Manuscript | entity-scope-model.md; canvas-strategy-surface.md |
| Fork | World, Timeline | entity-scope-model.md |
| Scope | KnowledgeEntry, Moment Context Assembly | entity-scope-model.md |
| Narrative Profile | Novel, Essay, Game-Bible, Script | novel-writing/workflow-profile.md |
| Outline | Workspace, Canvas, Manuscript, Moment (layer) | canvas-strategy-surface.md |
| Term | Related concepts | Spec doc |
|---|---|---|
| Compute | Preset, WASM module, Capability Registry | compute-module-abi.md |
| Run | Compute, Module, Accept, Discard, Compute result | daemon-api-surface-conventions.md |
| Compute result | Run, Timeline, Accept, Computable | entity-scope-model.md |
| Preset | Compute, Orchestration, Capability | orchestration-engine.md |
| Creator Memory | Creator, SOUL I/O, Character (distinct SOUL/Memory bearer — roadmap) | creator-workflow.md |
| Moment Context Assembly | Scope, KnowledgeEntry, Creator Memory (≠ Timeline Moment layer) | local-runtime-boundary.md |
| Quality Loop | Findings, Review, Knowledge Loop | novel-writing/quality-loop.md |
| Knowledge Loop | KnowledgeEntry, SourceAnchor, Quality Loop | novel-writing/quality-loop.md |
| Term | Related concepts | Spec doc |
|---|---|---|
| ACP | Agent Host, Daemon API | acp-client-tech-spec.md |
| Agent Host | ACP, Capability, Daemon API | agent-host.md |
| Hosted Execution Owner | Engine epoch, Confirmed close, Agent Host, Local Database | rust-core-service-boundary.md |
| Engine epoch | Hosted Execution Owner, Confirmed close, Run (run identity) | orchestration-engine.md |
| Confirmed close | Hosted Execution Owner, Engine epoch, Local Database | rust-core-service-boundary.md |
| Daemon API | apps/nexus-service (wire owner), Web UI, CLI, JSON Schema | daemon-api-surface-conventions.md |
| Connect Host | Daemon API, ACP, FL-R / DF-72 | spoke-adapter-architecture.md |
| Local Database | SQLite, World KB, Orchestration state | local-db-schema.md |
| JSON Schema (Wire Contracts) | schemas/, codegen, nexus-contracts | schemas-directory-layout.md |
| Workspace (Canvas) | Canvas, Outline, Manuscript | canvas-strategy-surface.md |
| Web UI | Desktop Shell, Daemon API, NexusClient | web-rebuild-ia.md (proposed) |
| Entrance | Web UI, Desktop Shell, Creator (orthogonal) | web-rebuild-ia.md (proposed); desktop-shell.md |
| Desktop Shell | Web UI, apps/nexus-service service lifecycle, Electron IPC |
desktop-shell.md |
| Setup Wizard | Desktop Shell, Daemon API, ACP Agent Detection | desktop-shell.md |
| ACP Agent Detection | Desktop Shell, Daemon API, ACP | desktop-shell.md |
| Profile Switcher | Web UI, Creator | web-rebuild-ia.md (proposed) |
- Counter vocabulary. Three different counters meet in current-host workflows and are not interchangeable: the engine epoch (which owner generation a handle or cursor belongs to), a durable run's state revision (the workflow graph's own revision fence), and a preset's core-context version (the immutable context version a schedule points at). A consumer that needs one of them must read that one — for example a commit receipt is projected from the recorded commit output, never from a state revision standing in for it.