DEADBYTE MCP V0.15.35 / R58 FRONTEND BACKEND BRIDGE PERFORMANCE CONSOLIDATION
=========================

AUTHENTICATED MACHINE TRUTH + DURABLE AGENT + CODING + AUTONOMOUS PRODUCTION ENGINE

NPX PRIMARY OPERATOR UX
------------------------
Use the npm CLI entry point instead of the legacy CMD convenience wrapper:

  npx -y deadbyte-mcp@0.15.35 mcp
  npx -y deadbyte-mcp@0.15.35 remote
  npx -y deadbyte-mcp@0.15.35 remote status
  npx -y deadbyte-mcp@0.15.35 remote restart
  npx -y deadbyte-mcp@0.15.35 audit status
  npx -y deadbyte-mcp@0.15.35 audit verify

The `mcp` command is the quiet stdio server entry for local MCP clients; stdout is reserved for MCP.
The remote CLI invokes the stable active-release PowerShell launcher directly with shell=false.
Bare `remote` is a foreground device session: it starts/resumes the verified runtime, arms process,
coding, and autonomous authority, independently verifies those three planes are ARMED, and requires
Desktop and Host to remain DISARMED. Desktop observation/UIA grounding is read-only; guarded GUI input
requires the separate explicit Desktop standing grant (`armdesktop`) and is never implied by Autonomous authority. The single remote console shows device/bridge/cloud/session readiness plus a
unified live timeline (`RUN`, `OK`, `ERR`, interrupted/recovery, cursors, and sanitized Bridge IN/OUT/ERR
diagnostics) without dumping raw JSON payloads, tokens, private keys, or full Bridge payload records. Session shutdown
revokes Desktop/process/coding/autonomous authority, applies fail-safe Host disarm, and parks the Bridge. A detached
nonce-bound guardian watches the foreground owner and performs the same revoke+park cleanup if the
owner is hard-killed before `finally` can run. The v2 runtime marker binds owner PID, guardian PID,
and a random 256-bit session nonce, prevents concurrent foreground sessions, and lets a later start
recover only a dead, unguarded stale owner. Explicit subcommands such as `remote status` remain
one-shot controller operations.

R58 FRONTEND BACKEND BRIDGE PERFORMANCE CONSOLIDATION
------------------------------------------------------
0.15.35 is the single unpublished consolidation successor to production-accepted 0.15.34. R58 keeps 0.15.34 immutable while unifying human/JSON runtime state, expanding read-only Doctor diagnostics, hardening foreground-session identity, and moving the Bridge into the immutable release package instead of relying on a mutable external workspace. The updater now binds the bundled Bridge script plus its complete recursive local static-import dependency closure; dynamic relative imports, path escape, ambiguous core topology, and dependency byte drift remain fail-closed. R58 is not publishable until fresh performance, cross-plane, full-regression, package, registry, and activation/rollback/restore evidence is green. The 4-hour soak and clean-machine proof remain NOT_COMPLETED unless explicitly observed.

R57 BOUNDED CORE STARTUP DISCOVERY HOTFIX
------------------------------------------
0.15.34 fixes the restart-verification race observed during the signed 0.15.33 -> 0.15.32 rollback acceptance. After the controller reported ONLINE and local-ready, the verifier sampled the verified bridge's downstream core process exactly once; on the failing run the bridge existed but its mcp-server child had not yet appeared in the process snapshot. R57 adds a bounded 10-second discovery wait that retries only the exact zero-child condition. Ambiguous or multiple-child topologies still fail immediately, timeout remains fail-closed, and the signed launcher/pointer rollback ordering from R56 is preserved. 0.15.33 remains immutable and published.

R56 SIGNED ROLLBACK LAUNCHER RESTORE HOTFIX
------------------------------------------------
0.15.33 fixes the explicit rollback defect observed after the successful 0.15.32 production activation. The prior immutable release and generation are now verified without incorrectly comparing them to the currently active successor launcher. Rollback then loads the signature-verified activation handoff, requires its prior/new pointers to match the signed activation receipt, restores the signed predecessor launcher snapshot before committing the predecessor pointer, and verifies the complete predecessor installation before restart. If rollback recovery is required, the signed successor launcher bytes are reinstalled before the successor pointer is restored. 0.15.32 remains immutable and published.

