Skip to content
DSH Brickbook

Glossary

The real names in the source

Plain-language and source-level meanings side by side. Open a term's chapter to return to the part of the story where it appears.

26 terms

  • Plugin

    Replaceable brick

    Open chapter

    A brick that can be attached or removed. Its registered traces disappear when it is removed.

    A function or class that implements a Service. Function plugins export inject + apply(ctx); class plugins call super(ctx, name) in the constructor and register immediately.

  • Cordis

    Baseplate

    Open chapter

    The LEGO baseplate. It does not care what a brick looks like—only that it attaches, detaches, and can find the others.

    A spatially and temporally composable plugin framework. It contributes Services, typed events, and reversible Effects. Fiber disposal unwinds registrations.

  • Context / ctx

    Shared shelf

    Open chapter

    One teacher puts the brain on the shelf; everyone else asks for ctx.llm without knowing that teacher.

    The service repository. Stable keys include ctx.tools, ctx.llm, and ctx.sessions. Depend on a service name, not its implementation.

  • inject (Cordis)

    Wait for friends

    Open chapter

    Say ‘I need the tool cabinet,’ and the baseplate waits until it arrives before activating you.

    A plugin's service dependency declaration. Requirements express load order instead of manual boot sequencing. This is unrelated to agent.inject().

  • inject() (Agent)

    Slide a note under the door

    Open chapter

    Do not ring. The note enters next-step and waits for the next claim.

    Agent.inject() puts a message into inbox.next-step without calling wakeDriver. Runtime context, skill bodies, and time commonly use this path.

  • Fiber

    A mounted brick's lifetime

    Open chapter

    The time a brick stays attached. Remove it, and everything it registered is collected.

    The lifecycle of a Cordis plugin instance. Fiber disposal unwinds every ctx.effect() / ctx.on() registration.

  • Effect

    Reversible registration

    Open chapter

    Items placed on the shelf and calls listened to disappear when the brick is removed.

    Registrations made through ctx.effect() or ctx.on(). There is no privileged kernel to patch.

  • isolate

    A classroom's own tap

    Open chapter

    This classroom's water tap is separate from the lobby's. A service name can have another instance.

    isolate(name, label) gives a child Context its own same-named service. Agent presets use it to build a capability tree per classroom.

  • scope

    Locker

    Open chapter

    One locker per person. It is not a fence; it only keeps coats on the right hooks.

    dsh-scope partitions registration layers by agent. Scope is not a sandbox; isolate provides independent same-named services.

  • Profile

    Toy box

    Open chapter

    Choose a box before leaving: web has a window; headless goes home after one job.

    A named assembly stored in Harness home. It lists bundles, out-of-tree plugins, and the user's cordis.patch.yml. Web and headless ship as templates.

  • Bundle

    A ready-made bag of bricks

    Open chapter

    The biggest bag is dsh-base; the bag with a window is dsh-web-app.

    A distribution format for Cordis config entries and mounting code. dsh.bundle points at a patch file. Higher layers may always patch inserted content.

  • Patch

    Note / sticker

    Open chapter

    Find a row by name and replace the whole row. Restate every field you want to keep.

    applyEntryPatches replaces a complete config row by id or inserts a new one. There is no deep merge; later layers win.

  • Seam

    Replaceable connector

    Open chapter

    Socket, plug, and lamp must all exist. A socket alone is not a capability.

    Service Definition + Provider + Consumer. Extension plugins depend on the definition, never a concrete provider.

  • Execution world

    The room where work happens

    Open chapter

    Hands and feet must enter the same room. Glasses move with them.

    fs and subprocess share an execution world. Point both at E2B and Bash, PTY, and LSP follow without provider-specific forks.

  • Sandbox

    Fence / safety gate

    Open chapter

    It is not a move—just a gate inside this room. Silent pass-through is forbidden.

    ctx.sandbox.confine wraps local argv. A remote sandbox is a different fs/subprocess provider pair, not a sandbox backend.

  • Session

    Journal

    Open chapter

    Everything that happens is written in a notebook that only grows forward.

    An append-only SessionEvent log with in-memory storage, exposed as ctx.sessions. Fork, resume, and search derive from it.

  • Model-visible means logged

    Seen by the model means already recorded

    Open chapter

    Any essay the teacher sees has already been copied into the journal. No secret edits.

    deriveMessages() projects model history from surface events. A runtime invariant ensures everything reaching a model request can be rebuilt from the log.

  • Turn / Step

    One assignment / one step

    Open chapter

    An assignment can take several steps. A step is one thought plus its tool calls.

    A Turn opens before the first claim and closes when no work remains. A Step is one model request plus its tools. A rejected first claim still closes a durable zero-step turn.

  • Inbox

    Notes on the desk

    Open chapter

    followup rings the bell, steer calls through the door, inject slides a note underneath.

    followup → next-turn and wakes; steer → next-step and wakes; inject → next-step without waking. Claim only deletes.

  • Waterfall

    Passing paper through an onion

    Open chapter

    Call next() to pass the paper inward; otherwise you take control.

    Around-middleware where listeners receive (...args, next). agent/pre-step, agent/request, llm/stream, and tools/* are waterfalls.

  • emit / parallel / serial

    Broadcast / work together / take turns

    Open chapter

    A broadcast cannot veto; parallel runs together; serial takes turns without next().

    emit does not await; parallel awaits all; serial awaits in order and returns values. turn-stopping is serial.

  • Host / Client

    House / window

    Open chapter

    The house runs in Node. The browser window assembles another small Cordis city.

    Host: webserver / apiproxy. Client: another Loader mounts immediately entries and gives the DOM to ctx.uiRenderer. Native capabilities are loopback-only.

  • Slot

    A hole in the felt board

    Open chapter

    The chat box, sidebar, and settings are pictures pinned into holes.

    The SlotMap composition API. ConversationNodeDefinition plus a keyed renderer adds a conversation node.

  • Agent preset

    Agent outfit

    Open chapter

    Different classrooms in one process can dress their agents differently.

    Assemble an agent + persona per session. Service rows require an isolate realm. Exposed as ctx.agentPresets.

  • compaction / spill

    Recap / another sheet

    Open chapter

    Summarize a journal that is too thick; move an overlong sentence outside and keep a reference.

    compaction uses token-meter pressure to trigger summaries; spill moves oversized tool results out of line. replace removes nodes hidden by its shadow.

  • ImageAttachmentRef

    Drawer number for a photo

    Open chapter

    The journal never holds the photo, only the line saying which drawer it went into.

    The serializable reference returned by ctx.attachments.saveImage after it normalizes and content-addresses an image. SessionEvents carry the reference only; base64, browser paths, and provider URLs never reach the log. read_image requires a mounted durable store and a routed model that declares image input.