Rangoon.si — a local-first workbench for reusable intelligence capabilities.
Turn scattered AGENTS.md, CLAUDE.md, SKILL.md and project instructions into understandable, versioned capabilities. Inspect their source, derive and review skills, decompose or combine exact revisions, build workflow definitions, compile instructions, and review an export before handing it to another system. Rangoon runs independently of LNSAT and every external authority provider.
Local Gateway development preview. Infrastructure can manage multiple local LNSAT connections, inspect scoped Auditor access, and recover and roll back durable read rules. The macOS development flow can prepare a Gateway and install a per-user background service. Start with the local Gateway guide. Exact source and runtime evidence is recorded in the development ledger. The preview uses a disposable, pinned Gateway overlay. Managed fleet deployment and signed release packaging are separate qualifications.
The desktop application is named Rangoon; Rangoon.si is the product wordmark. Superintelligence (super intelligence, SI) describes the long-term direction, not a claim of current superintelligence or guaranteed autonomous safety. The free open-source desktop workbench is Apache-2.0. macOS, Windows and Linux remain the initial desktop release targets; team/cloud/enterprise operation is a later stage.
Current status: an experimental native workbench with persistence, immutable skill/workflow revisions, composition, compilation/export/inspection and explicitly consented advisory model paths. The ordinary desktop source enables encrypted-workspace startup by default, with explicit setup/unlock and no plaintext fallback. Encrypted recovery has dated disposable macOS evidence, including recovery into a fresh independently keyed workspace and restart. Windows startup/custody/recovery remains unsupported in the current implementation; Linux GUI/custody and packaged release qualification remain open. Original instruction files and deliberately readable exports are outside workspace encryption. The local Gateway preview is mounted separately from the general authority adapter. Agent scheduling and the plugin runtime remain unmounted.
The October 29 whole-application audit reconciles current source against earlier architecture and usability checkpoints. The completion plan puts recovery, installed local tasks and usable editing ahead of more disconnected demonstrations. The development ledger records exact validation and limits. Source tests, checksums, model reviews and source CI do not establish runtime enforcement, target-loader compatibility, desktop support or certification.
Workbench update — November 3: continue exact saved revisions from Skills or Compose into Compile while preserving dirty drafts and historical pins. Task-oriented controls, 57 original full-color icons, packaged software marks and Recipe/Graph output navigation make the local workflow clearer; long titles and sixteen-output/recovery cases are covered by source and synthetic UI tests. Current source checks pass 670 JavaScript tests; headless software-rendered browser review completes 110 layout profiles and 30 checks while retaining native-select/Lock-pointer gaps. Opt-in memory-only replay also covers saved-result routing, exact revision/focus and dirty/busy/late-result guards; it is not native persistence evidence. Disposable native folder fixtures now bind their exact identity and require newly created manifest-v3 runs; this does not qualify the installed encrypted workflow. See the publication scope and evidence.
Review today: the reviewer guide provides a short design/source task and a disposable-data native task. Browser samples and playgrounds are synthetic. The local Operations window reads one selected report and shows unverified observations; it is not a live feed. Use disposable data in an explicitly isolated review profile. Earlier macOS recovery evidence does not qualify the current working tree, normal-profile migration or every platform. Broader desktop beta and three-OS release support have separate qualification gates.
A fresh macOS development binary exposed and then passed a repair for a startup lifecycle panic caused by registering a native failure anchor before Tauri setup. The native startup receipt records the direct-binary smoke, source checks and independent review. Installed GUI task qualification remains open.
Approval management, redacted correlated telemetry and live operations visualization remain accepted core product scope. Their offline inspection contracts and eight-target authority reference catalog already exist; authenticated ingress, qualified dispatch and actual evidence are still required. LNSAT is an optional authority with a scoped local development preview. General-purpose provider execution remains outside that preview. Provider allow, local content review, approval and execution are distinct facts. Ordinary authoring never requires an external connection.
VUSL develops independently; its repository owns the language specification and future core. RUSL is retired as an active Rangoon technical contract. The old rangoon-language parser remains inert experimental source with its original fixtures and wire identifiers preserved for reproducibility. No RUSL reader, converter, alias, dual-profile system or backward-compatibility promise is planned without demonstrated need. Rangoon will remove the old source only after a usable, pinned VUSL core is integrated and the affected consumer tests are updated and pass independent review. The consumer direction records that sequence; historical spec/fixture provenance does not establish a runtime dependency or current VUSL support. OpenShell and LNSAT remain separate optional systems, and Rangoon's local capability workflows remain independent of both. The retirement receipt records this documentation-only update.
The cross-runtime operator-record target defines what Rangoon must show for denied, approved, changed, repeated and uncertain actions. It prioritizes read-only OpenShell observations for this goal while LNSAT evidence remains an independent later gate. No live cross-runtime record exists today.
Output format and Compile actions now appear above long saved-skill/history lists, with selected-revision context and nearby stale-selection recovery. Existing action gates and export warnings remain. Local source checks pass 660 tests; eight bounded ARM-browser layout captures completed with clean teardown; complete interaction and native workflow qualification remain open. Evidence.
The workbench now uses 57 original filled, multi-color object icons, with the original monochrome shapes retained for high-contrast mode. Software identities include locally packaged authentic marks for agentgateway, Cerbos, Permit and Invariant, alongside Claude, Rangoon, LNSAT and VUSL. Existing availability, authorization and action gates are unchanged. View the color gallery and asset provenance.
JavaScript checks pass 659 tests and independent rendered visual review passes. Browser runs captured all 44 viewport/theme profiles but failed during repeated Lock input; complete interaction and native-workflow qualification remain open. See the full-color receipt.
The workbench now uses a 57-symbol local icon system for actions, records, storage states and systems. Skills, Compile, Lock and backup/export controls retain their text and behavior. Real packaged software marks identify Claude, Rangoon, LNSAT and VUSL; other software uses generic category symbols beside its name. The icon gallery separates identity from connection or support claims. Desktop navigation scrolls while Lock/theme stay reachable, and disabled primary actions use neutral styling.
JavaScript checks pass 652 tests. Synthetic browser validation completed 44 viewport/theme profiles and 17 checks; qualification remains partial for actual native dropdown input. Current native encrypted workflows and real-user usability require separate proof. See the inspection and validation receipt.
Skills now groups tools by task: find or create in the library, edit a revision, continue with its saved version in Compose/Compile, and inspect origin/history. Search stays visible; optional filters retain their state and show active facets. Recovery explanations sit beside relevant controls, and conflict reload appears above the editor.
Source checks pass 648 tests. Synthetic browser checks completed 14 viewport/theme profiles and 17 interaction/media/controller cases; overall qualification remains partial because native dropdown input is unverified. Native encrypted persistence and the latest desktop artifact still require separate qualification. See the task-arrangement receipt.
Skills keeps revision actions above the editor, with more compact task headers, clearer title typography, responsive content sizing and consistent dark/light surfaces. Existing draft, conflict, history and exact-revision rules stay intact. The native development executable has been rebuilt offline with these frontend changes.
Isolated synthetic browser checks now cover 14 viewport/theme profiles, including emulated 4K/DPR layouts, and 11 pointer/keyboard/recovery states. All desktop revision actions stayed above the fold and all tested action targets met 44×44 pixels. This is browser/source evidence, not a packaged release or qualified native encrypted workflow. See the rendered/build receipt.
Skills and Compose now preserve exact saved revisions in both directions: add a saved skill to Compose, then inspect an actual saved output in Skills without silently substituting a newer revision. Native readback precedes result navigation; unsaved edits, busy states, duplicate/full inputs and open drafts retain work and explain recovery. Navigation and Lock reject stale replies. Draft creation, preview, save, review, compilation and export remain explicit.
The disposable native harness also binds a synthetic folder and exact file inventory to each test run, rejecting mutation/replacement/link/unexpected-child cases before and after phases. The roadmap reconciles local completion with later authenticated peers, credential/key lifecycle and enterprise operation boundaries. Live peers, cloud control and distributed dispatch remain planned.
These are source changes, not a desktop release. Current rendered/native encrypted-workflow qualification remains open; Windows/Proxmox testing is deferred and Windows custody/startup/recovery still needs implementation. Source tests do not qualify normal user data, provider enforcement or compliance. The publication receipt records the exact scope and evidence.
Rangoon keeps its local-first capability workbench and native Rust trust boundary while improving project/target task continuity. The prepared packet sequence starts with an artifact-bound encrypted local journey, then exact-revision editing/composition, retained file inspection, reversible instruction-file changes, one verified target-loading handoff and practical bulk organization. Original bytes and revisions stay authoritative; future syntax projections/indexes are derived and versioned.
Finished radials, bars, icons, packaged system logos and refined abstract Rangoon artwork remain part of the visual contract. Metrics must show real scope/counts/freshness and inspectable detail, with complete empty, stale, partial, denied, failure and recovery states. These docs do not claim that the proposed UI or enterprise features are implemented.
Later peer/enterprise work requires verified tenant/actor scope, target-side operation guarantees, current ownership, scoped credentials/key lifecycle and recovery before writes or failover. Cloud hosting, cloud resource management and model inference are distinct profiles. Shared services, KMS/BYOK/federation, live peers and distributed dispatch remain planned; optional engines and VUSL retain their independent boundaries. Local usefulness does not wait for enterprise infrastructure. The development receipt records this documentation-only reconciliation and remaining gates.
The disposable macOS harness now includes the existing folder-metadata and explicit file-inspection permissions, plus a fixed synthetic folder bound to the run manifest and artifact inventory. It rejects changed contents, replaced entries, links and unexpected children before and after a phase. Input-integrity results remain separate from native UI results; the manual workflow checklist still needs a fresh artifact and actual picker, Lock, restart and recovery observations. See the development receipt for validation and limits.
Windows testing is deferred until the new Proxmox test host is available. Windows encrypted custody/startup/recovery implementation and three-OS GUI qualification remain outstanding. The next local milestones are a repeatable encrypted workflow, retained folder-row inspection, reversible project-file changes and one verified target-loading handoff.
This update brings the current local workbench into one source snapshot: encrypted default startup and recovery, instruction-history persistence, native lifecycle hardening, bounded Agent files and folder metadata, Markdown review/find, and exact saved-skill handoff to Compile. It preserves the newer public LNSAT offline inspection modules and independent VUSL direction. Rust manifests, local checks and source CI use the same 1.99.1 toolchain. Windows validation resolves the logical Cargo tool through rustup, then uses the returned absolute .exe paths; it never falls back to an unrelated compiler on PATH. The default encrypted Windows source build requires OpenSSL headers and the x64 MSVC import library; CI validates the hosted runner’s preinstalled copies explicitly. This build configuration does not enable the still-unsupported Windows workspace startup or key custody. Recovery-journal ownership now explicitly releases its lock at teardown, including when a duplicate handle survives temporarily; active competing owners still refuse access.
Folder browsing returns metadata; inspecting content still requires an explicit file selection. Remote inventory remains an offline contract, live providers/execution remain unavailable, and a desktop release still needs current-artifact and platform qualification. Original instruction files and deliberately readable exports remain outside workspace encryption. The full publication receipt records validation, independent review, exclusions and the next native workflow milestone.
Open in Compile carries a selected saved skill revision directly from Skills into Compile through an exact native read. Historical selection stays pinned; compilation, format choice and export remain explicit. Dirty edits for that skill, conflicts and pending requests block the handoff with recovery guidance. Navigation and Lock invalidate late reads. This slice has source-test evidence; the full-publication receipt records its additional synthetic rendered checks. Native task qualification remains separate. Receipt and next steps.
Add to Compose carries the exact selected saved revision from Skills into Compose after a native read, including historical revisions. Existing inputs and drafts remain intact; unsaved edits, open Compose drafts, busy/unavailable states, duplicate pins and full selections explain why adding is blocked. Draft creation, preview and save remain explicit. Late navigation/selection/Lock replies are discarded. This is source-tested; rendered and native qualification remain open. See the implementation receipt.
Saved Compose results now open their exact saved revision in Skills after native readback, with matching editor focus. Later revisions are not substituted. Unsaved edits for that skill block opening; other drafts remain. Failed or stale reads keep the current workbench. Source evidence and remaining rendered/native gates.
Agent files already has bounded native folder metadata selection, source inspection and IDE-style Markdown review. Folder rows still require a separate explicit file selection to inspect content; persistent tags/indexing, remote transport and copying/applying instructions remain future work. The immediate completion order is a repeatable isolated native workflow, safe row-inspection custody, then one qualified external target. A custom executor, scheduler or larger demonstration catalog is not required for that local milestone.
This source update brings the independent integration contracts and lifecycle work together while preserving the useful local workbench. The publication receipt records checks and remaining gates.
- Interoperability: D1 parses bounded offline observation documents. D2a maps pinned OpenShell fixtures; D3a decodes pinned LNSAT authorization/attempt/receipt/reconciliation evidence. Native payload identities remain visible and neither path grants authority or silently joins engines.
- Read-client engineering: the OpenShell v0.1.4 OIDC gRPC client uses pinned TLS/target/scope, bounded reads/watches, immutable credential deadlines and cancellation. Synthetic TLS tests compose it with one-shot native consent and callback custody. It remains unmounted; production Start is unavailable.
- Reproducible protocol sources: vendored OpenShell protobuf files retain LF bytes on every checkout, including Windows. Build-time hashes still verify the exact upstream sources; line-ending conversion cannot silently substitute different bytes.
- Native lifecycle: workspace admission closes before exit cancellation. Late setup/unlock callbacks cannot reopen it; callback ownership survives timeout/retry until actual return. The existing cleanup coordinator owns the final result. Real event-loop and platform qualification are still required.
- Workbench presentation: compact responsive layouts, bounded 4K workspace width, calmer abstract connected-form artwork and clearer local-model confirmation controls preserve the library/canvas/inspector layout. Design/playground data remain explicitly synthetic.
- Completion direction: finish encrypted adoption and real local tasks, then add reproducible capability/model/harness comparisons, context-fidelity cases and portable evidence. External task recovery and generated-tool lifecycle follow as provider-specific integrations.
The transcript-backed research and primary-source audit explains this focus. The LNSAT handoff is a proposal for that separate product's owner, not a change to LNSAT. Rangoon currently has no user-facing evaluation runner or durable agent scheduler; no claimed cost saving or competitor superiority has been measured.
The current audit matrix separates implemented behavior, missing qualification and planned integrations. Shared task navigation, compact themed headers, optional terminology help, retained skill drafts, workflow edit recovery, saved-summary search and flexible library/canvas/inspector docks are already implemented. Their completed receipts remain in the ledger; do not rebuild them from older planning paragraphs.
The material/node-editor grammar applies to Rangoon modules: a searchable library, direct canvas and properties/provenance inspector, with context actions, keyboard alternatives and explicit save/review boundaries. The current workflow connection controls need clearer eligibility and refusal recovery. Keep 3D and animated flow as optional inspection surfaces; the separate playgrounds are explicitly synthetic and cannot substitute for real runtime data. Native task, all-three-OS and rendered accessibility qualification remain distinct from browser fixtures.
The first useful experience is deliberately concrete: select a Markdown file, inspect its exact content and section inventory, save a snapshot, derive a skill, edit a new revision, record local review, and reopen that work after restart. Composition extends this into traceable transformations across saved records. The native Compile workbench turns exact saved revisions into inspectable AGENTS.md/CLAUDE.md artifacts and candidate manifests through a pure compiler and a read-only workspace service. Native Export and external bundle inspection are implemented in this source through the native command/UI path described in instruction-bundle-ui.md; isolated macOS native QA now covers the recorded import/save/derive/review/Compile, export, external Inspect, and restart flows, while collision/write uncertainty, composition compile, full keyboard coverage, Windows/Linux GUI, and target-loader qualification remain open. Publication evidence belongs in the development ledger.
The intended users are developers managing agent configuration, platform teams maintaining shared capabilities, and reviewers who need source lineage and explicit change plans. Cloud administration and government use are later qualification targets, not capabilities established by the current desktop prototype.
| Area | Implemented in this source | Remaining work |
|---|---|---|
| Design preview | Nine synthetic views: Command Center, Import, Decompose, Merge/Split, Skills, Workflows, Connectors, Evidence, and release planning; dark/light themes and responsive layouts | Replace each sample workflow with a real, qualified application service |
| Import & Analyze | Bounded Rust Markdown scanner, stdin CLI, and one explicitly selected native file; exact text, digest, spans, and diagnostics | Explicit directory/repository import, additional formats, optional semantic proposals |
| Local workspace | SQLite source snapshots; explicit save, deduplication, reanalysis on reopen | Broader project/workspace model and platform qualification |
| Skills | Source-section derivation, immutable revisions, history comparison, local content review, versioned provenance, loaded-summary search and Review/Origin filters | Explicit-root discovery, persistent organization, compatibility, distribution and collaboration |
| Decompose/Merge/Split | Real native editor routes, local saved-source/revision filtering and direct composition canvas: drag/drop, click-to-connect, contextual/keyboard actions, bounded undo/redo, exact recipes/coverage, new/append destinations, retained previews, atomic storage, and schema 3 recovery | Complete advanced GUI/failure qualification and Windows/Linux interactive evidence |
| Data controls | Managed encrypted startup, inventory, explicit setup/unlock/lock, encrypted recovery copy, explicit older-backup import, additive restore and dependency-aware logical deletion; selected disposable macOS recovery evidence | Current-artifact and normal-profile qualification, Windows implementation, Linux GUI/custody, retention/rotation and package release; instruction-file apply/restore remains separate |
| Engine integration | Explicit unavailable LNSAT action port; offline D2a OpenShell mapper and D3a LNSAT evidence decoder; unmounted OpenShell read-client/native custody source with synthetic-peer tests | Real-target/authentication/native qualification, connected readback and O3 detail; production Start remains unavailable |
| Model assistance | M1a pure pack/validation, session-only local custody, native local workbench, and native cloud orchestration are implemented. Cloud exposes ten bounded main/review commands, explicit capability configuration, retained full-envelope credential pairing, source-free GET checks, fixed-origin TLS, final parented OS consent, and pre/post freshness checks; outputs remain inert and advisory | Real provider compatibility, tokenizer/accounting, proposal application, three-OS GUI, security and release qualification remain open; M1b/V1 are incomplete |
| Workflows | Pure typed definitions and structural validation; durable schema-4 history/recovery; six native authoring commands; real saved-library/canvas/inspector source with local workflow/function filtering, separate control/data wires, six described node types, exact capability pins, draft/validated saves, historical reads and comparison | Native save/restart/history/stale-state GUI qualification across all three OSs; run records and execution remain future work. The separate design preview remains synthetic |
| Agents and templates | Synthetic visual concepts and architecture direction | Real reusable agent records, dependency closure, templates, scheduling and qualified runners |
| Approval, telemetry and operations | Accepted core architecture; portable O1a bounded observations and O1b read-only inspectors; O2 first local selected-window route with a privacy-minimized timeline, declared topology, inspector and separate reported decision counts. Outputs remain unverified with no authority or execution | Scoped gateways/rules, human and delegated-agent chains, authenticated redacted ingress, live graph/timelines/replay, persistent analytics and per-operation enforcement adapters; broader O2 and O3–O5 gates remain open |
| Connectors and harnesses | Candidate catalog, provider-neutral offline descriptors, pinned offline decoders and OpenShell synthetic transport/native conformance | Real provider/version qualification, SDK/plugin lifecycle and connected UX; catalog presence is not support |
| Instruction compilation | Two immutable text-format profiles, exact-byte artifacts, deterministic candidate manifests, and native inspection with revision selection, diagnostics and evidence | Native GUI qualification, SKILL/support-file profiles, qualified target versions, and target-loader compatibility |
| Test Lab and export | Development tests, independent golden fixtures, portable instruction-bundle encoder/verifier, native Export/Inspect commands/UI, and stdin-only CLI bundle inspection/exact artifact extraction | User-facing static tests, native GUI qualification, target conformance, desktop target-file export and evidence bundles |
| Distribution | Three-OS source/test/build CI; selected macOS development-bundle runtime evidence | Windows/Linux GUI checks, installers, signing, updates, rollback, and release qualification |
| Team/cloud/enterprise | Architecture direction | Service implementation, tenancy, identity, operations, and deployment evidence |
The atomic composition store and native integration reached public source through PR #12 and PR #13; PR #15 added the interactive native composition editor. An isolated macOS development bundle completed Decompose, Merge, and Split with new outputs, then restart/reopen of five saved skills. Native append/mixed-destination GUI, the full failure/keyboard matrix, Windows/Linux GUI, and release qualification remain open. Exact implementation, test, and publication receipts belong in the development ledger.
Authority Inspect now reveals the selected inspector when navigating within the authority screen, including repeated selection, while preserving the in-memory plan. This is a focus correction, not a provider action.
The October 9 feature review is historical. Managed startup, coordinated close/drain/purge, durable recovery and encrypted backups were implemented afterward. Current priorities are a repeatable isolated native source-to-export/restart task, recovery on the actual artifact and safe folder-row inspection. Additional provider catalogs do not substitute for that proof. Live authority adapters remain unavailable, Windows needs implementation, and three-OS/package release gates remain open. The October 29 assessment and development ledger own current truth.
Rangoon uses a small Rust core with a Tauri 2 desktop host and a shared, static HTML/CSS/JavaScript frontend. The browser preview uses a dependency-free Node server. The native application loads bundled frontend assets and does not start that HTTP server.
Bundled native workbench Browser without native bridge
Import / Skills / Decompose / Merge / Split native-backed routes unavailable
Workflows / Compile + Export / Workspace authority reference/planning local
Model Assistance / LNSAT diagnostic separate design/playground synthetic
| |
scoped Tauri IPC no native commands
|
apps/desktop host
sessions / pickers / busy guards
/ \
rangoon-host rangoon-store ------ SQLite workspace
bounded file reads validated records / transactions
| |
rangoon-import rangoon-compose / rangoon-compile
deterministic spans recipes / instruction artifacts / identities
\ /
rangoon-domain
typed records / identities
rangoon-engine: independent, unavailable LNSAT integration port
| Path | Responsibility |
|---|---|
crates/rangoon-domain/ |
Source, span, capability, revision, and provenance record types; content identity helpers |
crates/rangoon-import/ |
Deterministic bounded Markdown section analysis |
crates/rangoon-host/ |
Selected-file reads, bounded native backup handling, and exclusive instruction-bundle file helpers |
crates/rangoon-store/ |
SQLite schema validation, snapshots, revisions, local reviews, composition storage, backup/restore, and deletion |
crates/rangoon-compose/ |
Pure transformation validation, coverage, materialization, destination application, and deterministic identities |
crates/rangoon-compile/ |
Pure AGENTS.md/CLAUDE.md instruction artifacts, static diagnostics, candidate identities and strict portable-bundle verification |
crates/rangoon-workflow/ |
Pure typed control/data graphs, structural diagnostics, canonical definition identities, and immutable revision candidates; no storage or execution |
crates/rangoon-ops/ |
Closed observations, bounded decoding, immutable graph/timeline projections, reported evaluation/approval relationships, finite delegation and stage/ballot/decision inspection, and reported lifecycle/outcome/coverage inspection; authenticity and authoritative eligibility remain unverified, with no I/O, authority or execution |
crates/rangoon-engine/ |
Inert GovernancePort and LNSAT unavailable diagnostics |
crates/rangoon-language/ |
Retained inert experimental RUSL parser and historical fixtures; removal waits for usable VUSL core adoption and updated consumer tests |
crates/rangoon-integrations/ |
Provider descriptors, offline OpenShell mapping and pinned LNSAT evidence decoding; no provider operation or execution |
crates/rangoon-openshell-client/ |
Unmounted read-only OpenShell gRPC client with pinned protocol/TLS, bounded watch and lease/cancellation checks; synthetic peers are opt-in test support |
crates/rangoon-model-assistance/ |
Pure bounded context packing and advisory-response validation; no transport, provider, credential, or authority behavior |
crates/rangoon-model-local/ |
Explicit numeric-loopback Ollama-compatible HTTP/1 transport for prepared advisory requests; the desktop host supplies consent and calling orchestration; no credential or authority behavior |
crates/rangoon-model-cloud/ |
Fixed-origin OpenAI Responses TLS adapter, exact request/credential-revision binding, bounded response validation and synthetic TLS fixtures; native host now supplies consent and custody orchestration |
crates/rangoon-model-session/ |
Memory-only session profile/request custody, saved-record resolution, exact protected packing, single-use handles, lifecycle leases, and freshness checks; no network or authority behavior |
crates/rangoon-cli/ |
Stdin source analysis, strict portable-bundle inspection/exact artifact stdout and local engine diagnostics; no workspace editing, project installation or execution CLI |
apps/desktop/ |
Separate Cargo workspace containing the Tauri host, scoped commands, native sessions, assets, and OS icons |
preview/ |
Synthetic product preview, native workbench views/controllers, splash, icon system, and styles |
fixtures/ |
Secret-free source examples, contract fixtures, and independent identity vectors |
tests/ |
Node controller, view, server, and contract tests; Rust tests also live inside individual crates |
.github/workflows/source-checks.yml |
Core, frontend, and native source/build checks |
docs/ |
Accepted intent, specifications, product direction, claim evidence, and validation receipts |
The renderer authors an editable draft and checks returned preview shapes and byte mappings before display. These checks can reject a malformed or inconsistent response, but they are not the authority for saveability. Commit sends only an opaque preview ID, expected workspace state ID, and acknowledgment; it cannot supply replacement originals, a result body, or an arbitrary database path. Rust resolves saved references, computes saveability, retains the exact preview, rechecks current records and outputs, and owns the transaction. Rust and renderer tests now share an independently pinned complete core-preview fixture, including byte mappings and coverage, across new/append target examples. Native session and receipt contracts retain separate tests.
The pure composition crate has no database, filesystem, process, provider, or network behavior. The store resolves records and enforces persistence rules around that core. The native host adds user selection, retained previews, bounded IPC, and lifecycle handling. The engine port remains separate from all local content operations.
Current implementation is a modular monolith, not a ready network service: pure transformation rules live in Rust crates; local use-case orchestration currently spans the store and Tauri host. A later self-hosted service must extract typed use cases with explicit actor/workspace context and reuse the same Rust transformation and transaction semantics behind authenticated APIs. Tenant isolation, storage concurrency, remote job ownership, and API compatibility need separate qualification. A frontend framework migration is not a prerequisite for that work. The architecture boundary and extraction gates record the current path and remaining risks.
This separation protects local commits but does not make the Tauri command layer a reusable server API. Before hosting, move retained preview custody and single-attempt commit orchestration into a transport-independent Rust use case, bind each handle to an authenticated actor and workspace, and give both desktop and HTTP adapters the same typed operation. The renderer may continue to reject bad previews for display; it never decides which bytes can be saved. An uncertain commit response requires authoritative readback, not an automatic retry or a second implementation of transaction rules.
The analyzer accepts caller-supplied UTF-8 Markdown bytes and a display basename. The basename is a label, never a path for the CLI to open. The native host obtains bytes only after the user selects a file through the OS picker.
| Bound | Value |
|---|---|
| Source size | 262,144 bytes / 256 KiB |
| Logical lines | 10,000 LF-delimited lines |
| Content bytes per line | 16,384, excluding LF/CRLF terminators |
| Fragments | 256, including any preamble |
| Display name | Nonempty Markdown basename, at most 255 UTF-8 bytes; no path separators, colon, or control characters |
| Encoding | Valid UTF-8; optional BOM preserved; NUL rejected |
Oversized or malformed input is rejected, not silently truncated. AGENTS.md, CLAUDE.md, and SKILL.md receive filename classifications; a classification does not prove harness compatibility. Other valid Markdown names receive a generic classification.
The parser recognizes ATX headings, preambles, and backtick/tilde fences that suppress headings inside code blocks. It preserves BOM, CRLF, Unicode, separators, and trailing text. Empty input and unclosed fences produce explicit diagnostics. Every report discloses the limited Markdown subset.
It is a section scanner, not a CommonMark parser, semantic skill extractor, instruction sanitizer, or policy evaluator. Setext headings, frontmatter interpretation, nested-container semantics, and HTML-block rules are outside the current parser. Unsupported syntax remains original text.
rangoon.source-analysis.v0 contains the analyzer version, source record, ordered fragments, diagnostics, and authority: none.
source.idbinds the display name and original bytes using versioned, length-framed SHA-256 input.source.sha256hashes the exact supplied bytes;content,byteLength, andlineCountdescribe that same input.- Fragment spans use zero-based, end-exclusive byte offsets and one-based inclusive line coordinates.
- The fragments form a complete ordered partition: concatenating them reconstructs the original source.
- Every proposed fragment is
unreviewed; analysis never grants review or execution authority.
The report contains original source text and is not redacted telemetry. See the analysis contract for identity framing, supported syntax, diagnostic codes, and CLI exit behavior.
Selection and analysis are in-memory operations. Save locally persists a source snapshot explicitly. Identical basename and bytes deduplicate; a changed basename or content produces another source identity. Original selected files are never rewritten.
The native startup coordinator owns the OS app-local anchor and its managed-workspace directory; the older source-workspace location is inspected separately for explicit Legacy-copy handling. The renderer cannot choose database paths. Inspecting a missing layout does not create it; setup requires a distinct native action. Reopening a source reanalyzes its bytes and checks stored identity, digest and length.
Ordinary desktop source enables encrypted-workspace by default. Native bootstrap installs deferred Managed services over the OS app-local anchor; missing backend/anchor or unsupported startup stays unavailable rather than silently opening Legacy plaintext. The library's encrypted-sqlite feature remains optional for other callers, and explicit Legacy regression/compatibility paths remain in source. These are different configurations, not a runtime fallback.
SQLCipher uses the pinned 4.14.0 community profile: 4096-byte pages, enabled per-page HMAC, zero plaintext header, HMAC-SHA512/PBKDF2-HMAC-SHA512 profile checks and the SQLCipher-4 iteration setting. The host supplies a 32-byte raw key and owns entropy, custody and recovery; this is not a user-password derivation interface. A keyed connection forces schema access and cipher integrity validation before accepting wrong-key, corrupted, truncated or incompatible input. Temporary SQLite storage is memory-only. Native-owned key buffers zeroize; that does not prove erasure of allocator, parser, SQLite or OS copies.
SourceAccess, Owner and the shared admission gate route source, capability, workflow, composition, compiler and data controls through typed native services. Exact generation checks reject stale callers. Close first fences admission, drains actual callbacks, releases native custody and purges renderer/controller/DOM state; a completed UI lock requires the matching acknowledgment. Cancel alone does not prove that a picker closed or an operation had no effect. A compromised unlocked process or administrator can still obtain readable content; encryption at rest cannot repair that trust boundary.
Durable Pending/observation slots and retained plans distinguish committed, refused and uncertain operations across restart. Recovery revalidates actual layout, key custody and full records before an explicit confirmation. Lost keys never cause silent regeneration; contradictory or unauthenticatable state stays closed. Content hashes and review labels do not authenticate authorship or prevent replay of an older valid database. Storage contract and dated development evidence retain the individual implementation and failure-case history.
First interactive setup creates a new encrypted workspace under the user's OS account after native confirmation. Existing Legacy data follows an explicit verified-copy flow; it is not silently converted or overwritten. Unlock, interrupted-setup recovery and Lock use the same native lifecycle boundary. No cloud account, model, LNSAT or other engine is required. Installer elevation must not own the workspace key.
The Workspace surface exposes setup/unlock/lock, inventory, encrypted backup and explicit restore. Technical diagnostics and detailed limits stay in advanced disclosures. A future workspace-management CLI must use the same custody, exclusive ownership and domain receipts; there is no general workspace CLI, arbitrary SQL interface, hidden unlock or privilege granted by a presentation mode today. Rotation and broader retention tooling remain open.
E1d-2 recovery uses a canonical encrypted workspace image and a separate native-selected recovery key file. The October 25 disposable macOS run covered backup, original test-key removal, restore into a fresh independently keyed workspace, distinct-process reopen and exact test-slot cleanup. It did not qualify normal-profile adoption, the current artifact, Windows/Linux or release packaging. The recovery key file is itself unencrypted: protect it like a password and store it separately; anyone with both files can read the backup.
Windows startup and key-file recovery currently return unsupported/refusal states, rather than merely lacking a test receipt. The underlying native workspace owner also refuses non-Unix acquisition before backend, filesystem or credential work; platform compatibility never substitutes for missing file-identity guarantees. Windows source CI exercises this refusal and preserves platform-independent checks. The first refusal-enabled run passes all 432 selected tests, including the three no-change cases; its remaining platform-guard lint findings are corrected with the warnings-denied gate retained. Exact-head format, tests, Clippy and native build are required before publication. Encrypted custody success and adversarial workflow fixtures run on Unix until a separately implemented Windows custody backend is qualified. Linux and macOS each still need their applicable current-artifact, GUI, custody and package checks. The Managed host refuses the older plaintext whole-workspace backup export. Older plaintext backup import remains explicit. Original source files and intentionally readable instruction-bundle exports are not encrypted by this workspace and retain their own disclosure/consent boundaries.
A source-backed capability begins at one saved section. Editing creates an immutable successor revision and advances the capability's current head only when the expected revision still matches. Earlier content and reviews remain available. History comparison is local content comparison, not proof of semantic equivalence.
Composition adds capabilities born from recipes and revisions produced by particular recipe applications. A capability's birth origin remains stable; each revision separately records ordinary or composition provenance. An ordinary edit after composition keeps its parent relationship without claiming that the old byte mapping describes the new text.
A local content review binds to one exact revision. The recorded reviewer is the fixed label local_operator, not an authenticated identity. New revisions are unreviewed and do not inherit a prior review. All these records retain authority: none.
| Version | Records | Transition behavior |
|---|---|---|
| Schema 1 | Source snapshots: original bytes and source metadata | Created only by an explicit write; analysis fragments are recomputed rather than stored as a trusted report |
| Schema 2 | Source-backed capabilities, immutable revisions, and local reviews | First capability creation upgrades schema 1 within the same transaction |
| Schema 3 | Composition recipes, applications, derived-capability owners, and revision derivations, alongside existing records | Successful composition writes or qualifying restores migrate atomically with their data |
Reads and previews do not initialize or migrate the real workspace. Unsupported schemas and unexpected structures fail without resetting or replacing the database. Older APIs reject schemas they do not understand; versioned APIs preserve source and composition distinctions.
Current limits include 128 snapshots, 128 capabilities, 32 revisions per capability, 1,024 total revisions, 128 recipes, 128 applications, provenance depth 128, and a 64 MiB database allocation ceiling. Source/revision content remains bounded to 256 KiB. These limits are implementation constraints, not a promise of unlimited enterprise scale.
See local snapshots, reviewed capabilities, and composition destinations.
| Operation | Inputs | Outputs | Initial behavior |
|---|---|---|---|
| Decompose | One complete saved source | One or more, within the output limit | Start from the analyzer's exact partition, including preamble and whitespace |
| Merge | Two to sixteen distinct pinned capability revisions | Exactly one | Preserve input order; introduced separators are explicit authored pieces |
| Split | One pinned capability revision | Two to sixteen | Partition the whole input into editable output recipes |
Inputs name exact saved IDs and digests. Historical revisions may be selected explicitly; the host never silently substitutes a newer revision. Span boundaries are half-open UTF-8 byte offsets, not JavaScript string indexes.
An output is an ordered sequence of copy, authored, or replacement pieces. Copy pieces retain exact source ranges. Authored pieces record new text and an explanation. Replacement pieces bind changed text to its original range and a reason. Exclusions remove no source record; they explain why a range contributes no output bytes.
The core derives coverage from actual recipes. It distinguishes copied, duplicated, replaced, excluded, and unassigned input spans. Deliberate duplication needs acknowledgment; exclusions and replacements need reasons. Declared conflicts need explicit resolution before a saveable result. Conflict declarations are manual records: Rangoon does not automatically discover every contradiction in prose or certify a resolution as safe.
The native result includes materialized output text, provenance mappings, diagnostics, and saveability. An incomplete draft can remain inspectable while persistence is blocked.
Every output explicitly chooses one of two closed targets:
{"kind":"new"}{"kind":"append","capabilityId":"capability:<digest>","expectedRevisionId":"revision:<digest>"}Append requires the actual current head of that destination, even when an older revision is used as an input. Duplicate destinations are rejected. New destinations must be absent. All destinations are applied together; an operation cannot partially advance a set of skills.
A recipe identity describes transformation content and order. An application identity binds the recipe to ordered destinations. A composition-produced revision additionally binds its application, output index, parent, title, and content. Ordinary edits retain their separate identity algorithm. Independent golden vectors pin these encodings.
The store prepares and validates a proposed post-state without modifying the actual workspace. The native host retains that preparation and returns an opaque preview handle. Commit accepts acknowledgment of that exact handle and workspace state, not a replacement recipe or renderer-calculated result.
Within an immediate transaction, the store rechecks saved inputs, destination heads, complete workspace state, materialization, quotas, and proposed records. Schema migration, recipe/application rows, new owners, output revisions, derivations, and head updates commit together. Earlier inputs, revisions, and reviews remain intact.
The receipt contains actual saved capability details in output order. A changed workspace or target requires a fresh preview and acknowledgment. An uncertain response does not trigger automatic mutation retry. Transformation acknowledgment is distinct from later per-revision content review and grants no execution authority.
See the composition specification, destination contract, and native session contract.
The real Decompose/Merge/Split workbench supports dragging source sections and recipe pieces, click-to-connect ports, visible action menus, right-click actions and keyboard alternatives. These edit the same ordered recipe used by native preview and save. Undo/redo retains at most 32 entries and 4 MiB of combined serialized history; it cannot restore a previous acknowledgment or save receipt. Pending native operations lock editing, stale drag/connection state is rejected, and unsaved field edits require Apply/Cancel before structural changes. Narrow layouts provide explicit text actions instead of relying on dragging.
This graph reorganizes content; it is separate from workflow control/data flow and LNSAT authority. Synthetic browser interaction/layout checks and existing native composition evidence do not establish complete native canvas qualification. See composition UI and the development ledger.
rangoon-workflow implements the portable authoring foundation. Persistence is provided separately by rangoon-store, and the native host provides six authoring commands. The real #workflows editor uses that custody boundary; the separate design preview remains synthetic. Its closed node types are Input, Capability, Check, Branch, Checkpoint and Output. Typed data mappings are separate from control edges. Capability nodes declare exact capability/revision pairs; branches carry explicit paths, and checkpoints declare a prompt without recording approval.
inspect_definition strictly decodes bounded JSON, preserves decodable incomplete drafts, and reports structural errors for ports, references, topology, cycles, reachability and data availability. Canonical serialization preserves strings and array order. Only structurally valid definitions receive a workflow-definition: identity. The report always distinguishes structural validity from unverified references, unavailable execution and no authority.
The records module adds workflow_id_from_nonce, prepare_revision and decode_revision. A workflow ID derives from a caller-supplied 32-byte nonce; this pure module supplies no randomness or authenticated identity. Immutable revision IDs bind the workflow, nullable parent, explicit draft or validated intent, canonical definition and canonical layout using domain-separated, length-framed SHA-256. Layout changes alter the revision ID without altering the definition ID. validated requires structural validity, but the portable candidate cannot prove dependency existence or successful storage. Drafts preserve invalid but decodable graphs.
| Boundary | Current portable contract |
|---|---|
| Definition | 128 KiB; at most 128 nodes, 256 control edges, 1,024 data edges and eight inputs/outputs per node |
| Revision | 160 KiB raw/canonical record; strict schema, IDs, field types, duplicate-key rejection and identity recomputation |
| Layout | prepare_revision caps raw layout at 16 KiB; decode_revision caps canonical nested layout at 16 KiB within the 160 KiB raw record limit. At most 128 unique node-index entries; integer coordinates from -100000 through 100000 |
| Nesting | At most 32 JSON containers; malformed/resource failures return closed errors. Decodable structural faults produce validation diagnostics |
| Authority | No database, filesystem, network, provider, process, engine, run or approval behavior |
The W2b Rust store implements transactional expected-head saves, complete immutable history, pinned dependency resolution, migration, backup/restore and dependency-aware deletion. W2c-1 native Data inventory, export, restore and deletion controls are implemented in this source. W2c-2 native authoring commands are also implemented in this source; W3 library/canvas/inspector editing follows. Incomplete typed drafts remain saveable; stale or failed saves preserve current edits. The durable workspace contract freezes these semantics; exact qualification and publication receipts belong in the development ledger.
The current source integrates workflow rows into the complete validated record set and schema-4 state digest. Its flat V3 archive codec preserves source, capability, composition and workflow records, validates canonical bytes and exact pins, and checks both payload limits and reconstructed SQLite allocation. V1/V2 compatibility remains; legacy V2 export rejects richer records rather than omitting them. SQLite allocation exhaustion reports Full; malformed archives report BackupInvalid, except the unchanged legacy decoder behavior documented in the contract.
The following Rust lifecycle APIs are implemented. Native authoring custody is described below; the real editor remains subsequent work:
| API | Current behavior |
|---|---|
WorkspaceBackup::decode, id, byte_length |
Strict V1/V2/V3 archive inspection with an opaque validated record set; V3 reconstruction occurs in memory. |
Workspace::export_workflow_backup |
Noncreating complete export: V3 for schema 4 and unchanged V2 for schemas 1–3. |
Workspace::prepare_workflow_restore |
Noncreating, exact-state preview with complete addition counts, kept-owner counts and a private retained plan. Validated workflow pins are checked against the final additive union. |
Workspace::workflow_data / list_workflows / open_workflow |
Read-only inventory and selected-history inspection APIs. Complete record rendering preserves exact definitions, parent order and separate dependency observations; display labels are bounded and sanitized. Schemas 1–3 return an empty workflow inventory; schema 4 includes complete saved workflows and histories. |
inspect_workflow_save now validates canonical candidates, exact parent/head relationships, dependency observations, workflow quotas and complete prospective SQLite allocation without creating a workspace. The save transaction implementation supports immutable append and precise current-head retries, preserving original timestamps and history on retries. Incomplete drafts are accepted; validated intent requires exact saved capability revisions. Public save_workflow performs noncreating preflight and then atomically migrates/saves complete state. Disposable disk tests exercise first save, restart, head updates, exact retries, stale/deleted-owner replay refusal and concurrent saves; transaction fixtures also cover interruption and capacity failure.
Existing version-aware source reads/save_v1, skill *_v1 operations, composition preview/apply and stored compilation now use explicit complete-state routing. They validate workflow histories and preserve schema 4 and exact pinned revisions when skill heads advance. Composition stale-state checks include workflow metadata. Legacy source save, skill APIs and v1/composition data-control APIs still reject schema 4 before projecting or mutating records. Compatibility is exercised against disposable schema-4 fixtures. Native workflow authoring commands remain separate from the complete Data controls.
restore_workflow_backup now preflights without creating files, then rechecks the exact retained plan and complete state before inserting additions in one transaction. Empty V3 restores preserve absent, empty and existing workspaces; existing no-ops use read-only transactions. Public restore supports V1/V2/V3 data, upgrades schema monotonically when additions require it, and preserves complete local histories. Disposable disk tests exercise exact backup roundtrips, no-op bytes and retained-plan checks; transaction fixtures cover crash recovery and SQLite allocation failure.
inspect_workflow_deletion returns a private retained impact plan; delete_workflow_record revalidates its complete fields and workspace state inside an immediate transaction. Public operations handle sources, skills and workflows using complete records. Any historical draft reference to a skill owner blocks deletion, deleting a workflow removes only its history, and schema 4 never downgrades. Read-only preflight precedes write access, with full plan/state comparisons repeated inside the transaction. This is logical deletion, not secure erasure; the complete v2 native data-control adoption is specified below.
Previewing an empty V3 archive preserves an absent or existing destination's schema and creates no destination files. Complete v2 native data controls are implemented in this source. Native workflow authoring commands are implemented in this source; editor integration remains incomplete. Original images remain the layout reference for that editor. See workflow definitions, workflow records, and validation evidence.
The desktop command layer now owns one in-memory draft context and one exact inspected save candidate. The six commands are registered only for the local main workbench; the optional model/credential windows receive no authoring permissions. This is native API source implementation, not a completed workflow editor. The Workflows design preview remains synthetic.
| Command | Inputs and behavior |
|---|---|
list_workflows |
Read complete workflow inventory without creating a workspace or draft |
open_workflow |
Bounded raw request selecting a current head or exact historical revision; changes no head/session |
begin_workflow_draft |
New native-generated identity, or append to an explicitly selected current head; issues an opaque draft handle |
inspect_workflow_save |
Draft handle, closed intent, raw JSON definition/layout; builds the canonical revision using native-retained identity/parent and retains the full store plan |
commit_workflow_save |
Preview handle, exact expected state and explicit acknowledgment; consumes one attempt before reinspection/transaction, returns only a confirmed receipt |
clear_workflow_draft |
Matching active draft handle; clears session state without deleting persistent records |
Open/begin/commit/clear bodies are at most 1 KiB; inspection bodies are at most 160 KiB, with the existing 128 KiB definition and 16 KiB raw layout bounds. Requests use closed versioned raw UTF-8 JSON schemas; typed envelopes reject missing/unknown/duplicate fields and invalid selectors. Nested definition/layout JSON is retained as raw values so the existing strict domain decoders still see duplicates, depth and byte limits. These checks bound decoding after Tauri receives the buffer, not transport allocation.
Preparation accepts authored definition/layout and a native draft selector. It accepts no renderer workflow/parent/revision identity, SQL, path, timestamp or store plan. The native-generated identity stays stable while the draft is repaired. A successful new draft or preview replaces the corresponding prior session; preparation failure preserves the previous native candidate. A future renderer must treat uncertain preparation as stale. Matching confirmation consumes a single attempt even when storage refuses or its response is uncertain; no automatic write retry occurs. Draft identity remains available for a fresh inspection, while renderer text, selection, viewport and history remain the upcoming W3 controller's responsibility.
Reinspection compares the full retained plan. One narrow no-write exception permits the store's exact existing-current-head candidate retry: the schema/workflow/revision and unresolved count match, the store confirms canonical byte equality, and the head equals that candidate. A changed count, different/historical candidate or deleted owner is refused. Equal unresolved counts do not prove each dependency status stayed equal; a no-op receipt reports fresh statuses. The store transaction revalidates complete records and exact candidate/state relationships before any write.
Incomplete decodable definitions may be saved as drafts; validated intent requires structural validity and exact available local capability revisions. Neither intent records review, approval, execution or authority. Source/session tests are separate from native IPC/editor and all-three-OS GUI qualification. See native authoring and the development ledger for exact scope, checks and open gates.
The #workflows area connects native authoring custody to a saved library, positioned graph and right inspector. Its six node types expose typed text, json and boolean ports. Solid directed wires carry next, true and false control outlets; dashed directed wires carry separately labeled data mappings. Library-card and port drag/drop, click-to-connect, Outline forms and contextual keyboard actions share the same controller. Zoom and pan change the transient viewport; node positions belong to the persisted revision. Outline is the initial representation on a narrow first visit. The Workflows header uses distinct existing Rangoon technical artwork and retains the shared themed shell and sidebar mascot.
New and append sessions use native-issued identities. Exact historical capability revisions are selected from actual local inventories, rather than typed IDs or silently substituted heads. Field buffers belong to one controller target and must be applied or cancelled before structural changes or native inspection. Local undo/redo is bounded to fifty actions. Saved workflow revisions open read-only; editing requires an explicit append at the selected current head. History comparison reads two exact revision IDs without advancing either head.
Draft inspection preserves decodable incomplete graphs. Validated inspection requires a fresh native Draft report for the unchanged definition and layout, structural validity and zero unresolved references; it still performs a new native inspection. Closed response validation binds reports, dependency pairs, history, candidate identity and full definition/layout relationships. It rejects malformed or substituted success envelopes instead of fabricating observations. Explicit acknowledgment binds the exact inspected candidate. Confirmation consumes its renderer preview before dispatching one native save; uncertain replies retain local edits and require fresh inspection. A confirmed receipt survives a failed library refresh. Workspace writes invalidate workflow candidates and other workbenches' retained compilation/model/composition observations as appropriate.
The editor contract defines these behaviors and the development ledger records source, synthetic browser, review and publication evidence separately. Synthetic bridge checks exercise the production controller and binder; they do not qualify native IPC, saved restart behavior, Windows/Linux GUI, installers or released OS support. Native validation remains authoritative. Workflow authoring does not execute these nodes, activate LNSAT, connect providers or record execution approval. The historical Workflows design preview remains synthetic.
The R4a library compiles one exact capability revision into an inspectable instruction artifact. Workspace::compile_capability(capability_id, revision_id, profile) resolves the content, local review and composition lineage through the existing validated store; it accepts IDs rather than renderer-supplied content or a review flag. A reviewed historical revision remains selectable, with the observed current head reported separately. Reads do not create a workspace, migrate its schema, mark a revision reviewed or write an artifact.
| Profile | Fixed output name | Behavior |
|---|---|---|
agents_md_v1 |
AGENTS.md |
Preserve the selected revision's exact UTF-8 bytes |
claude_md_v1 |
CLAUDE.md |
Preserve exact bytes; conservatively block candidate readiness for ASCII @ or <!-- anywhere |
The Claude checks deliberately include false positives such as email addresses and code examples. They prevent presenting possibly imported or omitted content as a ready candidate under this narrow profile. They never follow includes, rewrite content, remove comments or authorize an execution. Structured requirements supplied to the pure API are retained as unsupported diagnostics and block candidates. Stored capabilities currently contain opaque Markdown rather than structured requirements, so compilation always warns that semantic equivalence, dependency closure and enforcement are unverified.
Every report carries the exact artifact text, byte digest/length, selected revision/provenance references, immutable profile descriptor/digest and ordered diagnostics. Artifact text remains inspectable when readiness is blocked. Readiness has three values:
blocked: a static compatibility error exists; there is no candidate manifest.review_required: static checks have no blocking error but the selected revision lacks local content review.candidate: the selected revision has local review and the narrow static checks allow an in-memory candidate manifest. This grants no execution or installation authority.
The compiler preserves BOM, CRLF/LF, Unicode, whitespace and final-newline state. Its domain-separated compilation identity binds profile, revision, artifact metadata and diagnostics. Review is separate: adding or changing a valid review observation leaves compilation identity unchanged, while the candidate manifest and identity bind that exact observation. The manifest uses a versioned compact JSON encoding; its SHA-256 covers its canonical bytes without a recursive self-hash. Digests establish consistency, not authentication or tamperproof local storage.
Profile versions describe Rangoon's format contract. Both profiles explicitly report runtime qualification untested, target budget unknown, semantic equivalence unverified, and authority: none. A generated file may still be ignored, truncated, combined with other instructions, or interpreted differently by a real harness. No external CLI version is advertised as qualified. The 256 KiB content limit is Rangoon's input bound, not a guarantee about available target context.
The pure compiler has no filesystem, process, environment, provider or engine access. The native Compile page calls a narrow compile_capability command with exact capability/revision IDs and a closed profile. Its raw UTF-8 JSON request is bounded to 4,096 bytes and rejects unknown/duplicate fields; source content, local review and provenance are resolved by the host. The command shares the workspace operation guard and never changes the Import session or saved records.
The inspection workbench keeps Generated text, Diagnostics and Evidence separate. It supports historical revisions, preserves unsaved Skills drafts, rejects mismatched native responses, and marks retained reports stale after known workspace writes. Refresh resolves the selected revision again; compilation runs only on explicit action. Candidate manifest text comes from the host's canonical serializer, with renderer manifest/hash consistency checks. Browser-only use shows the unavailable native bridge. Displaying text is not export or target qualification; no Copy, Install, Run or authority action is exposed.
The bundle foundation has a pure encoder and strict in-memory verifier plus bounded host helpers for an explicitly caller-selected path. It preserves exact artifact bytes and canonical manifest bytes, records component lengths, and appends a SHA-256 checksum of the preceding bytes; inspection separately reports the whole-file digest. Maximum total length is 295,016 bytes. Inspection reports verification: internal_consistency_only and authority: none. Digests detect inconsistency, not authentication, complete source-graph lineage, or target behavior. Native Export and external bundle inspection commands/UI are implemented in this source: requests are ID-only raw UTF-8 JSON bounded to 4,096 bytes; export re-resolves and recompiles after the picker, binds the fresh candidate ID, and exclusively creates a new plaintext file without overwrite; write/sync uncertainty is distinct from known no-output failure. External inspection never opens the workspace, imports, reviews or executes; it returns internal-consistency evidence with authority: none. The isolated macOS QA bundle exercised AGENTS export cancellation, successful exports for both profiles, and external Inspect cancellation, golden success from no-workspace state, own-export success, and invalid-file failure. Native GUI qualification remains open for collision/write uncertainty, full keyboard coverage, Windows/Linux, and target loaders; publication evidence belongs in the development ledger.
The CLI remains an analyzer and inert engine-status tool, with no compilation command. SKILL metadata/support-file formats, target drift/collision handling, native GUI qualification and all-three-OS target-loader evidence remain required R4/R5 work. See the compiler contract, bundle contract, native inspection contract, native bundle UI contract, and model assistance contract for exact schemas, identity framing, state handling and acceptance boundaries. M1a model assistance is implemented as a pure crate; local and cloud capability remain separate V1 deliverables, and use remains optional and explicit.
The implemented M1a core in rangoon-model-assistance has two bounded entry points:
prepare_pack(raw_json: &[u8]) -> Result<ContextPack, Diagnostic>
validate_response(pack: &ContextPack, raw_json: &[u8]) -> Result<ValidatedResponse, Diagnostic>It supports three closed tasks: classify_v1, decompose_v1, and compare_v1. A request carries already resolved source or capability revisions, exact selected byte ranges, explicit protected ranges, task/profile limits, and a requested output bound. Packing preserves input order and exact bytes, reports selected/protected/omitted coverage, and reuses only byte-identical complete blocks. Every input/range keeps an alias to the transmitted block, so deduplication does not merge provenance, scope, or authority. selectedBytes, uniqueTextBytes, and omittedBytes are byte measurements; tokenAccounting remains unknown, with no claim about token savings or compression quality.
The packer uses fixed checked-in task templates and bounded canonical JSON. The response decoder is closed and bounded before typed decoding; it requires the task-specific proposal kind, citations wholly inside selected ranges, and bounded uncertainty entries. authoredText remains inert model-authored text. Successful validation carries authority: none; it does not review, apply, execute, or mutate content. The pure core cannot authenticate database existence, revision ancestry, provider/profile identity, or operator consent, and it cannot authorize sending a payload. The separate rangoon-model-local library provides a source-only M1b transport seam: LocalProfile::parse, PreparedRequest::new, and explicit LocalClient::check/analyze use direct Tokio TCP and Hyper HTTP/1 only for a caller-invoked numeric loopback target (127.0.0.1 or ::1) and prepared payload. It uses no proxy, redirect, retry, fallback, credential, model launch, or background traffic; the loopback peer may forward or retain data. The native host supplies command, review, consent, cancellation and freshness paths for local and cloud routes. The cloud route is source-implemented with fixed-origin TLS and full credential custody; M1b/V1 remain incomplete pending provider compatibility, proposal application, tokenizer/quality qualification, native GUI and three-OS release evidence.
The rangoon-model-session crate supplies portable session custody around those libraries, and apps/desktop/src/models.rs wires it into the native host. LocalSession keeps one optional profile, one prepared request and at most one active operation in memory; configure, inspect, clear, cancel, begin_prepare, begin_check and begin_send enforce session lifecycle. Preparation resolves exact saved source or capability-revision IDs, packs each nonempty record as one protected full-content selection, rejects empty records, and exposes immutable request metadata. Random single-use prepared: and run: handles, checked generations, cancellation and non-cloneable RAII leases prevent stale or replayed ownership. Transmission::freshness is a read-before/read-after helper for native orchestration. The library performs no network calls or authority actions; the native host owns the seven main commands, three review commands, isolated exact-payload window, parented OS dialog, single-use consent, cancellation and freshness checks. See the native session contract and native workbench contract.
The local contract binds an exact immutable profile and final request payload, permits one in-flight operation process-wide, and fixes 3-second connect, 5-second version-check, and 120-second analysis deadlines. It caps the final request at 256 KiB, version responses at 1 KiB, chat responses at 1 MiB, and decoded message content at 128 KiB. Cancellation is monotonic and releases the guard; response parsing and proposal validation remain strict and advisory.
The pure inspect_proposal API checks a validated response against its exact context pack and selected proposal index, then exposes bounded proposal text and citation evidence for comparison. It performs no freshness check, destination selection, network request or mutation. Native completed-result retention and durable attributed application remain unfinished; routing model text through an ordinary skill edit would lose required model/task/pack/response provenance. See proposal inspection.
The portable rangoon-model-session::cloud module adds CloudSession, with a cloud-only profile, immutable staged request and one active operation per shared session. It reads the same validated saved records as the local path, preserves their full contents as protected ranges, and constructs the actual cloud adapter request. The caller supplies only a nonsecret credential revision; this module never opens the OS credential store.
Closed rangoon.cloud-selection.v1, rangoon.cloud-send.v1 and rangoon.cloud-cancel.v1 inputs have independent schema tags and random cloud-prepared:/cloud-run: handle namespaces. A prepared view exposes the exact outer body, byte length, SHA-256, model, fixed origin, credential revision, dependencies and separate inner context pack. Changed credential revisions change request identity. A successful claim consumes the handle once; profile replacement, clear, cancellation and a new preparation invalidate obsolete work. Read-only freshness checks compare exact content, dependency identity and observed capability heads.
Portable custody remains network-free and authority-free. Native apps/desktop/src/cloud_models.rs now calls the adapter through explicit capability-configured commands, pairs full credential envelopes to retained preparations, holds shared model/credential leases, performs source-free GET checks, requires final OS consent, and applies pre/post freshness gates. The module and native results grant no execution or LNSAT authority; model requests remain explicit disclosures outside database-at-rest confidentiality. Provider compatibility and full cross-platform qualification remain open. See the cloud session contract and native cloud contract.
The native Workspace surface provides real inventory, export through a save picker, restore through a file picker, and dependency-aware deletion. These controls exist now; they are not merely roadmap items.
The ordinary Managed workflow creates an encrypted recovery copy through native selection and consent. rangoon.recovery.sqlcipher.v1 contains a canonical SQLCipher image, bounded at 64 MiB, with an independent 32-byte recovery key selected through a strict owner-only key file. Native code builds encrypted staging, closes and reopens it, validates cipher/domain integrity, exclusively writes and syncs the selected output, then rereads that actual ciphertext and compares the complete records before reporting success. Keys, paths and replacement originals do not enter renderer requests. A post-write uncertainty is reported as uncertainty, never a false Cancel or an automatic retry.
The separate recovery key file is unencrypted and required to restore. Keep it protected and apart from the backup; the pair discloses the contents. This protects stored recovery data, not an unlocked or compromised host, original files or readable instruction exports. Recovery does not authenticate the sender, restore execution authority or establish freshness against rollback.
Older V1/V2/V3 plaintext codecs remain explicit compatibility paths. V2/V3 preserve source, capability and composition records; V3 additionally preserves workflow history. Their canonical manifests and SHA-256 trailers provide internal consistency, not encryption or signatures. Managed native plaintext export is refused. Older plaintext import remains an explicit selected-file operation under More recovery options; it does not make that input confidential. Unsaved drafts and transient preview handles are not backup records.
Restore computes the final union before mutation. Existing local records remain authoritative for membership and retained history. Absent capabilities may be imported with their complete histories; restore does not append missing historical revisions to an already-present capability or replace its head. Same-ID identity-bearing data must agree. Existing workflow owners retain their complete local history and head. Incoming workflow history must be an exact prefix including canonical bytes and timestamps; newer, divergent or retimed incoming histories are refused rather than silently discarded. An archive containing only workflows can be restored.
Missing pinned dependencies block dependent imports. The host retains the selected decoded archive and exact plan. Confirmation binds backup identity, current workspace state, and the proposed operation. State drift rejects the restore rather than applying an old plan. Migration and additions commit atomically. A matching native confirmation takes the retained candidate before entering storage; success, refusal or uncertain return consumes that attempt. Fresh preview is required for another attempt, and no write is automatically retried.
Deleting a capability removes its owned revisions, reviews, and derivation membership. A surviving capability that depends on one of those revisions blocks deletion. Any syntactically valid reference to that skill owner from any saved workflow revision also blocks deletion, including historical draft references with missing or malformed revision IDs. The impact preview lists skill and workflow blockers separately. Source deletion is likewise blocked by surviving source origins or recipe inputs. Orphaned application/recipe metadata can be removed as specified; unrelated inputs and other skills are not implicitly deleted.
Immutable recipe targets may describe outputs that were later deleted. Readback and restore use live membership and do not recreate those outputs merely because the historical application names them. A fresh, explicit composition can deliberately recreate a deterministic new destination; there are no permanent deletion tombstones.
Deleting a workflow removes its owner and complete immutable history only. It does not remove source files, input skills, unrelated workflows or lower schema 4. Native confirmation selects the exact private retained plan and consumes one attempt before storage revalidation.
The Data route and existing six native commands now adopt rangoon.workspace-data.v2, rangoon.restore-plan.v2 and rangoon.deletion-plan.v2 together. Source, skill and workflow owners remain separate; capability revision and workflow revision totals are never combined. The renderer rejects older/unknown shapes, contradictory validated-intent observations and impossible counts. It renders escaped bounded labels, local dependency observations and explicit Inspect/Delete actions without implying a workflow editor or execution exists. A workflow-only restore is actionable; a no-additions preview checks every record count. Native commands retain opaque archives/private plans and accept selectors rather than renderer-supplied impact or SQL.
These DTOs retain explicit native selection and confirmation for compatible archives; workflow authoring is a separate command family. Encrypted recovery uses the same retained restore-plan checks, and a truly empty destination preserves the complete canonical record set. Nonempty destinations retain additive union/conflict semantics. Workflow deletion is never treated as source deletion. Source tests, synthetic renderer results and dated native picker evidence remain distinct. See native controls and the development ledger for exact checks and remaining GUI gates.
Deletion is logical removal, not secure erasure. See workspace data controls and composition recovery for exact archive encoding, dependency closure, stale-state checks, and failure tests.
The October 11 purpose/vision review pauses further demo expansion. Real local source, capability, composition, revision, compilation and export behavior is the useful foundation; current workflow/flow companions remain experimental design specimens. The optional 3D graph and local change journal are frozen for review, not released capabilities. A local edit journal is not telemetry from a running agent or gateway, and no such source is established. Encrypted native adoption, complete local/native qualification and a later qualified read-only telemetry adapter remain substantive work. See the pause receipt for current evidence and limits.
The subsequent professional presentation packet refines the existing shared editor and shell: recognizable vector module types, readable cards, consistent action icons and restrained CSS feedback. Layered management keeps task actions and selected-module editing primary, with technical identities, definitions and local edit history available on demand. This is presentation work, not new execution or live-system support. The October 11 LNSAT reference maps current pinned pre-release source to optional identity, policy, approval, consumption, receipt and recovery responsibilities. Rangoon core authoring stays independent; every provider adapter remains unavailable. Exact validation, review and publication state belong in the development ledger.
The accepted compact flat graphics correction makes symbolic 2D workflow editing the default. Compact flat cards pair closed local type icons with readable names and explicit typed/control ports. The existing experimental 3D presentation is an opt-in View control over the same definition, selection and inspector. Smaller route artwork leaves more room for authoring. Drag/drop, context menus, staged Apply/Cancel, Undo/Redo and native persistence boundaries remain unchanged. This is a presentation correction; the standalone playground remains synthetic and no runtime source is connected. Source and rendered qualification, remaining gaps and publication state are recorded in the development ledger.
The guided section inspection packet further refines that alternate workflow view: fixed orientation, explicit Overview and Focus selection, instant section framing and no free-camera gestures. Node focus frames the selected module and direct neighbors; connection focus frames its exact route and endpoints. Framing never changes the definition, 2D viewport, staged edits or undo history. Flat editing and complete Outline/inspector records remain available when the graph or graphics cannot be projected. This remains design inspection, not observed execution.
Additional systems follow the existing provider interoperability boundary and extension strategy. Current contracts support closed workflow authoring and offline provider-fixture inspection; an executable plugin runtime and public developer SDK are planned, not shipped. Versioned descriptors, typed ports, explicit operation support, consent, bounded payloads and conformance evidence precede any real adapter. Third-party decisions cannot grant local approval or execution authority. The existing local workbench must remain useful without plugins, LNSAT or other providers.
The task-focused information-flow simulator at preview/flow-playground.html illustrates a proposed pull request through eight recognizable systems: agent, gateway, policy service, human reviewer, optional authority, execution checkpoint, repository and evidence. Closed native-WebGL volume meshes, local SVG type icons, bounded orbit/zoom/reset and a decision-focused inspector expose the request's route, refusal or missing outcome. The default policy-denial example makes the blocker visible immediately; explicit replay, manual stepping, scrubbing and direct blocker/evidence inspection reuse the existing immutable scripts. LNSAT's local mark identifies an optional example only, not an installed or connected backend. A complete 2D/list alternative preserves meaning when graphics or motion are unavailable. No rendering dependency, remote model/texture, provider, private record or executable tool is connected. This companion is a teaching and design-validation fixture for developers/reviewers; it is not a useful live incident console until actual qualified records are projected. Real tracing must reuse the O1 immutable operations projection and its trust fences. Validation and remaining native/performance/telemetry gaps belong in the V4 ledger receipt.
The workflow builder has browser-native drag previews, attached control/data wires and an explicitly synthetic in-memory playground at preview/workflow-playground.html. Native persistence and authority remain separate. The CLAUDE.md profile displays an official locally bundled Claude mark as format identification only; AGENTS.md remains provider-independent. No animation framework, CDN or runtime asset download is introduced. The earlier builder-polish packet passed 213 frontend tests and fresh independent review; rendered checks cover drag, undo/redo, zoomed wires, keyboard tabs/context menus, and dark/light layouts at 320, 768 and 1440 pixels. Cancellation and reduced-motion rules have source/fixture coverage, with live assistive-technology and reduced-motion emulation qualification still open. Exact evidence is tracked in the development ledger; this local source packet is not a released feature.
The OS application is named Rangoon and uses the selected logo without added text. Splash and navigation wordmarks use Rangoon.si. User-facing branding uses the short SI terminology; the expanded superintelligence term describes the documented long-term direction. This wording change does not add model, approval or execution capabilities. Startup resolves to usable application state or a visible failure; it does not invent progress or engine readiness. The visual system includes custom Foldline SVG icons, dark/light tokens, visible keyboard focus, and reduced-motion behavior.
Only the bundled main window receives the enumerated application commands. Native code opens its own pickers; the renderer receives no generic shell, arbitrary filesystem, SQL, or external HTTP capability. Bundled navigation restrictions and a native CSP complement command permissions.
| Command family | Examples | Boundary |
|---|---|---|
| Source | select_and_analyze, save_analysis, list_snapshots, open_snapshot, clear_analysis |
Native selection and retained reports; explicit snapshot save |
| Skills | list_capabilities, open_capability, create_capability, revise_capability, review_capability |
Saved references, expected heads, immutable revisions, local review |
| Workspace | get_workspace_data, export_workspace_backup, prepare_workspace_restore, restore_workspace_backup, inspect_workspace_deletion, delete_workspace_record |
Native pickers, retained plans, exact confirmations |
| Composition | read_composition_source, preview_composition, commit_composition |
Saved input resolution without replacing Import selection, and one retained preparation |
| Compilation | compile_capability |
Closed raw request, exact saved revision/profile, read-only report and canonical manifest inspection |
| Engine | get_engine_status |
No-argument local unavailable diagnostic |
| Model session and workbench | get_local_model_profile, configure_local_model, clear_local_model, prepare_local_model, check_local_model, send_local_model, cancel_local_model; isolated get_local_model_review, confirm_local_model_review, cancel_local_model_review |
Session-only numeric-loopback profile, exact protected records, native review/OS consent, cancellation and freshness; advisory output only |
| Cloud model session and workbench | get_cloud_model_profile, configure_cloud_model, clear_cloud_model, prepare_cloud_model, check_cloud_model, send_cloud_model, cancel_cloud_model; isolated cloud review commands |
Explicit cloud profile/capability config, retained request-envelope pairing, shared leases, fixed-origin TLS, source-free GET, final OS consent, cancellation and freshness; advisory output only |
Composition commands specifically use raw UTF-8 JSON IPC bytes. Preview is bounded to 8 MiB + 16 KiB; confirmation to 4,096 bytes before domain deserialization. Tauri has already allocated the transport buffer, so this is not a transport-level allocation guarantee. Closed DTOs reject unknown/duplicate fields and unsupported schemas.
The host retains at most one composition preview. A fresh successful preview receives a 32-byte OS-random handle and replaces the previous slot. Confirmation marks the handle attempted before entering storage; it cannot be used for another attempt after failure or a lost response. Verified success consumes the slot. Restart invalidates all such handles. These are local selection handles, not authentication credentials.
The store uses bundled SQLite, validated schema/record shapes, bounded transactions, fixed public errors, and unkeyed identity checks. Reopening source bytes and reconstructing composition provenance detects inconsistent records rather than silently accepting them.
New Unix workspace directories/files use owner-only permissions. Windows inherits the per-user application directory ACL; Unix mode behavior is not claimed for Windows. Known symlinks/reparse points and non-regular database/journal files are rejected. Parent directories are not held against a hostile concurrent local user.
SQLite connections disable trusted schema, use rollback-journal DELETE mode and synchronous=FULL, and apply allocation/value limits and a bounded lock timeout. Transaction and process-interruption tests are useful evidence; they do not prove power-loss durability on every device or filesystem.
Encrypted storage protects locked data, not a compromised authorized consumer. The default Managed source and encrypted recovery copy protect their respective stored bytes. Original files, older plaintext backup inputs, readable instruction exports and unlocked/model-delivered content remain outside that protection. A recovery key file must be secured separately. Consistency hashes do not establish authorship; even an authenticated encrypted image can be replaced with an older valid image. Local review labels and wall-clock timestamps remain unauthenticated.
Provider requests require the explicit configured model path, retained payload review and native consent described above. There are no automatic background source uploads. Analysis output and backups contain source content, so publishing those artifacts can disclose that content. Logical deletion cannot promise removal from backups, filesystem snapshots, or storage media.
- Define the threat model: accidental corruption, offline theft, another local account, malicious same-user software, rollback, and a compromised unlocked process require different controls.
- Qualify the implemented Managed startup and encrypted recovery on each actual target artifact and OS. Complete Windows custody/startup/recovery support, Linux GUI/custody, normal-profile adoption and rotation without weakening no-plaintext-fallback behavior.
- Add authenticated history that binds operations, identities, sequence, and prior state using protected key material. Keep consistency hashes for content addressing; do not relabel them as authentication.
- Design independently stored checkpoints for rollback detection. Stronger enterprise evidence may require an external witness; restoring all local state together cannot be made reliably fresh by another file beside the database.
- Fail closed on integrity failures, preserve recoverable evidence, and offer explicit recovery rather than silently creating a new empty store.
- Test altered pages/records, replayed backups, interrupted key rotation, lost keys, disk exhaustion, migration failure, and recovery on macOS, Windows, and Linux.
These are proposed controls, not implemented guarantees. A compromised administrator or unlocked application process can exceed the protection of local encryption. Nothing in this repository establishes production readiness, security certification, government compliance, domestic processing, or government endorsement.
The roadmap now targets scoped preparation for ISO/IEC 27001:2022 with 27002:2022 guidance, AI management under 42001:2023 and applicable privacy management under 27701:2025. Repository/supply-chain work will assess OpenSSF OSPS Baseline v2026.08.28, Best Practices passing criteria, dated Scorecard findings and SLSA v1.2 artifact provenance. These are planning targets, not achieved certification, badge, score or build level. Organizational controls, verified hosted settings, real human approval where required, vulnerability reporting and release attestations remain distinct from source tests and agent reviews. See the evidence/gap/owner matrix and next readiness packets.
Approval management, telemetry and dynamic operations visualization are core product scope. The shared flow is request → policy evaluation → required human/delegated-agent approval → scoped authorization → execution-time checks → execution → outcome evidence. Rangoon owns configuration, routing, visibility and evidence presentation; LNSAT and other qualified authority adapters enforce their actual contracts. Approval alone cannot bypass consumption-time checks.
Planned operations surfaces include scoped gateway/rule configuration, approval chains, mandatory human duties, explicitly bounded agent delegation, expiry/escalation/revocation/emergency suspension, an approval inbox, agent inventory and authority assignments. Agents cannot grant themselves broader authority. Telemetry must redact sensitive payloads and correlate request/attempt/trace IDs, exact policy versions, approvals, resource access, costs, latency, outcomes and failures. A live graph and timeline connect agents, workflows, tools, resources, gateways, approvers and engines, with filters, exact evidence drill-down and inert historical replay.
These are accepted product requirements, not implemented runtime features. Shared closed records, deterministic projections and adapter conformance precede activation. Per-operation coverage must distinguish unavailable, advisory, partially mediated and fully mediated paths; “universal” never means blanket enforcement. Live engine operation remains unavailable, workspace encryption does not authenticate telemetry, and these observations are not an authenticated audit log. See the operations control-plane contract for responsibility boundaries, state machines, privacy, failure handling and O1–O5 acceptance gates; exact source/runtime evidence belongs in the development ledger.
An optional curator may use a small local or explicitly consented advanced model to flag semantic risk, missing context and possible intent/action mismatch for human review. This is a planned advisory workflow, not an implemented LNSAT dependency. Deterministic rules, exact effect-time action binding, human approval where required and one-time consumption remain the authority path; model output never grants permission or proves an effect. The competitive verification plan separates machine-checked enforcement from AI-assisted usability review. The planned decision ledger keeps policy, model advice, human approval, authorization and observed effect as distinct events. O2's first selected-file view counts reported decisions without model advice or verified outcomes; broader analytics and O3 qualified live ingestion remain open. Model accuracy alone cannot authorize future model delegation.
rangoon-ops implements the first operations source stage. decode_window(&[u8]) returns an immutable DecodedWindow with canonical bytes, their SHA-256 digest and a read-only serializable inventory. Its input schema is rangoon.ops.window.v1; the inventory is rangoon.ops.inventory.v1. Snapshot metadata pins the reducer version, workspace/system/environment/engine scope, topology revision, policy/coverage revisions and per-producer prefix/watermark/fence inputs. A bounded tail retains subsequent events. Supplied prefixes are observations, not authenticated checkpoints.
The nineteen closed record kinds cover five connected concerns:
| Concern | Observation records |
|---|---|
| Systems and topology | Actor, resource, tool, workflow and engine |
| Configuration and delegated scope | Policy revision, gateway revision, assignment and delegation |
| Exact request and review | Request, immutable initial/successor evaluation, approval plan and approval decision |
| Reported execution lifecycle | Authorization, attempt and suspension |
| Visibility and provenance | Metric, evidence and per-operation coverage |
Every action/configuration event carries typed correlation selectors; only the five context-free inventory kinds may have null event correlation. Evaluation records retain the exact input/context snapshots and digests, expected effective predecessor and lineage fence. Decisions bind their evaluation, plan, stage, actor and delegation. Authorizations and attempts remain separate reported observations. Actor/delegation source verification, target-OS coverage and freshness are explicitly reported values. Neither reported_verified nor fully_mediated changes the decoder's fixed authority none, authenticity unverified, execution unavailable output.
The decoder rejects duplicate object keys (including equal values), unknown fields and variants, absent required nullable fields, malformed IDs/digests/tokens, unsafe integers and trailing content. Input and canonical windows are capped at 2 MiB each; structural limits are depth 32, 32,768 JSON values, 64 fields per object, 1,024 raw array entries, 32 distinct producers, 1,024 total events, 128 topology nodes, 512 edges and 32 entries in other lists. Explicit null costs and latency remain unknown rather than zero. Array order and string values are preserved; serialization normalizes object field order. All failures expose fixed codes without parser prose or input excerpts.
This foundation validates shape and resource bounds. It deliberately preserves duplicate event identities/sequences, broken references and contradictory lifecycle observations for O1b diagnostics. A content digest proves internal consistency only. Token syntax cannot detect disguised secrets: trusted future ingress must authenticate sources, mint application IDs and classify/redact external references before decoding. No telemetry collector, retention database, approval routing, grant issuance, connection or execution is introduced.
See the exact O1a records and decoding contract and development evidence. O1b is staged into the structural projection below and later semantic relationship assessment; a clean structural projection never certifies an approval trace.
rangoon-ops implements project_window(&DecodedWindow) as a pure read-only step over the immutable O1a window under the independently reviewed projection contract. It returns one timeline entry for every observation, including duplicates and conflicts, and a graph containing only declared topology. Exact input ordinals and prefix/tail locations address original records; graph and accessible table can share this result in O2 instead of implementing separate decision logic.
Replay identity binds the complete input digest, snapshot/reducer/scope, topology and policy/coverage pins, and sorted producer-prefix fences/watermarks. Timeline presentation sorts by producer, fence, sequence, event ID and input ordinal. Unknown/tied timestamps remain display data; they do not select authority or causal precedence. A late arrival creates a new exact input identity and leaves a previous projection unchanged.
Eighteen fixed structural diagnostics cover duplicate/contradictory identities, sequence gaps, missing/wrong/cross-fence predecessors, prefix fences/watermarks, scope and event-envelope disagreement, and missing/ambiguous declared graph references. Counts include every affected entry; observations never disappear to make a trace look clean. The output is bounded to 1 MiB using a capped writer; amplification beyond that cap fails atomically with projection_limit. Input remains intact, and no partial graph is returned.
This stage fixes authority none, authenticity unverified, execution unavailable, semantic assessment unavailable, authoritative eligibility unknown, and authoritative effective evaluation null. Its structural_unverified, incomplete and conflict states cover only the named structural checks. Reported full coverage, delegated identity verification, issued authorization or completed execution cannot change those trust fields.
Structural v1 remains frozen. The separate relationship schema below assesses reported links without changing those bytes or trust fields.
relate_window(&DecodedWindow) first projects the exact immutable window, then returns a separate rangoon.ops.relationships.v1 document under the relationship contract. It retains one link row per event and all matching observation ordinals for referenced records. Closed reference checks distinguish absent, ambiguous, wrong-kind and byte-identical repeated records. Flow binding compares workspace, system, environment, engine, request, trace and policy revision; each step keeps its own span ID.
Reported evaluation chains require one root, exact previous/expected selectors, a single successor at each step, matching declared lineage fences and producer streams, and increasing stream sequences. Missing history, branches, cycles, identity conflict, scope/envelope mismatch or inconsistent request/gateway/context pins produce unknown_or_conflict with null tip and result. Timestamps never select a winner. Late approvals bound to an older evaluation remain historical; they do not migrate to the successor or override a reported deny.
Plan/decision/authorization links check exact evaluation, plan and stage bindings. This stage does not establish approver eligibility, satisfy human duties, authenticate delegation, assess quorum/expiry/revocation/suspension, consume authorization or reconcile effects. Its reported chain tip is an unverified observation selector. Authoritative eligibility remains unknown, authoritative effective evaluation remains null, and authority/authenticity/execution remain none/unverified/unavailable.
The separate output is capped at 1 MiB, with at most 8,192 reference rows and 8,192 combined matching ordinals across references and chain requests. Work budgets are checked before adding rows or copies; cap failures return fixed, payload-free errors atomically. Structural projection overflow maps to relationship_structural_limit; relationship work or output overflow maps to relationship_limit. No partial output or hidden dropped observations are returned.
O1b-2b is staged into the reported identity/delegation inspection below (2b1), human/stage/quorum/decision duties (2b2), and lifecycle/outcome/coverage assessment (2b3). Current expiry, revocation, suspension and execution eligibility require later qualified authority work. O2 builds real read-only operations routes; O3 qualifies ingress/privacy/retention; O4 qualifies one complete approval/authorization/consumption/evidence path; O5 expands adapters and hosted operation. These source stages supply no live collector, approval router, authority engine, execution service or authenticated audit log. Full O1b, O1 and V1 remain incomplete.
inspect_delegations(&DecodedWindow) uses the exact immutable window and its structural projection to produce a separate rangoon.ops.delegations.v1 document under the delegation inspection contract. Subject groups use the reported (systemId, canonicalSubjectId) tuple: aliases within one system share diagnostics; identical subject IDs from different systems remain separate. Every actor occurrence, conflicting record variant and unassessed event remains inspectable. This does not authenticate identity or infer aliases from names or external references.
Explicit delegation links inspect uniquely resolved actors, finite environment/operation/resource/policy scope sets, parent subject binding and reported expiry attenuation. Alias-aware checks flag a delegate granting to itself or changing its own delegation even when different actor IDs report the same subject. Missing or conflicting actor references retain null resolved tuples and their diagnostics; null comparisons never become proof of self-delegation or a parent mismatch. Empty scope dimensions are incomplete, never wildcards. Reported expiry values are compared only against declared parents, without a clock or current-validity claim.
An iterative leaf-to-root path retains missing, ambiguous and wrong-kind parent IDs, closing cycle IDs and ancestor diagnostics. All byte-identical observations contribute diagnostics, so a clean repeat cannot hide a tainted observation. Independent grants, assignments and gateway admission are outside these explicit parent checks. Parent links never admit subdelegation. The separate reported stage/quorum/decision inspector follows below. Authenticated approver eligibility, current expiry/revocation/suspension, outcome reconciliation and operation-specific enforcement coverage remain subsequent qualification work.
The immutable output fixes authority none, authenticity unverified, execution unavailable, authoritative eligibility unknown, authoritative effective evaluation null, and subdelegation admission unavailable. Assessments are linked_unverified, incomplete, conflict or not_assessed; reported active/verified/current labels cannot promote them. Output is limited to 1 MiB with independent 8,192-reference, 8,192-matching-ordinal and 8,192-ancestry-step budgets checked before growth. A path ID counts once, including the own ID and closing/dangling step. Each record observation is compared with its ID’s first typed record once; reference and ancestry lookups use an invocation-local resolution index, avoiding repeated byte scans. The index is discarded before return. Overflow fails atomically with a fixed payload-free diagnostic. Existing structural and relationship v1 schemas remain unchanged. Exact source, fixture, independent review and publication evidence belongs in the development ledger; no live operations or authenticated delegation capability is established by this source stage.
inspect_approvals(&DecodedWindow) derives a separate immutable rangoon.ops.approvals.v1 document from the same exact input, structural projection, relationship inspection and delegation inspection. Their canonical digests bind the output to those specific upstream observations. This is a portable source API under the approval inspection contract, not an approval inbox service or an authorization engine.
Every input event remains in observation order. Each plan retains all declared stages, approver and escalation references, dependency edges and repeated matching indices. Actor aliases use the reported system-scoped canonical subject tuple and count once; contradictory roles, unresolved identities and foreign-system requester identities remain diagnostic. Escalation destinations never become normal approvers. Stage modes inspect all or a positive bounded quorum; missing cardinality stays null. Human-required gateways must declare a human-required stage. An observed human ballot is reported data, not proof of an authenticated review.
Decisions pin their exact plan, evaluation, stage and flow context. Agent ballots inspect the explicit reported delegation, delegate identity, finite request scope and parent diagnostics; agents cannot hide self-expansion by choosing another actor alias. Approval by a requester alias is flagged. Initial decisions have null supersedesDecisionId; successors name an exact prior decision for the same subject and duty. Competing roots/successors, cycles, missing links, conflicting observations or producer/fence/sequence mismatches leave the reported chain tip null. A valid reported tip preserves approve, deny or abstain, and historical ballots never migrate to a successor evaluation.
Inspectable stages summarize distinct reported approval, denial and abstention subjects, including reported human/agent approvals. Invalid identities, links or bindings make counts unknown; interpretable shortfalls retain their numeric observations. Iterative dependency inspection preserves declaration order, forwards predecessor diagnostics, flags missing/ambiguous stages and cycles, and reports dependency shortfalls. Header/declaration checks, decision lineage, local ballots, dependency propagation and final plan summaries run in noncircular phases. Final summaries cannot manufacture or erase an earlier decision tip. Denied or unknown policy evaluations are never promoted by votes.
Every checked auxiliary requester, gateway, resource and delegate reference is emitted with its status and matching observation ordinals. All identical copies contribute stream taint and diagnostics. Graph-only noise does not become an identity failure. Output fixes authority none, authenticity unverified, execution unavailable, authoritative eligibility unknown, effective evaluation null, and authoritative duty satisfaction unknown. Numeric ballots do not establish eligible approvers, current grant validity or permission to execute. Approval alone never bypasses execution-time enforcement.
The output is limited to 1 MiB, 1,024 emitted stage rows, and independent 8,192-reference, 8,192-matching-ordinal/index and 8,192-logical-walk-step budgets. Counters are checked before growth; duplicate references and diamond/cycle/dangling visits count, and overflow returns a fixed payload-free error atomically. Upstream structural, relationship and delegation limit failures remain distinguishable. The invocation-local resolution index compares record observations once and is discarded before return. Earlier schemas remain unchanged. Exact fixture, source, independent review and publication receipts belong in the development ledger.
The final O1b source stage inspects reported lifecycle, outcome and coverage observations below. Real read-only operations routes (O2), qualified redacted ingress/privacy/retention (O3), a complete approval/authorization/execution/evidence path (O4), and adapter/hosted expansion (O5) remain open. No live collector, routing, human authentication, agent grant admission or execution is established by these inspectors; O1 and V1 remain incomplete.
inspect_lifecycle(&DecodedWindow) is a pure read-only source API under the lifecycle contract. Its separate rangoon.ops.lifecycle.v1 document binds the exact decoded input and preceding structural, relationship, delegation and approval inspections by canonical digest. One event row retains each of the nineteen record kinds in input order. Authorization, attempt, suspension, metric, evidence and coverage rows expose reported states, exact reference status and diagnostics; all other kinds remain visible as not_assessed.
Authorization, attempt and suspension chains retain duplicates, broken predecessors, changed bindings, stream/sequence conflicts and unknown effects instead of selecting a convenient winner. A metric's attemptId matches an attempt chain, not an attempt record ID. Coverage rows preserve eight reported checks, target OS, freshness and evidence references. Stale, expired, missing and contradictory reports stay explicit. Neither reported_completed nor fully_mediated proves an effect or enforcement. The output fixes authority none, authenticity unverified, execution unavailable, authoritative eligibility/outcome unknown and qualified coverage unknown; it cannot grant execution.
Inspection has a 1 MiB output ceiling and separate 8,192-reference, matching-ordinal and predecessor-walk budgets. Limit failures return fixed errors without a partial document or source excerpt. Exact source validation and review belong in the development ledger. O2's first route presents minimized local observations; fuller provenance/gap drill-down remains open. O3 must authenticate and minimize ingress before any live operator claim. Rangoon remains useful without a provider, LNSAT or OpenShell.
The desktop workbench now has an Operations window route. Its native command opens a parented picker only after the operator chooses a local JSON file. A dedicated host reader bounds that file at 2 MiB, refuses nonregular files and final-component links, and passes the exact bytes through all five O1 inspectors. Rust constructs a separate rangoon.ops.operator-view.v1 allowlist before IPC. It exposes display ordinals, closed reported values, diagnostics and reference status, but not original IDs, source text, paths, digests, external references or free-form errors. The native operation holds a read-only selection lease; Clear or Managed close discards stale picker/read results and the renderer purges the retained view. The route remains memory-only, participates in Managed close/purge and does not persist a telemetry history.
The screen keeps a record library, filtered observation timeline, declared-topology outline and selected-item inspector. A compact count strip leads to those working panels; a closed Reported decisions disclosure holds the detailed breakdown. Empty-window, filter-no-match and fixed recovery messages are distinct. Its truth labels stay authority: none, authenticity: unverified, eligibility: unknown, execution: unavailable, outcome: unknown and coverage: unknown. Offline decision analytics count reported evaluation, approval-decision, authorization and attempt values in separate groups, each with its own observed-record denominator. A zero count means no matching record in the selected file; it says nothing about total system activity. O1 has no model-advice record, authenticated producer, confirmed human identity or independently observed effect, so model accuracy, real approval, enforcement and outcome rates cannot be inferred. A future advisory record and O3 authenticated, redacted, encrypted ingress are required before live model decision history or analytics.
This is a local source implementation and browser-reviewed interface, not an authenticated audit log or qualified native release on macOS, Windows and Linux. See the O2 local-window contract and development evidence.
Rangoon and LNSAT are separate products. Local capability authoring, source provenance, Decompose/Merge/Split, revisions, instruction compilation, export and inspection must work without an external provider installed, configured or running. LNSAT is optional; its existing A1 diagnostic placeholder remains unchanged. Provider allow decisions, guardrail results, local content reviews, approvals and actual execution outcomes retain distinct provenance. None silently grants permission to execute.
The accepted direction and candidate/functionality matrix, small neutral contract and first packet evaluate agentgateway, Cerbos, Permit authorization, Permit FastMCP middleware, Permit's commercial MCP Gateway, Invariant local/remote evaluation and LNSAT. These are candidates, not current support. The first offline core is source-implemented in rangoon-integrations: a pure unavailable candidate inventory and bounded synthetic evidence inspector, with independent conformance fixtures. It preserves reported decisions, reviews, approvals and outcomes without granting authority, fixes authenticity to unverified and execution to unavailable, and has no provider SDK, network or credential path. Named conformance, workspace regression and independent source-review evidence are recorded in the development ledger; it is not a native integration or release-support claim. A later Cerbos PDP read-only decision adapter is recommended only after version/transport/privacy qualification.
OpenShell and LNSAT are separate optional Rangoon connector targets: OpenShell owns its native gateway/sandbox policy and observations; LNSAT owns its separate action-authorization and receipt path. Neither runs under the other in Rangoon's active plan, and neither is required for local authoring. The current OpenShell descriptor and continuity inspector are offline combined-path research, not native OpenShell compatibility. Earlier LNSAT-owned middleware research is historical. Separate read-only connectors, native capability mapping, consent, direct-path coverage and effect evidence remain unimplemented; no live adapter exists.
Keep the all-three-desktop local release path. Broad integration coverage and live LNSAT are not release prerequisites. Optional operations must show honest unavailable/unsupported/disconnected/error states, with explicit consent for external checks, evaluations and evidence retrieval. Existing persistence, composition, compilation, bundle export and inspection stay intact; platform, recovery, packaging, licensing and release gates remain required.
The planned support commitment is qualified governance workflows with LNSAT and capability-specific integrations with other providers, with explicit functions, enforcement coverage and limitations. Common ownership of Rangoon and LNSAT supports an end-to-end qualification path; it is not a guarantee from ownership alone. No live Rangoon adapter, including LNSAT, is currently qualified. Future support rows pin the product, adapter, protocol, operation, deployment environment, limits and dated evidence. Provider changes must expose lost controls and block governed actions when mandatory requirements are unmet.
The interface direction separates function availability, enforcement coverage and control-assessment evidence. For coverage, green means fully mediated for the qualified path; for control assessment, green means a met control within its named assessed scope. Amber means partial; blue means advisory coverage; gray identifies unavailable/unsupported/unqualified/unknown/stale status; red identifies a separate known blocked/failed action or unmet control. Text, symbols and accessible reasons accompany colors. Unsupported actions remain visible with disabled controls and an accessible Details action. A green badge is never permission to execute or security/compliance certification. Catalog functions remain unavailable; I1e below projects these fixed states. Qualified live badges, host dispatch guards and actual assessment evidence remain unimplemented.
Middleware and adapters are planned plugin forms through the existing typed ports and R9 descriptor, with explicit operations, data/egress scopes, credential references, side effects and limits. Declarative configuration is inert. Server middleware and executable workers require separately qualified identity/host isolation, permissions and update/revocation handling; third-party code does not run in the renderer. Installing a plugin never grants authority. No runtime loader, public SDK or registry is currently supported; SDK/registry work remains gated by two real adapters. See scoped commitments and plugin boundaries, coverage/control evidence meanings, the standards-readiness track and canonical validation ledger.
The module workspace puts search, compact module cards and the detail inspector first. LNSAT appears first with a neutral Recommended label; selecting it remains explicit. A five-segment function meter summarizes the existing local projection. Function details, evidence meanings and module metadata use native disclosures. Role planning and provider comparison remain available below the workbench, with their existing local interactions. This layout packet reduces repeated explanatory text while preserving the original grouped shell and every operation/diagnostic. The current receipt records implementation and rendered validation status.
All eight candidates still have zero of five adapter functions available. The unchanged immutable helper rejects forged IDs/states and fixes authority to none, execution to unavailable and network attempted to false. Exact reasons and disabled controls remain in Function details; coverage and control assessment remain separately labeled in Evidence meanings. The meter reports listed Rangoon adapter functions, not provider breadth or a security score. Actual setup defaults, qualified workflow requirements, runtime evidence, providers and plugin loading remain separate development tracks. LNSAT is the recommended optional governance target; local authoring works without any provider. See meter/default semantics and the unchanged I1e contract.
The shared workbench includes analyze.html#authority-engines: an implemented local directory for eight optional product targets, with search, category filters, a detail inspector and the locally bundled LNSAT mark. Every entry has a stable catalog ID and links to related application screens. A contextual route such as #authority-engines/lnsat/from/workflows retains the originating screen and provides an exact return link. IDs describe built-in catalog entries; they are not authenticated provider instances, saved workflow assignments or runtime trace IDs.
The immutable rangoon.authority-catalog.v1 metadata mirrors I1's inventory and five operations: configuration preview, connection check, evidence read, authorization evaluation and guardrail evaluation. All operations remain unavailable with adapter_not_implemented; observed version is null, compatibility/connection/runtime are unknown, authority is none and network attempted is false. Researched abilities remain visibly separate from implemented adapter support. Permit authorization, FastMCP middleware and the commercial MCP Gateway are separate targets; Invariant local and remote preserve different privacy requirements.
A separate plain-language comparison list covers all eight targets, with consistent purpose, permission scope, control placement, approval meaning, evidence, privacy, hypothetical example and limitations. Expand several rows to compare them without changing selection; catalog filters apply only to the library. A glossary explains permission, approval, enforcement, guardrails and evidence. Provider references are dated research checked October 9, 2026, not observed or pinned product versions. No checkmark ranking implies interchangeable enforcement. Gateway session consent is distinct from per-action approval, a PDP decision requires caller enforcement, and guardrail success grants no permission. See the comparison contract.
The authority page also includes an ephemeral role planner: drag built-in targets into Gateway, Access decision, Server middleware, Behavior guardrail and Action authority roles, or use the equivalent Add controls. More/right-click menus perform local add, confirmed replacement, removal, pair comparison and origin-aware inspection. Relationship inspection distinguishes documented Permit dependencies, possible same-role alternatives requiring migration, overlapping checkpoints, conceptual complementary responsibilities and unassessed pairs. No pair is a proven drop-in replacement or qualified Rangoon integration. Planned relationships are not execution wiring. The plan clears when the page is remounted/reloaded; catalog filtering and selection preserve it while mounted. Connection checks remain unavailable because adapters are missing. See the local arrangement contract.
Catalog controls perform local filtering and navigation. Fixed cards and unchanged controls/inspectors are reused between updates; existing startup inventory reads remain intact, and the catalog adds no native calls or provider requests. Core authoring needs no engine. Future instance bindings, consented transport and correlated runtime evidence require their own contracts. See the catalog contract and validation ledger.
Rangoon is the user-facing product. LNSAT remains an independent authority and evidence engine. A future model provider can propose content; LNSAT qualification governs a different concern: whether an exact consequential operation is permitted and what evidence establishes its outcome. Neither role is implemented by changing a UI status badge.
The current GovernancePort has five closed operations:
| Operation | Intended future role | Current result |
|---|---|---|
negotiate_contract |
Verify exact peer contract and supported surface | Unavailable |
inspect_configuration |
Read authorized diagnostic configuration | Unavailable |
read_evidence |
Retrieve exact authorized evidence | Unavailable |
submit_operation |
Submit a governed operation | Unavailable |
reconcile_operation |
Resolve an uncertain prior effect | Unavailable |
The placeholder performs no discovery, launch, filesystem access, network transport, credential handling, mutation, or execution. Status reports placeholder, not_attempted, not_checked, null installed/observed versions, and no authority. engine status exits 0 for successful local diagnostics; engine check returns unavailable and exits 4.
The integration specification records an immutable public LNSAT research reference. Its source version, wire contract, product surface, storage schema, and eventual release support are distinct dimensions. A wire label containing v1_0 does not establish a supported LNSAT product 1.0. Rangoon never opens the LNSAT database. The model-assistance core is separate and advisory: it cannot authorize transport, execution, review, or mutation.
Adapter work requires a supported artifact, exact typed request/result contracts, peer authentication, secret custody, compatibility tests, and explicit unknown-outcome handling. Read-only evidence qualification precedes consequential operations. Lost responses must not cause blind write retries.
- Node.js 20+ for the local preview and Node tests; no npm dependency installation is required.
- Rust 1.99.1 for both the edition-2024 core and separate desktop workspaces, pinned in
rust-toolchain.tomland both Cargo manifests. This aligns the compiler floor with VUSL; it does not add or qualify a VUSL consumer dependency. - Host-native prerequisites for the separate desktop workspace: Xcode command-line tools on macOS, Microsoft C++ tools/WebView2 on Windows, or the documented WebKitGTK dependencies on Linux. See desktop setup.
git clone https://github.com/hypler-dev/rangoon.git
cd rangoonnpm startOpen http://127.0.0.1:4377. The splash preview is /splash.html, and the icon specimen is /icon-gallery.html. The normal browser cannot call the native bridge. Reloading resets the sample workspace; theme preference may remain locally. Synthetic controls do not operate real providers, deployments, or approvals.
cargo run --locked -p rangoon-cli -- --help
cargo run --locked -p rangoon-cli -- analyze --name AGENTS.md < fixtures/contracts/AGENTS.md
cargo run --locked -p rangoon-cli -- engine status
cargo run --locked -p rangoon-cli -- engine check --operation read_evidenceThe last command deliberately exits 4. The analyzer writes JSON to stdout; invalid input/usage exits 2 with fixed JSON errors on stderr; I/O/serialization failures exit 3. A successful report includes original text.
On Windows, use binary-preserving Command Prompt redirection with fixtures\contracts\AGENTS.md. Text-mode PowerShell pipelines may change encoding/newlines before the CLI receives them. Hashes describe bytes actually supplied. The CLI has no composition, workspace-management or execution subcommand.
The export-handoff packet adds two stdin-only commands around the existing strict bundle verifier. They inspect a native-exported container or recover its exact instruction bytes; they never open a workspace, choose a destination, write a project or launch an agent. Named source acceptance is recorded in the development ledger.
cargo build --locked -p rangoon-cli
./target/debug/rangoon bundle inspect < exported.rangoon-instructions
./target/debug/rangoon bundle artifact < exported.rangoon-instructionsinspect prints JSON including instruction content, profile, identities and the unchanged qualification warnings. artifact prints only exact instruction bytes to stdout, preserving BOM, CRLF/LF, Unicode and final-newline state; stderr carries a fixed plaintext/internal-consistency/no-authority notice. It validates the entire bounded bundle before emitting stdout. Invalid or over-limit input exits 2 without stdout; I/O failures exit 3 and may leave partial output. Shell redirection can truncate a destination before Rangoon runs, so these examples deliberately do not write active AGENTS.md/CLAUDE.md files. Use a separate explicit inspection and installation decision. On Windows, use target\debug\rangoon.exe from Command Prompt for binary-preserving redirection.
This closes bundle-to-text handoff. It does not establish actual Codex/Claude loading, semantic equivalence, authentication or execution permission. Both frozen v1 profiles remain runtime-untested; desktop one-click target-file export and real target-loader qualification remain open.
The CLI handoff receipt records exact recovery from both previously exported, controller-authored native QA bundles after rechecking their original hashes. This is a local macOS CLI check with synthetic content, not a new GUI run or target-loader test.
The next-phase target-loader investigation records installed Codex/Claude executable identities and documented discovery behavior separately from runtime evidence. Codex has a documented experimental prompt-inspection candidate, but its startup/authentication/configuration isolation has not been qualified; no comparable safe standalone Claude loader path was verified. Neither product was invoked by this investigation. Both profiles remain runtime-untested, and unrelated local authoring workflows can continue while target compatibility claims remain gated. The next user-facing increment is attributed model-proposal inspection, explicit draft saving and restart recovery; it must preserve proposal provenance rather than silently turn model text into an ordinary unattributed skill revision.
cargo +1.99.1 run --manifest-path apps/desktop/Cargo.toml --lockedChoose fixtures/contracts/AGENTS.md for a first run. Inspect the report, explicitly save it, derive a skill from a section, edit/review a revision, then quit and reopen saved data. Open Decompose to work from a saved source, Merge to combine two saved skill revisions, or Split to divide one saved revision. Inspect the exact native preview before acknowledging and saving. Backup and restore controls are in Workspace. Installer bundling is disabled; this command runs a development executable.
For pinned source validation, provision Rust 1.99.1 with rustfmt and Clippy, then run node scripts/check-source-rust.mjs for core or add --desktop for the native workspace. The script reads the root toolchain pin, requires both Cargo floors and any CI version to match, pins compiler/documentation executables and subprocess PATH, and verifies all seven tool identities (rustc, rustdoc, Cargo, rustfmt, cargo-fmt, cargo-clippy and clippy-driver) before formatting, tests and warnings-denied Clippy; the desktop plan also builds its executable without installers. --check-config checks version coherence without starting compiler tools. An already provisioned isolated compiler can be selected with --toolchain-bin /absolute/path/to/bin; missing tools fail without installation. Compiler-wrapper overrides are rejected and file-configured wrappers are disabled only for child processes. CARGO_TARGET_DIR may select an isolated build cache. Historical 1.85/1.98 receipts remain evidence for their original bytes and compilers, not validation of this new pin.
| Evidence | What it establishes | What it does not establish |
|---|---|---|
| Core tests and independent vectors | Contract, identity, transformation, storage, and recovery behavior under tested conditions | Native interaction, production readiness, or adversarial certification |
| Node controller/view tests | State transitions, closed DTO handling, escaped rendering, and synthetic interactions | Real native IPC or OS picker behavior |
| Rendered browser QA | Layout, theme, focus, and interaction behavior for recorded states | Native persistence or engine integration |
| Native source/tests/build | Host code compiles and tested helper paths pass on an identified runner | Clean-host GUI, installation, signing, updates, or released support |
| macOS development-bundle QA | Named real picker, persistence, skill, and data-control flows on the recorded build | Windows/Linux GUI parity or complete desktop qualification |
| Release qualification | Future clean-host install/use/update/rollback evidence for exact artifacts | Any broader certification without its own assessment |
The current workflow runs Rust checks on Ubuntu 24.04, Windows 2022, and macOS 14; frontend checks on Ubuntu; and native format/tests/Clippy/build on all three OS runners. It builds executables without publishing installers. Windows/Linux interactive qualification remains pending.
The vision build rule keeps the original eight screens as the structural baseline while requiring technical evidence for each feature. npm run build:check runs syntax, asset integrity, vision contracts, and the complete Node behavioral suite. Implemented surfaces must name native/core source separately from their UI; sample-only and unavailable surfaces keep explicit next technical outcomes. Visual-only work cannot count as capability completion. Rendered dark/light review at 320/768/1440 and fresh independent review complement these narrow source checks.
npm run build:check
node scripts/validate-review.mjs
node scripts/check-source-rust.mjs
cargo +1.99.1 fmt --manifest-path apps/desktop/Cargo.toml -- --check
cargo +1.99.1 test --manifest-path apps/desktop/Cargo.toml --locked
cargo +1.99.1 clippy --manifest-path apps/desktop/Cargo.toml --all-targets --locked -- -D warnings
cargo +1.99.1 build --manifest-path apps/desktop/Cargo.toml --locked
git diff --checkCurrent counts and exact run receipts belong in development.md, rather than a permanently fixed test-count badge. A passing adjacent stage does not close an untested release gate.
The accepted intent, detailed plan, product experience contract, and application architecture guide delivery. The milestones below describe intended outcomes and acceptance gates, not fixed dates or a declaration that version 1.0 is complete.
Current delivery priority: prove the useful local loop before expanding disconnected infrastructure: import → inspect/reorganize with provenance → review exact changes → export → verify target behavior. The accepted priority and sequence starts with portable bundle-to-text handoff, then separately scoped two-target loader qualification and attributed model-proposal application. Compare representative projects against manual editing and existing instruction-distribution tools before claiming differentiation or token savings. Approval, telemetry and live visualization remain core staged scope; all three desktop OSs remain the initial release target.
Foundation present: deterministic core, new/append destination semantics, atomic storage, versioned recovery, native preview/commit, and interactive editor routes with initial macOS save/restart evidence.
Deliver: complete qualification and refine the Decompose, Merge, and Split experience across saved-input selection, historical revision pinning, source/recipe/graph views, output destinations, before/after inspection, explicit coverage actions, conflict declarations, and actual saved-result navigation.
Acceptance: exact BOM/CRLF/Unicode preservation; no silently omitted spans; stale heads and workspace changes invalidate acknowledgment; failure preserves the draft; all output destinations commit together; restart/reopen works; dark/light, keyboard, reduced motion, and narrow layouts remain usable. Complete native GUI evidence on all three target OSs before declaring that milestone qualified everywhere.
Foundation present: bounded SQLite, schema 1/2/3 validation, transaction/recovery tests, V1/V2 backup handling, additive restore, and dependency-aware logical deletion.
Deliver: select and implement the reviewed encryption/key-custody design, authenticated history, explicit recovery UX, retention controls, and a documented schema/backup compatibility matrix.
Acceptance: demonstrate key-loss and backup recovery, corruption response, stale/rollback limits, interrupted migration/rotation, disk-full behavior, and no silent plaintext downgrade. Preserve legacy data through an explicit verified migration. Treat secure deletion and compromised-host resistance as bounded claims.
Foundation present: pure agents_md_v1 and claude_md_v1 text-format profiles, exact stored-revision selection, static compatibility diagnostics, deterministic candidate manifests, a pure exact-byte bundle encoder/strict verifier, bounded selected-file host helpers, and native Export/Inspect UI/IPC implemented in this source. Native GUI qualification and actual target-loader qualification are not complete.
Deliver: a shared capability representation plus at least two explicitly supported harness/format adapters. Choose initial targets from actual user projects and maintain a per-version support matrix.
Each adapter declares accepted input fields, target syntax, preserved semantics, unsupported fields, loss diagnostics, and required permissions. Export plans show destinations and exact changes before writing. Bundle identity includes source/revision digests, transformation and adapter versions, diagnostics, and test results.
Acceptance: independent golden/negative fixtures; deterministic repeat exports; no silent constraint loss; confined output paths; explicit handling of generated versus user-owned files; reproducible compatibility reports. A familiar provider logo is not compatibility evidence.
Foundation present: pure typed workflow definitions, deterministic structural validation, immutable revision candidates and the complete durable Rust storage/recovery lifecycle. Native workflow authoring custody/commands, the real library/canvas/inspector source and complete v2 Data inventory/recovery are implemented. Native workflow save/restart/history/failure and three-OS GUI qualification remain open. The separate workflow design preview is synthetic.
Deliver: user-facing static validation, fixture simulations, reusable agent definitions, and workflow graphs with typed inputs/outputs, dependencies, retries, timeouts, cancellation, and evidence links. Templates and a registry build on versioned records and dependency closure.
Keep pure validation and simulated steps distinct from provider or connector runs. Separate a workflow definition from a run record. Runs need durable states for queued, running, waiting for review, completed, failed, cancelled, and unknown effect; failure and unknown effect must not be conflated.
Acceptance: deterministic fixtures where applicable; observable state transitions; recoverable interruptions; bounded retries; no automatic retry of an uncertain consequential effect; meaningful comparison against expected results. Real execution requires its own qualified runner and authority path.
Deliver: an exact, versioned LNSAT adapter beginning with contract/identity checks and read-only evidence, followed by one disposable governed operation with a complete consequence receipt. Add connectors individually with scoped permissions and declared effect classes.
A connector transports requests; it does not become the source of authority. An authenticated credential proves access only within its actual scope. Approval must bind the exact operation, resources, constraints, and expiry where required by the qualified engine contract.
Acceptance: compatibility failures remain explicit; authentication and authorization are independently tested; replay, expiry, revocation, cancellation, lost responses, and reconciliation have evidence; UI activity is not mislabeled as authoritative audit evidence. LNSAT 1.0 arrival triggers qualification, not automatic activation.
M1a is the pure context-pack and advisory-response core described above. Remaining gates stay separate from that implementation and require their own evidence:
- M1b: the source-only
rangoon-model-locallibrary provides immutable connection profiles, a bounded numeric-loopback adapter, source-free connection check, cancellation/timeout/size handling, no startup traffic, and no automatic provider fallback. The separaterangoon-model-sessioncrate provides portable session-only profile/request custody, exact saved-ID resolution, protected full-record packing, single-use handles, generation/cancellation/RAII leases, and freshness helpers. The native host now wires the actual#model-assistanceworkbench, seven main commands, three isolated review commands, exact-payload consent, narrow IPC, cancellation and freshness checks. Isolated macOS synthetic QA passed the named prepare/GET/POST/cancel/inert-response cases recorded in development.md. Native cloud integration is source-implemented; three-OS credential custody qualification, proposal application, tokenizer/quality qualification, real compatibility and Windows/Linux GUI remain open. M1b is incomplete. - M1c: native credential management is implemented under the cloud custody contract. Fixed OpenAI-slot inspect, add/replace and remove commands use explicit OS stores and native Save/Remove decisions. The portable fixed-origin cloud adapter is implemented and tested with synthetic TLS fixtures; cloud session custody adds saved-ID resolution and single-use request ownership. Native exact-request/credential consent integration is source-implemented. Real-provider compatibility and all-three-OS runtime qualification remain open; M1c is incomplete.
- M1d: native payload review and pure attributed proposal inspection exist. Complete native result retention/comparison, durable provenance, stale/error/partial states, accessible controls, and explicit draft application. Proposals remain advisory and inert until existing local review rules accept a change.
- M1e: task-quality and packing qualification on public or synthetic fixtures, with stated tokenizer/accounting assumptions, coverage and correctness measurements, latency/input/output measurements, regression limits, and honest failures. This gate does not follow from the M1a byte counters.
Deliver: verified attribution/contribution/dependency notices, reproducible builds, documented minimum OS/architecture requirements, packaged artifacts, signing strategy, updates, backup compatibility, and rollback procedures for macOS, Windows, and Linux in the initial release.
Acceptance: clean-host install/launch/select/save/reopen/edit/review/compose/backup/restore/delete/update/uninstall checks; platform accessibility and keyboard evidence; artifact hashes; retained failure receipts; explicit limitations. Core portability and native CI are prerequisites, not substitutes for this release matrix.
Deliver: an owner-hosted service sharing domain contracts, followed by separately qualified managed hosting. Introduce authenticated actors, workspace/tenant isolation, role boundaries, collaboration, durable jobs, quotas, migrations, operational monitoring, and recovery procedures.
Enterprise candidates include SSO/SCIM, managed retention, audit export, fleet configuration, private registries, deployment policy, and support. Core content portability should not depend on a proprietary hosted account; final licensing and commercial packaging remain decisions to make explicitly.
Acceptance: isolation and authorization tests across every API/job/storage boundary; load and recovery evidence; tested backup/restore and disaster recovery; clear data residency, egress, deletion, and outage behavior. Tenant administration, subscription entitlement, and execution authority remain separate concepts.
Deliver: a versioned adapter SDK with manifests, schemas, fixtures, and compatibility tests. Consider MCP for tool/resource interoperability, A2A where cross-agent communication is required, OpenAPI for service contracts, and OpenTelemetry for operational observability only when the corresponding feature and privacy review justify adoption.
Pin supported protocol versions and negotiate capabilities explicitly. Unknown extensions must not silently grant permissions. Redact or omit source bodies, prompts, secrets, and customer data from telemetry by default. Standards support needs a named conformance matrix and tests; listing a standard is not an implementation claim.
Deliver: a reproducible evaluation plan and claim-to-evidence register aligned to a specific funding solicitation when selected. The current government-grant work is research preparation; eligibility, registrations, application submission, and compliance remain separate work.
Measure preservation of source constraints across transformations/adapters, provenance completeness, reviewer task completion, recovery under interruption, interoperability limits, and resistance to bypass in specifically qualified authority paths. Record baselines, datasets, methodology, negative results, and reproducible artifacts. Avoid invented compliance percentages or unsupported claims of universal safety.
Rangoon's original source and documentation use Apache License 2.0, with attribution in NOTICE. The license permits use, modification and redistribution, including commercial use. Redistributors must provide the license, retain applicable notices and mark modified files; distributed derivatives must carry applicable NOTICE attribution. The license includes a bounded contributor patent grant and its stated termination provisions, and does not grant trademark rights beyond its stated exceptions. Third-party components and separately identified materials retain their own terms. See the official license for the authoritative conditions.
Hypler's intended consulting business complements the free community app: implementation and integration services, capability/workflow design, deployment assistance, training, custom development and paid maintenance/support. Customers may use or modify community code commercially without buying consulting. Paid services do not convert planned enforcement, certification, hosted operations or platform qualification into current capabilities. Consulting agreements, support commitments and any future separately licensed enterprise components need their own terms; adding restrictions to the Apache license is not the business model.
Contributor/DCO policy and complete dependency/distribution notices remain release work. License adoption does not complete installer, security or government qualification.
Use intent.md for accepted scope and development.md for exact implementation/publication evidence. Product designs and older packet records are supporting context; their original status labels may describe an earlier stage. Changes should name the controlling contract, preserve unrelated work, and include appropriate tests plus independent review.
Every push or merge to main must include a substantive update to this README that reflects the final delivered change and its limits. The controller verifies this in the reviewed publication diff under AGENTS.md; exact test and merge receipts remain in the development ledger.
Keep fixtures secret-free. Imported instruction text is data, including when it contains commands. Do not commit private project content, credentials, local databases, provider payloads, production records, or engine tokens. Preserve the distinction between synthetic UI, implemented source, observed native behavior, and released support.
| Document | Purpose |
|---|---|
| Intent | Accepted outcome, constraints, and authority |
| Development ledger | Exact tests, reviews, CI, commits, and publication receipts |
| Product experience | Image-derived behaviors and recovery expectations |
| Architecture | Module ownership and staged engine adoption |
| Plan | Broader product, platform, and delivery direction |
| Source analysis | Parser subset, input bounds, records, and identity framing |
| Local workspace | Snapshot storage, permissions, and initial schema |
| Reviewed capabilities | Immutable skill history and local review |
| Composition | Recipes, coverage, conflicts, and exact materialization |
| Destinations | New/append outputs, schema 3, and revision provenance |
| Recovery | Archive format, additive restore, and dependency deletion |
| Native composition | Raw IPC, retained previews, and confirmation semantics |
| Instruction compilation | Pinned format profiles, byte preservation, compatibility limits, candidate identities and bundle foundation |
| Instruction bundles | Exact portable format, strict verification and bounded host file boundary |
| Model assistance | Accepted local/cloud assistance contract, context packing, proposal validation and staged gates |
| Native Compile inspection | Exact-ID command, workbench states, stale report handling and qualification gates |
| Native bundle export and inspection | Export/Inspect commands/UI in this source, picker custody, receipts, uncertainty and external-file limits |
| Workspace controls | Original inventory, export, restore, and deletion experience |
| Native workflow authoring | Draft identity, exact candidate custody, historical reads and one-attempt save commands |
| Complete native controls | Explicit v2 inventory, workflow recovery/deletion, and single-attempt custody |
| Desktop setup | Native prerequisites and runtime qualification limits |
| Engine integration | Unavailable port and LNSAT qualification gates |
| Claims and evidence | LNSAT research snapshot and safe claim boundaries |
| Visual system | Icons, themes, motion, and asset rules |
| Preview gallery | Clearly labeled synthetic design captures |
| Funding research | Government funding research and evidence preparation |
The marketing website is maintained separately. This repository contains the Rangoon application under development.
The Model Assistance workbench provides explicit Inspect custody, Add/replace credential and Remove credential actions for one fixed OpenAI slot. It does not access credential storage at startup or during polling, test a key, contact OpenAI or send source implicitly. Explicit cloud actions use the app-owned service/account namespace, native full-envelope custody, fixed origin, review and final OS consent; provider compatibility and native GUI/release qualification remain open. The renderer cannot select arbitrary credentials, providers, origins or backends.
The desktop workspace pins keyring-core 1.0.0 with explicit macOS User Keychain, Windows Credential Manager (Local persistence), and Linux Secret Service adapters. An unavailable or locked store reports failure; there is no plaintext or session fallback. The stored binary envelope combines a version marker, random 32-byte revision and bounded credential. Inspection returns only a random revision reference and custody metadata, never a key, prefix or key hash. SQLite, workspace exports and instruction bundles contain no credential records.
New keys are typed into a separately scoped password-entry WebView. That isolated renderer necessarily holds new text transiently; the main workbench never receives it, and existing keys are never sent to the entry window. Native code validates bounded raw IPC and requires a final OS Save/Cancel decision. Save compares the slot with its native baseline, writes once and verifies exact readback. Removal similarly rechecks the selected envelope, requires OS consent and verifies absence. A changed slot is refused; uncertain writes require explicit inspection. No automatic retry or provider fallback exists.
Native secret buffers use zeroizing ownership, but JavaScript, IPC, OS and dependency allocations have no proven erasure guarantee. OS custody does not protect a compromised signed-in session or application process, attest a Linux store's at-rest configuration, encrypt Rangoon's SQLite workspace, or establish tamper resistance/certification. The OS read/compare/write sequence is not atomic against other processes. Synthetic macOS Keychain lifecycle evidence and native tests are recorded in the development ledger; Windows/Linux runtime custody and all-three-OS GUI qualification remain open. See the full custody contract.
rangoon-model-cloud is the portable transport foundation for the next native
cloud workflow. CloudProfile::parse accepts only a versioned profile ID, model
and output cap; the host, port, endpoint, authentication scheme and wire adapter
are fixed. PreparedRequest::new checks the context-pack target and binds exact
serialized body bytes to the profile, pack and OS credential revision. The body
uses one non-streaming Responses request with JSON output, no tools, no server
conversation, disabled truncation and store: false. JSON mode does not replace
Rangoon's closed proposal validation.
CloudClient::analyze requires explicitly supplied zeroizing credential material
matching that revision. It resolves only api.openai.com, rejects the documented
special-use address ranges, dials one validated address, and verifies TLS with
bundled WebPKI roots and a fixed server name before constructing Authorization.
It has no proxy/environment-key discovery, redirect following, retries, model
fallback, decompression or detached request driver. Bounds include a shared
10-second DNS/TCP/TLS deadline, 120-second total deadline, 256 KiB final body,
1 MiB response body, and one in-flight cloud operation per process.
Completed output must contain one assistant text message whose JSON validates
against the retained pack and its citations. Refusals, tool output, partial
responses, malformed usage, oversized data and duplicate JSON keys fail with
closed diagnostics. Locally bound receipts distinguish provider-reported model
and usage from unknown cost, region and retention. Cancellation can stop local
waiting and close the socket; it cannot recall a dispatched request or guarantee
no billing. store: false is not a Zero Data Retention claim.
CheckRequest::new and CloudClient::check provide an explicit authenticated
GET /v1/models/{model} with an empty body. The immutable request binds the
profile, credential revision, method/path and empty-body digest. It shares the
TLS and single-flight protections above, with a 30-second total deadline and
64 KiB response cap. Strict metadata decoding requires the requested model ID;
a successful receipt means model visibility only, not inference compatibility,
zero cost, local processing, or retention guarantees.
The portable cloud session reserves a resolution lease before native credential reads and rejects continuation after cancellation or profile changes. Native local and cloud operations hold a shared model gate through workspace callbacks and pending OS consent. Dropping an IPC waiter cancels retained work; OS dialog callbacks complete their own cleanup. Native cloud orchestration also holds credential-use custody through final envelope re-read and transport.
The portable library does not establish consent or OS freshness by itself; native source now supplies those checks. No existing keys, paid calls or private sources are used in source validation. Provider compatibility, native GUI (including an unresolved Keychain access prompt after a QA rebuild), all-three-OS GUI and release evidence remain open. See the adapter contract, credential custody and canonical development evidence.
The separate rangoon.integrations.lnsat-request-record.v1 source profile inspects one caller-supplied, bounded synthetic request record from the selected LNSAT source contract at 35a41963ad698934c7ee00852c71355e329c34fa. It distinguishes failed evaluation, unknown outcome, degraded evidence, generic read refusal and unavailable reads. Native completion remains a reported fact, not independently verified effect or execution authority. Requester identity and approval reasons are omitted; the separate summary contains fixed labels and counts, while host bytes retain sensitive correlation identifiers.
The existing D3a runtime-composition decoder and its f669181a source pin remain unchanged. Neither decoder performs a live read, opens credentials, persists evidence, reconciles an outcome or dispatches an action. The new profile is unmounted and does not replace O1/O2, VUSL or any provider contract. The implementation receipt owns exact source/test/review evidence and remaining gates. This source work is not installed-runtime, platform, release or support qualification.
The separate lnsat_request_inspection source slice places a pure host lifecycle around the request-record decoder. Its presentation boundary permits only the closed summary or fixed error envelope; raw bytes, complete selectors, host JSON, input digest and native correlation details stay host-side. One inspection is admitted at a time. Discard revokes delivery immediately and remains pending until the exact owned operation releases its data and the current presenter purge is acknowledged. Close is permanent; numeric generations never grant authority or wrap into renewed work.
This is a source/synthetic contract boundary, with no file picker, renderer/IPC, workspace mount or live provider read. A logical delivery lease and cooperative purge acknowledgment do not prove memory zeroization, native cleanup, authentication or physical erasure. Summaries are privacy-minimized, not anonymous or approved for persistence. D3a, the underlying request decoder, O1/O2 and provider independence remain unchanged. The source receipt records validation, independent review and later adoption gaps; it grants no reconciliation or execution authority.