R55 ACTIVATION GUARDIAN FAMILY HOTFIX
--------------------------------------
0.15.32 fixes the remaining 0.15.31 offline-recovery self-classification defect observed during production activation. R54 excluded the detached updater supervisor's ancestor chain but the foreground remote-session guardian is a sibling owned by the deadbyte-cli ancestor. R55 excludes that guardian only when its declared --owner-pid is in the updater ancestry, its actual ParentProcessId equals that owner, and its 256-bit session nonce matches the foreground-session contract. Unrelated guardians and stale DEADBYTE runtimes still block recovery. 0.15.31 remains immutable and published; production runtime predecessor remains exact 0.15.29 until R55 activation completes.

R54 ACTIVATION RECOVERY HOTFIX
---------------------------------
0.15.31 fixes the published 0.15.30 offline-predecessor activation defect. The detached update supervisor now excludes only its verified current process ancestry when scanning for DEADBYTE runtime blockers. Unrelated stale DEADBYTE runtime processes, including sibling Node runtimes, guardians, tunnel hosts, and cloud processes, still fail closed. The 0.15.30 package remains immutable and is retained as the exact published source predecessor; production runtime predecessor remains exact 0.15.29 until R54 activation completes.

R51 RUNTIME COHERENCE + SINGLE-FLIGHT + LIVELOG HARDENING
----------------------------------------------------------
0.15.29 closes the offline predecessor activation defect observed in 0.15.28: when recovery sees an OFFLINE predecessor with a stale Host standing grant, the updater now revokes Host authority itself, re-reads controller state, and fails closed unless Host is confirmed DISARMED before capture.

0.15.28 closes the package/runtime split that could leave a new npx CLI attached to an older immutable active slot.
Bare remote now verifies package version plus MANIFEST.SHA256 before binding live generation roots. An older active
runtime is upgraded through the existing immutable-slot updater, then reread and required to match the package exactly.
A newer active runtime is never downgraded automatically, and same-version manifest drift fails closed.

Coding command execution now single-flights identical request identities and reuses one signed completed result for a
bounded five-minute/16-entry window. Caller transport loss or an immediate retry therefore does not spawn duplicate
expensive child work inside one runtime. Explicit receipt identities remain distinct for durable task semantics.

Foreground authority cleanup now verifies and revokes both Desktop and Host, including the detached hard-kill guardian.
Human live logs mark calls at or above one second as [SLOW], report peak in-flight concurrency, parse each audit line once,
refresh directory discovery once per second instead of every 250 ms, and tail only the current plus previous audit segment
to preserve rotation safety without repeatedly scanning historical segments.

R50 PUBLIC PACKAGE BOUNDARY HOTFIX
----------------------------------
0.15.26 is immutable and remains valid as a published historical release, but its npm tarball omitted the
canonical top-level DEADBYTE-MCP.cmd compatibility launcher because the package-ignore boundary matched all
top-level DEADBYTE-MCP*.cmd wrappers. R50 narrows that boundary: DEADBYTE-MCP.cmd is shipped, while local and
shadow wrappers remain excluded. A pack-boundary regression now verifies this exact file surface before publish.
No R49 runtime semantics are widened by this hotfix.

R49 BOUNDED SEMANTIC DESKTOP WAIT
----------------------------------
`desktop_wait` replaces blind fixed sleeps with a bounded, read-only observation loop. It can wait for
frame, topology, foreground-window, or local UIA presence/absence conditions; every poll performs a fresh
capture, and the final observation is recorded in a signed receipt. The baseline frame is goal-owned when
used by the autonomous runtime. Waiting never dispatches input, retries an action, grants Desktop authority,
or treats an execution receipt as proof of the requested outcome. The compact surface exposes the same
contract as `desktop_control` operation `wait` without adding a new compact public tool.

