Desktop App Foundation v1

Start offline. Prove every branch. Connect only by explicit choice.

The local foundation turns the existing Integration Studio handoff into a runnable loopback application without choosing a permanent desktop framework. It preserves the exact resolver contract, validates the first-party bootstrap before sending text, and records action authorization as a separate non-executing step.

Run from the extracted root package

One command launches the loopback app.

Use Python 3.10 or newer. The presentation shell and network client use only the Python standard library. The existing repository test suite may use its declared development dependencies, but no additional desktop framework is required for this foundation.

  1. 01
    Extract the root-deploy ZIP.

    Keep desktop_foundation.py, desktop_app/, integration_studio.py, integration_readiness.py, machine_agent_contract.py, and docs/ together.

  2. 02
    Launch locally.

    The server rejects non-loopback binds and does not make a remote request during import or startup.

  3. 03
    Open the shown localhost URL.

    Add --open-browser to request the operating system’s default browser.

LaunchOffline by default
python -m desktop_app --open-browser
Build deterministic evidence onlyNo server, no network
python desktop_foundation.py \
  --recipe workflow-routing \
  --output desktop-state.json

The generated state carries a recomputable SHA-256 digest and deterministic history. The browser prototype keeps state in memory; closing it discards live evidence and the next start returns to offline mode.

First-release workflow

Choose → prove → connect → resolve → authorize.

01

Choose one recipe

Select one of the five canonical use cases. The app regenerates and verifies the unchanged deterministic Integration Studio kit.

02

Prove locally

Replay all six fixed fixtures. Only resolved-valid receives the exact code and registry version; the other five retain no identity fields.

03

Connect explicitly

After a user checks the consent control, fetch the body-free bootstrap and verify its canonical origin, readiness, and same-origin resolver request.

04

Resolve minimum data

Send only the exact expression and optional known language. Preserve the full returned envelope and every abstention or error.

05

Authorize separately

Record a policy outcome and reason. The prototype performs no memory write, route, tool call, publication, spend, deletion, or other side effect.

Local security and privacy

A narrow loopback surface, not a hidden agent channel.

  • Loopback only. The server accepts 127.0.0.1 or localhost; remote interfaces are rejected.
  • No CORS. State-changing requests require same-origin JSON plus X-Embedded-Semantics-Desktop: 1.
  • Bounded input and output. Local command bodies are capped at 32 KiB; remote JSON is capped at 1 MiB; redirects are rejected.
  • No credential path. The bootstrap accepts no body. Resolution sends only expression and optional language.
  • No persistence claim. Prototype history is in memory. There is no database, background updater, remote session, telemetry, account, or startup synchronization.
Inspect the strict state schema →

Fail-closed behavior

Every unsupported path ends in no assignment.

Origin mismatch

Reject the bootstrap before an expression is sent.

Timeout or network failure

Record request/service error evidence; assign no ConceptCode.

Malformed JSON or envelope

Record malformed or unsupported evidence; assign no ConceptCode.

Unknown expression

Preserve unknown_expression; do not guess or synthesize identity.

Ambiguous expression

Preserve ambiguous_expression; do not choose from candidates.

Service error

Preserve the error evidence; do not convert HTTP success or failure into semantic success.

Optional local-model boundary

The model may propose a call. Deterministic code decides whether identity exists.

A local LLM is an advisory client capability, not registry authority. It may help the user identify the exact expression to send or explain already-selected public evidence. It cannot invent, repair, translate, normalize, approximate, or select a ConceptCode.

May receive

The user-selected expression, optional known language, user-selected public resolver evidence, and the public tool contract.

Must not receive

Credentials, hidden prompts, unrelated private conversation or files, automatic background exports, or action authority.

Control point

The user explicitly enables HTTPS. The resolver envelope is validated by the client record contract. Independent policy controls every external side effect.

Reversible architecture decision

The loopback shell is selected for the foundation, not declared the final desktop platform.

foundation only not final packaging choice
selected for foundation

Python standard-library loopback browser shell

Offline
complete local fixture proof without network access
Accessibility
semantic HTML and native browser controls
Bundle
repository source plus Python 3 standard library
Maintainability
reuses current Python contracts and tests
Reversibility
state engine and HTTP boundary can be retained behind another shell

It proves product flow, security boundaries, and state semantics without locking the project into a desktop framework before platform evidence exists.

deferred for platform prototype

Tauri native webview shell

Offline
strong
Accessibility
depends on platform webview and application QA
Bundle
typically smaller than Chromium-bundled shells
Maintainability
adds Rust and platform build responsibilities
Reversibility
can wrap the current state engine through a narrow local API

Promising packaging candidate, but the required Rust/platform toolchain is not assumed here.

deferred not selected

Electron shell

Offline
strong
Accessibility
Chromium accessibility with application QA
Bundle
large runtime bundle
Maintainability
adds Node, Chromium, packaging, and update surface
Reversibility
can consume the same local JSON state contract

Mature but too heavy to select before measured packaging and maintenance evidence.

deferred not selected

Qt/Python native widget shell

Offline
strong
Accessibility
native toolkit support requiring platform QA
Bundle
moderate to large depending on binding and deployment
Maintainability
adds binary dependencies and licensing review
Reversibility
can call the current pure state engine directly

Viable native option, deferred until dependency, licensing, and platform tests are authorized.

Next bounded phase

Prototype one unsigned, rollback-capable platform package without changing the state engine.

The next phase should pick one target operating system, wrap the existing local state/API boundary, measure accessibility and bundle behavior, define update provenance and rollback, and produce an unsigned local test artifact before any distribution signing or app-store work.