Platform Tasks

Where to start

Twenty-two guides sit in this category. These seven are the ordered path a new operator actually walks — toolchain, first session, first look at the console, first inference call — followed by the three things every operator needs next.

• How to install the development toolchain — The pinned Rust toolchain, a baseline build and test run, and the signing key you need before touching an archive. Start here.
• Open your first Totebox session — Reading the manifest and the inbox, understanding what a session may and may not write, and completing the shutdown sweep before closing.
• Explore the console for the first time — Orientation to os-console: the status bar, the F9 inference dashboard, and the mandatory F12 checkpoint that writes to the ledger.
• Run your first SLM query — Submitting an inference request to the Doorman over HTTP, which is the real path, since the console's F9 slot is a monitoring dashboard with no query interface.
• Verify a WORM ledger entry — Checking an entry against a fetched checkpoint with a standard SHA-256 toolchain; no proprietary tooling exists or is required.
• Export structured data from the platform — The three real export paths: DataGraph records over MCP, wiki Markdown straight from git, and paginated ledger entries over HTTP.
• Add a node to a running fleet — The second node uses the same enrolment mechanism as the first, because nothing about enrolment changes once a fleet exists.

Getting started

The foundation: install the toolchain and open your first session.

• Install the development toolchain — Installs the pinned Rust toolchain with rustup, runs a baseline build and tests, and verifies the commit helper and SSH signing key needed before working in a monorepo archive.
• Open your first Totebox session — Opens a first Totebox session in a single archive: read the manifest, check your inbox, understand what the session can and can't write, and complete the shutdown sweep before closing.
• Explore the console — Orients a first-time operator to os-console — the status bar, the F9 inference-gateway dashboard, and the mandatory F12 input checkpoint that writes to the WORM ledger.

Working in the console

Use the platform's terminal interface and its built-in Cartridges.

• Navigate the console TUI — Navigates os-console by keyboard — the F-key strip at the top, the status bar's real fields at the bottom, and switching slots without losing state.
• Use the F-key model — Works the os-console F-key cartridge model — F3 email, F9's monitoring-only SLM dashboard, F12's file-based Input Machine — where each compiled-in cartridge owns its slot's rendering and input.
• Read the command ledger — Reads the append-only WORM ledger over service-fs's real HTTP API — paging entries with a cursor and fetching a signed checkpoint — since no ledger-browsing UI exists in the console.
• Run your first SLM query — Submits a first inference request to Doorman directly over HTTP — the real path, since the console's F9 slot is a monitoring dashboard with no query interface at all.

Records & storage

Work with the WORM audit ledger and entity data.

• Read and write Totebox archives — Reads a Totebox archive's state at session start — inbox, session context, git status, NEXT.md — and writes changes through the staging-tier commit flow.
• Verify a WORM ledger entry — Verifies WORM ledger entries against a fetched checkpoint over service-fs's real HTTP API, using a standard SHA-256 toolchain — no CLI or proprietary tooling exists or is required.
• Query the DataGraph — Queries the DataGraph for current entity state with the real query_datagraph and get_entity_context MCP tools, and handles DataGraph unavailability as its own signal, separate from Doorman's inference tiers.
• Export structured data — Exports platform data through three real paths — DataGraph entity records via MCP tools, wiki Markdown read directly from git, and paginated ledger entries over service-fs's HTTP API.

Multi-entity scale

Manage multiple tenants, users, and fleet nodes.

• Configure a tenant namespace — Configures a tenant namespace on service-vm-tenant via environment variables and a restart — the real config-driven mechanism, since no runtime tenant-registration API exists.
• Scale user access — Grants role-scoped capability tokens to new users as a team scales, using service-content's real pairing API — there is no promote/demote or bulk-revoke operation, since no revocation mechanism exists at all.
• Add a node to a running fleet — Adds a second node to an already-running PPN fleet using service-vm-host's real env-var configuration — the same mechanism as the first node, since nothing about enrollment changes once a fleet exists.

Integration & data

Connect external data pipelines and build location-intelligence applications.

• Build a co-location map — Renders tier-coloured co-location cluster markers in MapLibre GL by loading a PMTiles archive directly — the real flat-file architecture, since no bearer-token REST cluster API exists.
• Connect to the OSM data pipeline — Ingests a new retail or service chain from OpenStreetMap using the real ingest-osm.py script and taxonomy.py's CATEGORIES/BRAND_FILL dicts, then rebuilds the servable cluster tiles.
• Federate archives via content mounts — Federates a second knowledge instance's articles into a running instance through a knowledge.toml mount entry — a flat, merged namespace with no isolation, not a URL-prefixed federation scheme.
• Use declarative knowledge mounts — Adds a secondary content repository to a running knowledge instance via a knowledge.toml mount entry — into the same flat slug namespace as the primary, since no URL-prefix isolation exists.

Device pairing, capability tokens, and fleet enrollment now have their own category — see Machine Authorization. Self-hosted deployment now has its own category — see Self-Hosting.

Financial & construction tools

Run the platform's domain tools — the construction cost, schedule, and quality ledger and its accounting and payroll siblings. Each is a command-line tool; none has a console screen today.

• Generate a construction cost estimate report — Runs the construction reporting binary against a CSV data directory to produce costing and schedule reports as HTML and PDF, with reconciliation and validation logs — the only interface that exists, since the tool has no console screen and parses no command-line arguments at all.
• Generate a financial statement package — Runs the statements binary for one fiscal year and one period to render a consolidated statement package as HTML and PDF, recomputed from journal CSVs on every run — the tool refuses to render rather than publish a figure that does not tie.
• Generate a payroll register — Runs the payroll binary to aggregate budgeted labour hours by division into an HTML and PDF register — a narrow report that computes no gross pay, no pay frequency, and no remittance, and prints an em dash rather than a number wherever it has none.
• Monitor an active construction project — Runs eight independent recurring-cadence report binaries — status, exceptions, cost-to-complete, change-order exposure, subcontract and equipment tracking, safety activity, and portfolio roll-up — against a project's data directory, plus the dashboard that confirms what actually landed on disk.
• Close out a construction project — Runs the two job-completion report binaries — a weighted six-category operational scorecard and a job-completion checklist and review pack — either of which can also be run as a live status check on a project still under construction.
• Generate a construction draw workbook — Runs the five report binaries in tool-accounting-tco-26's construction-industry extension — capital call request and schedule, statutory declaration, checks issued, and cash-flow calendar — covering an active build's statutory and payment-timing exposure.

See also

• Architecture — cross-cutting platform architecture
• Patterns — named design patterns used across the platform
• Totebox session — what a Totebox session is and what it can do
• Machine-based authorization — how machine-based authorization works
• Machine Authorization — device pairing, capability tokens, fleet enrollment, and binary-download authentication
• Self-Hosting — deploying platform components on your own infrastructure