R48 HUMAN LIVELOG TRACE + VISUAL OPCODES
----------------------------------------
The foreground remote console treats emoji as visual opcodes rather than decoration. File reads, writes,
edits, searches, commands, verification, desktop, autonomous, policy-denial, and unknown-side-effect states
use stable semantic glyphs with deterministic ASCII fallback. Policy root ids resolve to absolute host paths
in the human projection while the root id remains visible. `remote --trace` adds trace/span/parent identity
without exposing payload bytes. `remote --filter` filters presentation only; the durable result journal and
audit stream retain every event. Interactive TTY output rewrites a matching RUNNING line in place only when
the terminal result belongs to the same request; unrelated output forces a newline first. Session summaries
report outcome classes, mutation count, p50/p95 latency, slowest tool, heartbeat folding, and top tools.

The legacy CMD file remains only as an R33 compatibility artifact until activation/rollback/restore
proof confirms the npx path; it is not the primary operator interface. Audit data lives under the
stable mutable state root and never inside immutable release slots.

R46 FILELESS POWERSHELL PROCESS PROFILE
--------------------------------------
The Process plane includes a hash-pinned `powershell` profile for bounded one-shot source execution through
`powershell.exe -Command <source>` without creating a temporary `.ps1` script file. The generated release
policy re-pins both `cmd.exe` and Windows PowerShell from the target machine at activation time, so system
binary hashes are never assumed portable across Windows builds. The one-shot profile is shell=false, accepts one source argument up to 8192 UTF-8 bytes, uses pipe transport,
and remains gated by the explicit Process standing grant. R46 also ships `powershell_repl`, a separately
policy-opted persistent PowerShell session profile. `process_session_write` accepts bounded UTF-8 input only
for profiles with `allow_raw_input=true`; every write rechecks the standing grant and journals only byte count
plus SHA-256, never the raw command text. Process reads support bounded waits and negative tail offsets, while
retention remains byte-capped with an explicit earliest offset and stream digest. Signed journals remain the
authority for session history.

AUTHORITY MODEL
---------------
The original containment core remains five tools:

  workspace_open
  file_read
  proof_execute
  contained_transform
  evidence_verify

A configured host policy registers three additional tools:

  host_file_read
  host_file_write
  host_exec

Host registration does not arm host authority. Host calls require an explicit,
policy-hash-bound standing grant until operator revocation. The normal final state is DISARMED.

V0.8 adds an independently feature-gated durable agent surface:
  agent_task_submit
  agent_task_run
  agent_task_status
  agent_task_events
  agent_task_cancel
  agent_task_approve
  agent_task_verify

R23/R34 provide a separately granted 22-tool coding surface for inspect/edit/command/benchmark,
batched file reads, JS/TS semantic navigation/edit, and durable coding tasks. Coding registration
is not coding authority; mutating or executing calls require an explicit policy-bound standing coding grant.

R24 adds a 12-tool autonomous surface for bounded goal execution, DEADBYTE Native Diff,
model-driven diagnose/replan cycles, objective release gating, and signed release proof.
Autonomous registration requires the coding surface, while execution requires both standing
coding and autonomous grants. The model cannot create, widen, or renew either grant.

R29 adds a four-tool machine identity surface: machine_list, machine_status, machine_ping,
and machine_revoke. Machine identity is an Ed25519 public-key identity; machine_id is the
SHA-256 of the exported SPKI bytes. Status/list expose that public SPKI so remote clients can
verify signed pings without trusting the target machine's local key store. Revoke requires
local host authority and advances identity generation plus online epoch without changing the key.

The bridge accepts only complete combinations of base plus optional machine, host, agent,
process, coding, machine-filesystem, observation, and autonomous surfaces. A fully enabled R34
runtime has exactly 73 tools. Process authority is independently gated. Machine-filesystem and
observation require the coding policy root set; autonomous requires the complete coding surface.
Partial, dependency-invalid, unknown, or extra catalogs fail closed.

STRICT OUTPUT CONTRACT
----------------------
R22.1 established strict object outputSchema contracts for the original 15 tools.
R23/R34 apply the same contract to all 22 coding tools, R24 applies it to all
12 autonomous tools, and R29 applies it to all four machine tools. The core validates structuredContent locally on success
and error paths, and the HTTP Bridge
preserves outputSchema at the public MCP edge. Unknown top-level output fields
and missing required result fields fail closed.

R22 AGENT TRUST
---------------
Agent plans are normalized and content-addressed before storage. Durable state is
kept under .deadbyte-agent/tasks/<task-id> inside the selected workspace.

The Ed25519 trust key authenticates separate domains for receipts, agent plans,
agent events, and cancel requests. Recomputing SHA-256 or an event hash chain
without the private key is not sufficient to forge agent state.
Every event also remains in a canonical SHA-256 previous-hash journal. The
signature and hash chain serve different purposes: signature authenticity and
ordered tamper evidence.

A completed task receives a signed task receipt bound to:

  task id + plan SHA-256
  journal head
  package/protocol/runtime identity
  successful underlying step receipts
  approved checkpoints

Executable R22 agent steps are still only proof_execute or fixed contained_transform
operations. Agent orchestration does not create generic shell, executable, argv,
environment, capability, Job-policy, or host-workspace authority.

R23 CODING PLANE
----------------
The coding plane is explicit host-code authority, not AppContainer containment.
A separate policy-hash-bound standing grant gates source writes and command execution
until explicit operator revocation. Edits use absent/SHA-256 preconditions, exact
replacement counts, atomic rename and post-commit hashing. Commands use policy-selected
executable paths/hashes, script hashes, bounded argv/output/time, shell=false, and a
small environment allowlist.

Coding commands execute as the current host user; the child process is not a
filesystem sandbox. The standing grant is therefore intentional coding authority.
No coding tool creates or widens that grant. Benchmark observations record median,
P95 and an explicit regression verdict. Coding actions and durable coding tasks
are independently Ed25519 authenticated.

R25 AUTONOMOUS PRODUCTION ENGINE
--------------------------------
A separate policy-hash-bound standing autonomous grant layers goal authority on top of
the coding grant until explicit operator revocation. Goals are content-addressed and
journaled with signed planner requests, decisions, Native Diff commits, profile
observations, and release completion. Planner actions are limited to inspect, patch,
run_profile, finish, or pause; commands and benchmarks come only from trusted profiles.

DEADBYTE Native Diff uses exact SHA-256 preconditions, signed preimages, transaction
rollback, conflict detection, and signed coding receipts without Git metadata.
Required build/test/benchmark evidence is tied to the current mutation epoch. A
planner finish request cannot bypass the objective release gate or Native HEAD
verification. Public client-sampling mode uses authenticated MCP 2026-07-28 MRTR.
There is no wall-clock goal timeout in the active R25 policy; iteration, mutation,
context, diff-size, command, benchmark, no-progress, and explicit-cancel bounds remain.

For drop-off operation, an `openai_compatible` policy starts the in-process autonomous
supervisor at MCP boot and advances durable submitted goals without further client
`autonomous_goal_run` calls. `client_sampling` instead uses the connected MCP client's
model and persists every round so interrupted work can resume without losing state.
R24 does not install or require Ollama or Git/GitHub for planning, diff, rollback, or
release authority.

R25 adds signed planner-contract rejection/self-repair, deterministic context compaction,
and optional signed authoritative plan snapshots with completed-prefix invariants. Plan state
coordinates work but never replaces Native Diff or current-epoch release evidence; hard guards
block post-plan mutation and premature finish. See docs/V081-R25-MANUS-CONTROL-SEMANTICS.md.
R27 IMMUTABLE RELEASE SLOTS
---------------------------
R27 replaces live-file activation with content-addressed immutable release slots and immutable
controller/policy generations below %USERPROFILE%\.deadbyte-mcp. The operator-only updater verifies
the exact package manifest, creates a generation whose coding/host core root is a separate mutable
development tree, revokes coding/autonomous authority, stops only verified owned processes, then
atomically commits active-release.json. The stable launcher verifies its own hash, every release
manifest entry, every generation entry, and package identity before starting the controller.
Failed activation restores the prior pointer/launcher/workspace state and restarts the known-good
runtime. Host authority must be DISARMED; standing coding/autonomous grants return only with the
explicit --restore-standing-grants flag. No MCP tool can invoke this path.
See docs/V083-R27-IMMUTABLE-RELEASE-SLOTS.md. R26 src-swap behavior remains historical in
docs/V082-R26-RUNTIME-SELF-UPDATE.md.

R28 PERSISTENT NAMED TUNNEL
---------------------------
R28 removes Quick Tunnel hostname drift from the production path. The immutable release ships a
small native tunnel host; the generated controller configuration pins the native host, exact
cloudflared bytes, the external tunnel-token file, and one stable MCP URL file by SHA-256. The
operator supplies a persistent HTTPS origin during v2 activation; the updater derives the full
MCP URL from that origin plus the external MCP path token, writes it outside immutable release
bytes, and binds its hash into the generation identity. The controller re-verifies that URL file
before use and rejects trycloudflare for v2. The native host binds descendants to a kill-on-close
Windows Job and fixes the local origin at 127.0.0.1:8787. Changing external transport inputs is a
generation change; changing the native host is a release change. See
`docs/V084-R28-PERSISTENT-NAMED-TUNNEL.md`.

R29 MACHINE IDENTITY
--------------------
R29 gives each state root one persistent Ed25519 machine identity. The private key stays under
%USERPROFILE%\.deadbyte-mcp\machine and is never returned by MCP. machine_status and machine_list
publish the SPKI public key plus machine_id, identity generation, online epoch, release manifest,
and generation manifest. machine_ping signs a caller nonce together with those bindings using a
domain-separated Ed25519 message. A remote verifier derives SHA-256(SPKI) and verifies the ping
without reading target-local identity files.

machine_revoke is not a remote reset button: it is gated by the separately armed host authority.
A successful revoke increments identity_generation and rotates online_epoch while preserving the
public-key machine_id. Old signatures remain cryptographically valid evidence of the old epoch;
they are stale relative to current status rather than retroactively invalid. Controller command
`machinetest` performs a non-mutating public status/list/ping verification through HTTPS.
See `docs/V085-R29-MACHINE-IDENTITY.md`.

RECOVERY
--------
A task lock prevents concurrent runners. After an interrupted runtime, R22 does
not infer success from an output file alone. It adopts a completed side effect
only when the expected signed underlying receipt independently verifies and is
bound to the expected operation/output. Otherwise it retries, pauses, or fails
closed according to the observed evidence.

Checkpoint approval never automatically executes the following step.
CONTROLLER
----------
Primary operator entry point:

  npx -y deadbyte-mcp@0.15.35 remote

The legacy CMD entry remains compatibility-only for R33 rollback safety.

AgentRuntimeEnabled, CodingRuntimeEnabled, and AutonomousRuntimeEnabled are trusted
boolean controller settings. The controller injects feature flags/policies only into
the Bridge child and restores its own environment after spawn. Coding and autonomous
authority use separate standing grants: `armcoding` and `armautonomous` enable them until
explicit revoke; `disarmcoding` also revokes autonomous authority immediately. No timer
maintenance is required.

Closing the menu is not STOP. Lifecycle state is derived from verified process
identity plus readiness and remains OFFLINE, PARKED, ONLINE, or DEGRADED.

TARGET GATE
-----------
On the Windows target machine:

  npm ci
  npm run gate:windows

The Windows gate runs source tests, core MCP smoke, dedicated agent/coding/autonomous
smokes, tunnel startup-probe compatibility, host-plane fail-closed smoke, native MSVC
build, authority checks, AppContainer containment, active network denial,
fixed contained operations, replay/challenge checks, and independent signed evidence
verification.
PUBLIC FULL GATE
----------------
The controller fulltest uses the public modern MCP path and verifies proof,
contained AppContainer execution, and—when enabled—a two-step durable agent task
plus its signed task receipt. The local canonical three-operation contained gate
runs afterward against the same native build.

TRUST BOUNDARY
--------------
The private Ed25519 key must remain outside task workspaces. Signed evidence does
not prove which physical machine executed the operation and does not survive a
fully compromised trusted host. Workspace write access can still cause local
availability loss; signatures prevent unauthenticated state from being promoted
into authenticated task history, not arbitrary local file deletion.

See:

  docs/ARCHITECTURE.md
  docs/TRUST.md
  docs/V080-AGENT-RUNTIME.md
  docs/V080-R23-CODING-AGENT.md
  docs/V080-R24-AUTONOMOUS-PRODUCTION.md
  docs/V081-R25-MANUS-CONTROL-SEMANTICS.md
  docs/V082-R26-RUNTIME-SELF-UPDATE.md
  docs/V083-R27-IMMUTABLE-RELEASE-SLOTS.md
  docs/V084-R28-PERSISTENT-NAMED-TUNNEL.md
  docs/V085-R29-MACHINE-IDENTITY.md
  docs/R221-STRICT-OUTPUT-CONTRACT.md
  docs/V071-HOST-PLANE.md
  docs/V073-TUNNEL-STDIO-COMPAT.md

MCP CLIENT CONFIGURATION
------------------------
The local stdio entry point is quiet and suitable for MCP hosts:

  npx -y deadbyte-mcp@0.15.35 mcp

CLAUDE DESKTOP
Use the standard local-server entry in claude_desktop_config.json:

  {
    "mcpServers": {
      "deadbyte": {
        "command": "npx",
        "args": ["-y", "deadbyte-mcp@0.15.35", "mcp"]
      }
    }
  }

CURSOR
Create .cursor/mcp.json:

  {
    "mcpServers": {
      "deadbyte": {
        "type": "stdio",
        "command": "npx",
        "args": ["-y", "deadbyte-mcp@0.15.35", "mcp"]
      }
    }
  }

VS CODE
Create .vscode/mcp.json:

  {
    "servers": {
      "deadbyte": {
        "type": "stdio",
        "command": "npx",
        "args": ["-y", "deadbyte-mcp@0.15.35", "mcp"]
      }
    }
  }

CODEX
Add this to ~/.codex/config.toml:

  [mcp_servers.deadbyte]
  command = "npx"
  args = ["-y", "deadbyte-mcp@0.15.35", "mcp"]

The remote device path remains `npx -y deadbyte-mcp@0.15.35 remote`. Remote public MCP uses the
verified HTTPS named-tunnel URL selected by the active generation; do not commit a private device
URL or tunnel token into a repository.

PRODUCTION TRACER BULLET
------------------------
The executable tracer test uses a real MCP client through the `deadbyte-mcp mcp` CLI entry point:

  initialize / negotiate MCP 2026-07-28
  tools/list
  coding_file_read
  coding_text_replace with exact file precondition
  coding_receipt_verify
  coding_command_run through a pinned executable/script policy
  coding_receipt_verify
  coding_file_read to verify committed state

The test fails if negotiation closes, if a required tool is absent, if the edit is not surgical,
if the command exits nonzero, or if either signed receipt fails independent verification.

SEMANTIC CODE AND CONTEXT DISCIPLINE
------------------------------------
The R34 coding surface has 22 tools and the fully enabled public surface has exactly 73 tools.
`coding_files_read` batches bounded reads. `coding_symbol_outline`, `coding_symbol_definition`,
`coding_symbol_references`, and `coding_symbol_replace` use the bundled TypeScript language service
for JavaScript/TypeScript (JS/TS). Symbol mutation still commits through the coding plane's exact
file precondition and signed surgical-edit receipt path.

The built-in semantic engine is deliberately limited to JS/TS in this baseline. DEADBYTE does not
claim Serena's broader language breadth; unsupported languages must fail honestly rather than fall
back to grep and call it semantic navigation. CONTEXT.md and `deadbyte://context` define domain
vocabulary while bounded semantic/search/resource tools provide progressive disclosure instead of
whole-repository prompt dumps.

DOCUMENT ADAPTER EXTENSION
--------------------------
`src/document-adapter.mjs` is the bounded production document adapter extension seam. Adapters
declare an id, one operation, accepted MIME types, output MIME type, and input/output byte budgets.
Duplicate adapters, operation mismatch, MIME mismatch, or budget overflow fail closed. An installed
converter can expose operation `markdown_to_pdf`; no fake PDF, DOCX, or spreadsheet tool is listed
when no converter is configured.

SECURITY DEFAULTS
-----------------
Workspace allowlist and coding-policy root checks are on by design. Paths are root-relative and
traversal, symlink escape, denied paths, stale preconditions, and unknown executables fail closed.
Destructive or executable host work requires the relevant standing grant / authority plane.
Process execution uses policy-selected profiles or pinned scripts rather than a raw caller-selected
shell command. Audit files retain request identity, timing, bounded metadata, and signed evidence. The single `remote`
console exposes the useful correlated timeline and sanitized transport diagnostics directly; there is no
separate verbose mode.

EVIDENCE-BASED COMPARISON
-------------------------
R36 reproducible capability evidence and comparison rules are recorded in
`docs/R36-CAPABILITY-EVIDENCE.md`. Comparisons distinguish upstream `documented` capability from
retained `direct_observation`; tool count is not a release verdict.

Desktop Commander provides a mature local filesystem/terminal MCP and Remote Desktop Commander adds a hosted
remote relay. R46 incorporates the production terminal techniques that materially close workload gaps without
copying their authority model: persistent process sessions, bounded profile-opted stdin, waitable/tail output
reads, chunked retained-output eviction without whole-buffer recopy, stale-aware remote reachability,
bounded idempotent probe retry, no-retry mutation dispatch, bounded async observation-search retention,
and restart-safe exact catalogs. DEADBYTE keeps its stronger
self-owned content-addressed release chain, separately revocable process/coding/autonomous/desktop/host planes,
hash-preconditioned edits, Ed25519 signed receipts/journals, contained fixed workers, exact public-catalog gates,
and tested rollback/restore. Fuzzy mutation is deliberately not substituted for exact mutation preconditions.

Serena has broader semantic language coverage through multiple language-server backends. DEADBYTE
currently does not match that semantic breadth: its built-in semantic backend is JS/TS. For JS/TS,
DEADBYTE adds exact file identity, receipt-backed symbol replacement, durable coding/autonomous
journals, and release evidence around semantic operations. Broader pinned LSP adapters belong in a
successor rather than pretending unsupported languages are already production-ready.

Remote Desktop Commander uses a hosted account/OAuth relay. DEADBYTE instead uses its own verified
named-tunnel device path plus immutable release/generation binding. The trade-off is explicit:
hosted convenience on one side; self-owned release/evidence authority on the other.

NO RAW SHELL COMMAND STRING. NO CALLER-SELECTED EXECUTABLE. CODING AND AUTONOMOUS
EXECUTION REQUIRE EXPLICIT LOCAL STANDING GRANTS. REPORTS ARE CLAIMS; VERIFIED
OBSERVATIONS AND SIGNED EVIDENCE ARE AUTHORITY.


R44 REMOTE AGENT / SKILL / DURABLE JOB
---------------------------------------
R44 keeps the R43 authority model and adds one read-only public skill_catalog, bringing the compact/full surfaces to exact 43/81. Skills are Ed25519/content-addressed and cannot arm authority. The optional codex_app_server planner is executable-hash pinned, uses approvalPolicy=never and read-only sandbox defaults, persists thread identity, and fails closed on interrupted requests. Remote devices require Ed25519 identity, epoch, verified reachability, local capability authorization, durable request IDs and terminal acknowledgement. Persistent jobs require the external supervisor and exact process identity.
