Skip to content

feat(ava): establish controlled Hermes runtime foundation - #1

Draft
SE87H wants to merge 50 commits into
ava/stagingfrom
agent/ava-hermes-foundation
Draft

feat(ava): establish controlled Hermes runtime foundation#1
SE87H wants to merge 50 commits into
ava/stagingfrom
agent/ava-hermes-foundation

Conversation

@SE87H

@SE87H SE87H commented Jul 30, 2026

Copy link
Copy Markdown
Owner

Purpose

Establish a controlled Hermes runtime and fleet control plane for the two
runtime entities ava and aeon. AVAEON Codex is the portable deployment and
audit operator; it is not a Hermes runtime and is never a fleet member.

Canonical identity model

RuntimeEntity    := ava | aeon
OperatorIdentity := avaeon-codex
HostIdentity     := avaorus | minisforum
InstanceIdentity := live | shadow-* | test-*

AVA_ENTITY is always the selected runtime target (ava or aeon).
operator_id=avaeon-codex is separate metadata. AVAEON has no runtime,
Telegram, gateway, service, state.db, permanent snapshot, quorum, or
promotion obligation. It may retain isolated worktrees, harnesses, manifests,
reports, and disposable shadow roots only.

Delivered foundation

  • explicit runtime identity, HERMES_HOME, workspace and session isolation;
  • fail-closed resume/session/CWD/TERMINAL_CWD handling;
  • durable session and workspace restoration invariants;
  • runtime doctor and managed one-shot launcher;
  • runtime-only fleet validation, collision/provenance protection and CLI;
  • SQLite state snapshot verification for runtime entities only;
  • runtime-only promotion evidence and rollback gates;
  • manual-only validation workflow with no deployment authority.

Current M1–M7 evidence

  • M1–M3: resume/session/CWD/workspace invariants and focused repository
    tests closed.
  • M4: synthetic network gate, OAuth protocol trace and TLS fixture closed;
    no real OpenAI endpoint, credential or live provider was used.
  • M5: bounded AEON hosted shadow closed with isolated provider/session,
    persistence, duplicate-consumer and rollback evidence. AEON Unchained remains
    deferred.
  • M6: fresh-main rebase and upstream candidate publication completed in
    isolated worktrees; no live runtime mutation.
  • M7: operator/runtime split implemented in
    dcc9538145a4d58438bbc7137a859009166fba9b; 77 AVA-runtime tests,
    compilation, Ruff and diff-check passed. The postflight cleanup removes the
    residual test processes and corrects the documentation/policy boundary.

AEON hosted shadow is closed. AVA/AVAORUS validation is explicitly deferred
while that host is unavailable. No live promotion, stable movement, service
restart, or live state mutation has been performed.

Frozen update policy

The managed control plane rejects auto_update: true, non-40-character refs,
and moving branches as live sources. hermes update is operationally
forbidden. The upstream binary is not globally intercepted outside the managed
control plane; it must not be invoked directly for live updates.

Every future version must use an isolated pinned candidate, semantic audit,
focused and repository-compatible tests, disposable shadow, state snapshot,
explicit authorization, controlled promotion and rollback. Upstream is intake
material only. AEON Core may provide read-only diagnostics and smokes, but may
not deploy, approve or mutate its own live runtime.

Deferred boundary

External fleet configurations have not been migrated. They must first be
inventoried read-only and then migrated to the two-runtime/operator model before
any future promotion. No live AEON configuration was changed.

The PR remains draft; no promotion to staging or stable is performed here.

SE87H added 30 commits July 30, 2026 11:40

SE87H commented Aug 1, 2026

Copy link
Copy Markdown
Owner Author

M4-SHADOW-PREFLIGHT review — BLOCKED correctly; authorize M4-NETWORK-GATE only

Closure

M4-SHADOW-PREFLIGHT is accepted as an honest BLOCKED:

  • filesystem confinement is viable;
  • gateway/dashboard command templates and disposable topology are viable;
  • ports 18642 and 19119 are unused and distinct from the live ports;
  • no file, credential, process, provider, model, Telegram or cron action occurred;
  • the only unresolved gate is outbound network confinement.

Bubblewrap alone cannot simultaneously provide OpenAI/Telegram egress and prevent access to host loopback, LAN and arbitrary Internet destinations. Do not launch the shadow with host networking and do not weaken this gate.

Authorized operation: M4-NETWORK-GATE only

Build and test an entirely synthetic, ephemeral network harness. No Hermes, model, provider, OAuth, Telegram or real external endpoint may be contacted.

Required topology

  1. Start two disposable loopback TCP endpoints on the host:
    • one ALLOWED_SYNTHETIC endpoint;
    • one DENIED_SYNTHETIC endpoint.
  2. Start one disposable HTTP CONNECT proxy bound only to host loopback on a newly selected unused port.
  3. The proxy must:
    • permit only the exact authority of ALLOWED_SYNTHETIC;
    • reject DENIED_SYNTHETIC, every other hostname/IP/port, non-CONNECT methods and malformed authorities;
    • perform no TLS interception;
    • log only classifications and byte counts, never payloads.
  4. Create a rootless user/network namespace using the validated bubblewrap filesystem topology plus --unshare-net.
  5. Attach rootless networking with slirp4netns if available, otherwise inspect pasta as fallback. Host-loopback reachability may be enabled only to reach the proxy.
  6. Inside the namespace install a fail-closed nftables or equivalent egress policy permitting only:
    • established/related traffic;
    • loopback inside the namespace;
    • the slirp gateway IP and the single proxy TCP port.
      Everything else, including direct DNS, direct Internet, RFC1918/link-local, host gateway ports 8642, 9119, 18642, 19119, and any other proxy-bypass path must be denied.
  7. Run deterministic probes proving:
    • direct connection to ALLOWED_SYNTHETIC is denied;
    • direct connection to DENIED_SYNTHETIC is denied;
    • direct access to host loopback/live ports is denied;
    • direct Internet/DNS route is denied;
    • CONNECT through the proxy to ALLOWED_SYNTHETIC succeeds;
    • CONNECT through the proxy to DENIED_SYNTHETIC is rejected;
    • an arbitrary third destination is rejected;
    • after teardown, no proxy, endpoint, namespace, listener or rule remains.

Forbidden

  • no real OpenAI, ChatGPT, Telegram, DNS or Internet request;
  • no copying or reading credentials/configuration/private state;
  • no Hermes/gateway/dashboard/model/provider/OAuth/cron/skills/memory launch;
  • no sudo, system firewall mutation, persistent service, Docker, source modification, commit, push, merge or promotion;
  • do not rerun earlier phases.

Required report

PHASE := M4-NETWORK-GATE
ROOTLESS_NET_BACKEND :=
PROXY_BIND_PROOF :=
APP_EGRESS_POLICY :=
DIRECT_ALLOWED_ENDPOINT_DENIED :=
DIRECT_DENIED_ENDPOINT_DENIED :=
HOST_LOOPBACK_LIVE_PORTS_DENIED :=
DIRECT_DNS_INTERNET_DENIED :=
PROXY_ALLOWED_CONNECT :=
PROXY_DENIED_CONNECT :=
PROXY_ARBITRARY_DESTINATION_DENIED :=
FILESYSTEM_SANDBOX_PROOF :=
CLEANUP_PROOF :=
LIVE_BEFORE_AFTER :=
CANDIDATE_PROOF :=
RESULT := PASS|FAIL|BLOCKED
RESIDUE :=
NEXT_SINGLE_OPERATION := STOP

Stop after this report. A real shadow launch remains forbidden.

SE87H commented Aug 1, 2026

Copy link
Copy Markdown
Owner Author

M4-NETWORK-GATE review — authorize M4-NETWORK-GATE-V2 only

Le premier design est BLOCKED uniquement parce que slirp4netns et pasta sont absents et que nftables rootless est indisponible. Aucun harness n’a tourné et aucun résidu n’existe.

Une voie sans installation ni privilège doit maintenant être testée :

namespace bwrap sans réseau routable
→ relais HTTP local sur son loopback
→ socket Unix jetable
→ proxy hôte CONNECT à liste blanche exacte
→ endpoint synthétique autorisé uniquement

Autorisation limitée

Exécuter uniquement M4-NETWORK-GATE-V2, avec des endpoints synthétiques locaux.

Contraintes :

  • aucune installation, aucun sudo, aucun nftables/iptables, aucun Docker/Podman/systemd ;
  • aucun Hermes, modèle, provider, OAuth, Telegram, gateway, dashboard ou cron ;
  • aucun endpoint réel, secret, configuration privée, mémoire ou état vivant ;
  • nouvelle racine jetable uniquement ; candidat non exécuté et conservé detached/clean à d39c853c9538e64662d23f5cff170ac8bba7f79a.

Preuve demandée :

  1. Créer deux petits endpoints TCP synthétiques sur le loopback hôte : un autorisé, un refusé.
  2. Créer un proxy CONNECT éphémère écoutant uniquement sur une socket Unix jetable. Il doit accepter exactement la destination synthétique autorisée et refuser toute autre destination ou méthode.
  3. Entrer dans bubblewrap avec --unshare-net et le confinement filesystem déjà validé.
  4. Dans ce namespace, activer seulement le loopback et lancer un relais éphémère lié à 127.0.0.1, communiquant avec le proxy uniquement via la socket Unix montée.
  5. Prouver que les accès TCP directs aux endpoints hôte et aux ports 8642/9119 échouent, que la résolution DNS directe échoue, que le CONNECT autorisé via le relais réussit, et que les destinations refusée/arbitraire ainsi que les méthodes non-CONNECT sont rejetées.
  6. Tout arrêter et supprimer ; prouver l’absence de processus, listener, socket ou fichier résiduel.

Rapport requis :

PHASE := M4-NETWORK-GATE-V2
NO_INSTALL_PRIVILEGE_PROOF := PASS|FAIL
NETWORK_NAMESPACE_LOOPBACK_ONLY := PASS|FAIL
UNIX_EGRESS_SOCKET_PROOF := PASS|FAIL
TCP_RELAY_LOOPBACK_ONLY := PASS|FAIL
DIRECT_ENDPOINTS_DENIED := PASS|FAIL
HOST_LOOPBACK_LIVE_PORTS_DENIED := PASS|FAIL
DIRECT_DNS_DENIED := PASS|FAIL
PROXY_ALLOWED_CONNECT := PASS|FAIL
PROXY_DENIED_CONNECT := PASS|FAIL
PROXY_ARBITRARY_DESTINATION_DENIED := PASS|FAIL
NON_CONNECT_REJECTED := PASS|FAIL
FILESYSTEM_SANDBOX_PROOF := PASS|FAIL
CLEANUP_PROOF := PASS|FAIL
LIVE_BEFORE_AFTER := ...
CANDIDATE_PROOF := ...
RESULT := PASS|FAIL|BLOCKED
RESIDUE := ...
NEXT_SINGLE_OPERATION := STOP

Ne pas affaiblir l’isolation ni partager le réseau hôte en cas d’échec. Aucun shadow réel n’est autorisé. Stop après le rapport.

SE87H commented Aug 1, 2026

Copy link
Copy Markdown
Owner Author

M4-NETWORK-GATE-V2 closure — PASS; authorize M4-PROXY-COMPAT-PREFLIGHT only

M4-NETWORK-GATE-V2 is accepted as PASS. The validated architecture provides loopback-only networking inside bubblewrap, a Unix-socket egress bridge, a loopback TCP relay, strict CONNECT allowlisting, blocked direct DNS/network/host-loopback access, and complete cleanup with no live or candidate mutation.

Authorized single operation: M4-PROXY-COMPAT-PREFLIGHT

Run offline and read-only against exact candidate d39c853c9538e64662d23f5cff170ac8bba7f79a and its installed environment.

Inspect and report only:

  1. the exact code paths and dependency versions used for:
    • OpenAI Codex inference requests;
    • OpenAI OAuth refresh requests;
    • Telegram Bot API polling/sending;
    • Telegram proxy resolution and any fallback-IP transport;
  2. whether each path honors HTTP_PROXY, HTTPS_PROXY, ALL_PROXY, NO_PROXY, or an explicit Telegram proxy argument;
  3. whether the underlying clients use environment proxy discovery (trust_env) or bypass it;
  4. every hostname and port that could be contacted during a minimal shadow start, one hosted model call, Telegram initialization, and token refresh;
  5. any direct-IP, DNS, websocket, webhook, media-download, retry, or fallback path that could bypass the validated proxy gate;
  6. the exact synthetic compatibility harness required to prove both Codex and Telegram through the V2 network gate without using real credentials or endpoints.

Do not copy credentials or private configuration. Do not launch Hermes, gateway, dashboard, Telegram, cron, provider, model, OAuth, or any network request. Do not modify source, candidate environment, live runtime, or files.

Return a compact M4-PROXY-COMPAT-PREFLIGHT report and stop. Real shadow launch remains forbidden.

SE87H commented Aug 1, 2026

Copy link
Copy Markdown
Owner Author

M4-PROXY-COMPAT-PREFLIGHT review — PARTIAL PASS; authorize M4-CLIENT-PROXY-HARNESS only

The inspection closes the static compatibility question for Codex inference and OpenAI OAuth refresh. Telegram also supports an explicit proxy, but two runtime facts remain open: the messaging extra is not installed in the candidate environment, and Telegram contains direct DoH/IP fallback paths that must be proven inert inside the V2 network gate.

CANDIDATE := d39c853c9538e64662d23f5cff170ac8bba7f79a
CODEX_PROXY_COMPAT_STATIC := PASS
OAUTH_PROXY_COMPAT_STATIC := PASS
TELEGRAM_PROXY_COMPAT_STATIC := PASS
TELEGRAM_RUNTIME_DEPENDENCY := MISSING
TELEGRAM_DIRECT_FALLBACK := PRESENT
M4_SHADOW_LAUNCH := FORBIDDEN

Authorize M4-CLIENT-PROXY-HARNESS only, under Luna medium, without subagent.

Disposable environment

  • Create a new private root outside the candidate and live runtime.
  • Build a separate venv from the exact candidate pyproject.toml and uv.lock using frozen resolution with the official messaging extra.
  • Use a disposable UV_PROJECT_ENVIRONMENT and disposable UV_CACHE_DIR; do not alter the candidate .venv.
  • Package-registry access is permitted only when required for the exact frozen lock. No other external destination is authorized.
  • Verify python-telegram-bot==22.6, openai==2.24.0, and httpx==0.28.1 without printing the full environment.

Synthetic client harness

Reuse the proven V2 architecture:

bubblewrap --unshare-net
internal loopback relay
Unix socket bridge
host CONNECT proxy with static allowlist
synthetic TLS endpoints only

Synthetic authorities only:

codex.test:443
oauth.test:443
telegram.test:443

Use dummy credentials only. Redirect endpoint constants in memory or in the disposable harness; do not edit candidate source.

Run exactly these paths:

  1. OpenAI SDK Codex Responses client through the proxy to the synthetic SSE endpoint.
  2. refresh_codex_oauth_pure through environment proxy discovery to the synthetic OAuth endpoint, writing only disposable auth state.
  3. Telegram HTTPXRequest for getMe, getUpdates, and sendMessage through the explicit proxy.

Required environment closure:

HTTP_PROXY/HTTPS_PROXY/ALL_PROXY := internal loopback relay
lowercase proxy variants := same
NO_PROXY/no_proxy := empty
TELEGRAM_PROXY := internal loopback relay
TELEGRAM_FALLBACK_IPS := empty/disabled
GATEWAY_PROXY_URL := unset

Required assertions:

  • all three real client implementations reach only the allowlisted synthetic authorities through CONNECT;
  • direct DNS, direct IP, host loopback, LAN, Internet, Telegram fallback IPs, DoH endpoints, and arbitrary authorities remain unreachable;
  • Telegram normal proxy construction succeeds, so the autonomous direct Bot(...) fallback is not entered;
  • an explicit forced-construction-failure probe proves any direct Telegram fallback is denied by the namespace rather than escaping;
  • no real model, provider, OAuth account, Telegram bot, gateway, cron, or live service is used;
  • candidate HEAD/tree, live CLI, live auth, live state DB, and live processes remain unchanged;
  • stop and clean all endpoints, relays, sockets, venv, cache, and temporary roots.

Return only:

PHASE := M4-CLIENT-PROXY-HARNESS
LOCKED_MESSAGING_ENV :=
VERSIONS :=
CODEX_CLIENT_PROXY :=
OAUTH_REFRESH_PROXY :=
TELEGRAM_GETME_PROXY :=
TELEGRAM_GETUPDATES_PROXY :=
TELEGRAM_SENDMESSAGE_PROXY :=
TELEGRAM_NORMAL_FALLBACK_NOT_ENTERED :=
FORCED_FALLBACK_ESCAPE_DENIED :=
DIRECT_DNS_IP_LAN_INTERNET_DENIED :=
ONLY_ALLOWLISTED_CONNECTS :=
DISPOSABLE_AUTH_ONLY :=
FILES_BEFORE_AFTER :=
LIVE_CLI_PROOF :=
CANDIDATE_PROOF :=
STATE_DB_PROOF :=
CLEANUP_PROOF :=
RESULT := PASS | BLOCKED | FAIL
RESIDUE :=
NEXT_SINGLE_OPERATION := STOP

No shadow launch, real endpoint test, source patch, commit, merge, service action, or promotion is authorized.

SE87H commented Aug 1, 2026

Copy link
Copy Markdown
Owner Author

M4-CLIENT-PROXY-HARNESS review — network gate preserved; authorize M4-CODEX-PROTOCOL-TRACE only

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
CLIENT_HARNESS_RESULT := FAIL
NETWORK_GATE_V2 := PRESERVED
ONLY_ALLOWLISTED_CONNECTS := PASS
LIVE_RESIDUE := NONE

The observed APIConnectionError is not evidence of a proxy bypass: CONNECT and TLS reached the synthetic Codex endpoint, direct DNS/IP/LAN paths remained denied, and no non-allowlisted CONNECT was observed. The remaining fault is at or above TLS/HTTP/protocol-fixture handling.

Authorize M4-CODEX-PROTOCOL-TRACE only, under Luna medium, no sub-agent.

Scope

Recreate a fresh locked disposable environment and the already-proven M4 network gate V2. Test only the OpenAI SDK Codex client against one synthetic TLS endpoint. Do not run OAuth or Telegram in this phase.

Required trace

  1. Verify the disposable CA/certificate trust and hostname match used by the synthetic endpoint.
  2. Through the same proxy path, perform a minimal raw httpx request to the synthetic authority and prove:
    • CONNECT accepted;
    • TLS completed;
    • request reached the endpoint;
    • complete HTTP response framing was received.
  3. Invoke the exact Codex OpenAI SDK path with retries disabled (max_retries=0) and a bounded timeout.
  4. Capture only sanitized diagnostics:
    • exception class and nested __cause__/__context__ class chain;
    • whether failure occurred during connect, TLS, write, read, HTTP parsing, status handling, or SSE/event parsing;
    • request method and path;
    • response status, content type, transfer/content-length framing;
    • header names only, never values;
    • JSON/SSE event names and object-key names only, never prompt or payload values.
  5. Compare the synthetic response with the exact response/event contract expected by openai==2.24.0 and the candidate Codex runtime.
  6. The harness may repair only its synthetic certificate/HTTP/SSE fixture and repeat at most three bounded variants derived from the observed failure. It must not modify candidate source, installed candidate venv, lockfiles, or runtime configuration.
  7. Prove again that only the allowlisted synthetic CONNECT occurs and that direct DNS/IP/LAN/live ports remain unreachable.
  8. Delete the disposable environment, CA, certificates, sockets, endpoints, logs, and harness.

Forbidden

real OpenAI endpoint/account/token
OAuth refresh
Telegram
Hermes gateway/dashboard/cron
model call
candidate or live source changes
live auth/state/workspace changes
service/process persistence
merge/promotion/ready-for-review

Report

PHASE := M4-CODEX-PROTOCOL-TRACE
RAW_HTTPX_PATH := PASS|FAIL
TLS_TRUST := PASS|FAIL
SDK_REQUEST_REACHED_ENDPOINT := YES|NO
SDK_FAILURE_LAYER := exact sanitized layer
EXCEPTION_CHAIN := class names only
SYNTHETIC_FIXTURE_REPAIR := NONE|exact fixture category
CODEX_CLIENT_PROXY := PASS|FAIL
ONLY_ALLOWLISTED_CONNECTS := PASS|FAIL
DIRECT_PATHS_DENIED := PASS|FAIL
LIVE_BEFORE_AFTER := unchanged|exact difference
CANDIDATE_PROOF := exact SHA, detached, clean
CLEANUP_PROOF := PASS|FAIL
RESULT := PASS|FAIL|BLOCKED
RESIDUE := exact
NEXT_SINGLE_OPERATION := STOP

OAuth and Telegram remain suspended. Do not relaunch the combined client harness.

SE87H commented Aug 1, 2026

Copy link
Copy Markdown
Owner Author

M4-CODEX-PROTOCOL-TRACE closure — PASS; authorize M4-OAUTH-PROTOCOL-TRACE only

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
CODEX_CLIENT_PROXY := PASS
TLS_TRUST := PASS
ONLY_ALLOWLISTED_CONNECTS := PASS
DIRECT_PATHS_DENIED := PASS
RESIDUE := NONE

The prior Codex failure is classified as a synthetic-fixture defect. Do not rerun the Codex client.

Authorized single operation: M4-OAUTH-PROTOCOL-TRACE

Run under Luna medium, without sub-agent.

Use the already proven network gate V2 and a fresh disposable environment. Exercise only refresh_codex_oauth_pure against a synthetic TLS endpoint such as oauth.test:443.

Required boundaries:

  • fake access/refresh tokens only;
  • disposable Hermes and Codex auth files only;
  • override the OAuth endpoint only inside the disposable harness;
  • no real OpenAI endpoint, account, token, provider inference, Telegram, gateway, cron or model;
  • retries disabled and timeout bounded;
  • no secret/token values, hashes, exact timestamps or raw payloads in the report.

Required proofs:

RAW_HTTPX_PATH
TLS_TRUST
OAUTH_REQUEST_REACHED_ENDPOINT
OAUTH_REFRESH_RESULT
HERMES_AUTH_WRITE_SCOPE
CODEX_AUTH_WRITE_SCOPE
TOKEN_ROTATION_RELATION := synthetic categories only
ONLY_ALLOWLISTED_CONNECTS
DIRECT_PATHS_DENIED
LIVE_AUTH_BEFORE_AFTER
LIVE_STATE_DB_BEFORE_AFTER
LIVE_CLI_PROOF
CANDIDATE_PROOF
CLEANUP_PROOF
RESULT
RESIDUE
NEXT_SINGLE_OPERATION := STOP

The harness must prove that a successful synthetic refresh updates only the two disposable auth states in the expected schema and that a rejected/malformed synthetic response fails closed without corrupting either file. Maximum three bounded response variants.

No Telegram retest and no shadow launch are authorized.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M4-OAUTH-PROTOCOL-TRACE interruption review — BLOCKED safely; authorize M4-GATE-V2-RECOVERY only

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
PRIOR_NETWORK_GATE_V2 := PASS
PRIOR_CODEX_PROXY := PASS
CURRENT_BLOCKER := local candidate checkout and non-secret V2 harness absent after operator restart
LIVE_STATE_CHANGED := NO
RESIDUE := NONE

The interruption does not invalidate any prior proof. Do not rerun M2, M3, the Codex client, OAuth, or Telegram in this operation.

Authorized single operation: M4-GATE-V2-RECOVERY

Run under GPT-5.6 Luna medium, without sub-agent.

  1. Recreate an isolated candidate checkout at an AVAEON-controlled disposable path, pinned to exact commit d39c853c9538e64662d23f5cff170ac8bba7f79a.
  2. Prove detached HEAD and clean tree. Do not alter the live Hermes checkout, CLI symlink, service, state DB, auth, or workspace.
  3. Reconstruct the previously validated non-secret network gate V2 harness from the closed contract:
    • bubblewrap --unshare-net;
    • namespace loopback only;
    • TCP relay bound only inside that loopback;
    • relay crosses only a disposable Unix socket;
    • host-side CONNECT proxy with exact static allowlist;
    • no DNS, direct IP, LAN, host-loopback live-port, or arbitrary CONNECT route;
    • complete teardown.
  4. Store the reusable non-secret harness under a protected AVAEON control root, not inside either Git checkout, for example:
    /home/se7h/.local/share/avaeon/harnesses/m4_network_gate_v2.py
    with parent mode 0700, file mode 0600, and a sidecar manifest recording SHA-256, size, owner, mode, and the contract version. Do not publish the hash or full source in the report; report equality/integrity categories only.
  5. Run one fully synthetic self-test only, equivalent to the prior V2 proof. No external endpoint and no private credentials.

Required report:

PHASE := M4-GATE-V2-RECOVERY
CANDIDATE_REHYDRATED
CANDIDATE_PROOF
HARNESS_PATH
HARNESS_PERMISSION_PROOF
HARNESS_MANIFEST_PROOF
NETWORK_NAMESPACE_LOOPBACK_ONLY
UNIX_EGRESS_SOCKET_PROOF
TCP_RELAY_LOOPBACK_ONLY
DIRECT_ENDPOINTS_DENIED
HOST_LOOPBACK_LIVE_PORTS_DENIED
DIRECT_DNS_IP_LAN_INTERNET_DENIED
PROXY_ALLOWED_CONNECT
PROXY_DENIED_CONNECT
PROXY_ARBITRARY_DESTINATION_DENIED
NON_CONNECT_REJECTED
FILESYSTEM_SANDBOX_PROOF
CLEANUP_PROOF
LIVE_BEFORE_AFTER
RESULT
RESIDUE
NEXT_SINGLE_OPERATION := STOP

No OAuth, Telegram, model/provider call, gateway, cron, systemd, Docker, source change, merge, promotion, or upstream rebase is authorized.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M4-GATE-V2-RECOVERY closure — PASS; authorize M4-OAUTH-PROTOCOL-TRACE only

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
GATE_V2_RECOVERY := PASS
HARNESS_PATH := /home/se7h/.local/share/avaeon/harnesses/m4_network_gate_v2.py
HARNESS_MANIFEST := PASS
NETWORK_CONFINEMENT := PASS
CLEANUP := PASS
LIVE_STATE_CHANGED := NO
RESIDUE := reusable non-secret gate + manifest only

The previous interruption is fully repaired. Earlier M2/M3/M4 proofs remain valid. Do not rerun Codex or prior gates.

Authorized single operation: M4-OAUTH-PROTOCOL-TRACE

Run under GPT-5.6 Luna medium, without sub-agent.

Required setup:

  1. Verify the persistent gate V2 file and manifest before use; abort on any mismatch.
  2. Rehydrate a fresh disposable checkout at exact SHA d39c853c9538e64662d23f5cff170ac8bba7f79a; prove detached and clean.
  3. Create fresh disposable HERMES_HOME, CODEX_HOME, HOME/XDG/TMP roots and fake Hermes/Codex auth files only.
  4. Use the validated gate V2 against one synthetic TLS authority oauth.test:443, with static proxy resolution and no DNS.

Exercise only refresh_codex_oauth_pure with fake tokens and a harness-only OAuth endpoint override.

Required bounded variants, maximum three:

  • valid refresh response: prove expected token/metadata update in disposable Hermes and Codex auth stores only;
  • rejected response: prove fail-closed behavior and no file corruption;
  • malformed response: prove fail-closed behavior and no file corruption.

Required report:

PHASE := M4-OAUTH-PROTOCOL-TRACE
GATE_MANIFEST_PROOF
CANDIDATE_PROOF
RAW_HTTPX_PATH
TLS_TRUST
OAUTH_REQUEST_REACHED_ENDPOINT
OAUTH_REFRESH_RESULT
HERMES_AUTH_WRITE_SCOPE
CODEX_AUTH_WRITE_SCOPE
TOKEN_ROTATION_RELATION := synthetic categories only
REJECTED_RESPONSE_FAIL_CLOSED
MALFORMED_RESPONSE_FAIL_CLOSED
ONLY_ALLOWLISTED_CONNECTS
DIRECT_PATHS_DENIED
LIVE_AUTH_BEFORE_AFTER
LIVE_STATE_DB_BEFORE_AFTER
LIVE_CLI_PROOF
CLEANUP_PROOF
RESULT
RESIDUE
NEXT_SINGLE_OPERATION := STOP

Forbidden:

  • real OpenAI endpoint/account/token;
  • provider inference or model call;
  • Codex client retest;
  • Telegram, gateway, cron, service, shadow launch;
  • source modification, commit, rebase, merge, promotion;
  • secret values, raw payloads, hashes or exact token timestamps in the report.

Stop after the report.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M4-OAUTH-PROTOCOL-TRACE interruption review — BLOCKED safely; authorize M4-OAUTH-TLS-FIXTURE only

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
GATE_V2_MANIFEST := PASS
NETWORK_GATE := PRESERVED
OAUTH_TLS_FORWARDING := ABSENT
LIVE_STATE_CHANGED := NO
RESIDUE := persistent non-secret gate + manifest only

This is a missing synthetic protocol fixture, not a network-confinement failure. Do not modify or replace the validated gate V2 core.

Authorized single operation: M4-OAUTH-TLS-FIXTURE

Run under GPT-5.6 Luna medium, without sub-agent.

Create a separate persistent, non-secret OAuth TLS fixture beside the gate, for example:

/home/se7h/.local/share/avaeon/harnesses/m4_oauth_tls_fixture.py
/home/se7h/.local/share/avaeon/harnesses/m4_oauth_tls_fixture.manifest.json

Required boundaries:

  • parent mode 0700; files 0600;
  • fixture code and manifest only may persist;
  • ephemeral CA, key, certificate, sockets, endpoint process, logs, cache and temporary roots must be removed after self-test;
  • certificate SAN must contain only oauth.test;
  • synthetic endpoint must bind to an ephemeral host-side local port and be reachable only through the existing gate V2 exact CONNECT allowlist;
  • no real DNS, Internet, OpenAI endpoint, OAuth token, auth file, Hermes client, Codex client, Telegram, gateway, cron, service or model;
  • do not execute refresh_codex_oauth_pure in this phase;
  • do not change the candidate, source repository, gate V2 core or its existing manifest.

Required self-test:

  1. verify the existing gate and manifest before use;
  2. generate an ephemeral private CA and oauth.test certificate;
  3. launch a minimal bounded HTTPS endpoint with one non-sensitive health response;
  4. inside the gate namespace, prove raw httpx TLS validation succeeds only via the proxy using the ephemeral CA;
  5. prove wrong hostname and untrusted CA fail;
  6. prove direct DNS/IP/LAN/Internet/live-port access remains denied;
  7. prove only oauth.test:<ephemeral-port> CONNECT is observed and arbitrary/non-CONNECT requests are rejected;
  8. clean every ephemeral artifact and process;
  9. verify the persisted fixture and manifest integrity after cleanup.

Report:

PHASE := M4-OAUTH-TLS-FIXTURE
GATE_MANIFEST_PROOF
FIXTURE_PATH
FIXTURE_PERMISSION_PROOF
FIXTURE_MANIFEST_PROOF
TLS_CA_TRUST_PROOF
TLS_HOSTNAME_PROOF
RAW_HTTPX_PROXY_PATH
WRONG_HOSTNAME_DENIED
UNTRUSTED_CA_DENIED
ONLY_ALLOWLISTED_CONNECTS
DIRECT_PATHS_DENIED
FILESYSTEM_SANDBOX_PROOF
CLEANUP_PROOF
LIVE_BEFORE_AFTER
RESULT
RESIDUE
NEXT_SINGLE_OPERATION := STOP

No OAuth protocol trace or shadow launch is authorized yet.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

Sol High integration sweep authorization — finish synthetic closure, prepare shadow, stop before real state

OPERATOR_MODEL := GPT-5.6 Sol High
CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
NETWORK_GATE_V2 := PASS + persistent manifest
OAUTH_TLS_FIXTURE := PRESENT + persistent manifest
CURRENT_BLOCK := gate/fixture composition, not network confinement

This replaces the overly granular one-micro-phase cadence. The operator may complete the remaining non-destructive synthetic validation chain in one continuous integration sweep, while preserving evidence after each internal gate.

Mission A — compose the durable harnesses

  • Inspect the persistent gate V2 and OAuth TLS fixture plus both manifests.
  • Do not weaken or overwrite the validated gate core.
  • Build a versioned composition/adapter layer beside them that provides exact TLS forwarding for synthetic authorities while retaining loopback-only namespace, Unix-socket egress, strict CONNECT allowlisting, no direct DNS/IP/LAN/Internet/live-port access, and full cleanup.
  • Persist the adapter and its manifest outside Git checkouts with parent 0700 and files 0600.
  • Regression-test every original V2 invariant before proceeding.

Mission B — close OAuth synthetic protocol

Against oauth.test:443 only, with fake tokens and disposable Hermes/Codex auth files:

  • raw httpx + TLS/hostname proof;
  • execute the exact refresh_codex_oauth_pure path;
  • maximum three bounded variants: valid, rejected, malformed;
  • prove successful writes are limited to the two disposable auth stores and schema-correct;
  • prove rejected/malformed responses fail closed without corruption;
  • expose only categorical token-rotation relations, never token values, hashes, claims, or exact timestamps.

Mission C — close Telegram synthetic protocol

Using a disposable locked messaging environment and fake bot/token only:

  • getMe, getUpdates, sendMessage through the composed gate;
  • normal proxy path reproducible;
  • forced construction failure/fallback path exercised;
  • prove DoH, system DNS, Telegram fallback IPs, arbitrary CONNECT, direct IP, LAN, Internet and live ports cannot escape;
  • prove no duplicate synthetic delivery and complete cleanup.

Mission D — offline shadow readiness

After A-C pass:

  • rehydrate the exact candidate checkout detached and clean;
  • inspect the exact foreground gateway/dashboard startup paths and required config schemas;
  • create a complete disposable shadow plan: roots, ports, logs, process bounds, proxy allowlist, shutdown, snapshot, rollback and evidence matrix;
  • verify startup can be attempted without touching live paths;
  • do not launch a real-provider, real-Telegram or persistent shadow.

Optional audit assistance

Sol High may use at most two short read-only counterchecks at depth 1 only when a named contradiction remains. No autonomous implementation branch, broad repository refactor, or speculative source change.

Hard stop boundary

The sweep MUST stop before any of the following:

  • real OAuth credential copy or refresh;
  • real OpenAI/ChatGPT endpoint or model call;
  • real Telegram bot/token/API;
  • gateway/dashboard/cron against real configuration;
  • systemd/service creation, restart, kill or promotion;
  • live CLI/symlink/state.db mutation;
  • candidate source mutation;
  • upstream rebase, commit, push, merge, READY FOR REVIEW, staging/stable movement.

Final report

Return one consolidated report with:

PHASE := M4-SOL-HIGH-INTEGRATION-SWEEP
HARNESS_COMPOSITION
V2_REGRESSION
OAUTH_SYNTHETIC
TELEGRAM_SYNTHETIC
FALLBACK_ESCAPE_DENIAL
SHADOW_READINESS
PERSISTED_HARNESSES_AND_MANIFESTS
LIVE_BEFORE_AFTER
CANDIDATE_PROOF
CLEANUP_PROOF
PASS|PARTIAL|BLOCKED
EXACT_REMAINING_GAPS
NEXT_CRITICAL_BOUNDARY

Stop after that report. Real-state execution remains subject to SE7H/ChatGPT audit.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M4-SOL-HIGH-INTEGRATION-SWEEP closure — PASS; authorize unattended M5 shadow sequence under bounded auto-review

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
M4_SYNTHETIC_CHAIN := PASS
NETWORK_GATE_V2 := PASS
OAUTH_SYNTHETIC := PASS
TELEGRAM_SYNTHETIC := PASS
FALLBACK_ESCAPE_DENIAL := PASS
SHADOW_READINESS := PASS
LIVE_STATE_CHANGED := NO
RESIDUE := non-secret manifested harnesses only

Operator/model decision

  • Parent/operator: GPT-5.6 Sol High.
  • Do not spawn a Luna execution subagent for the remaining critical path. The synthetic work is already complete; duplicating context now is unnecessary.
  • A reviewer agent may be used only through Codex Auto-review for eligible approval prompts.

Permission decision

Forbidden on the living Minisforum host:

--dangerously-bypass-approvals-and-sandbox
--yolo
sandbox_mode = "danger-full-access"
approval_policy = "never" + danger-full-access

Required unattended posture:

approval_policy = "on-request"
approvals_reviewer = "auto_review"
sandbox_mode = "workspace-write"

Use a dedicated trusted shadow workspace and grant only the additional directories explicitly needed. Do not broaden to the user's full HOME. Keep the external bubblewrap/network-gate boundary authoritative.

Authorized operation: M5-UNATTENDED-SHADOW-SEQUENCE

Run as one coherent Sol High sequence. Stop immediately and report if any invariant fails; do not improvise broader access.

Stage 0 — autonomy and boundary proof

  1. Record effective model, approval policy, reviewer, sandbox mode, writable roots, network policy, workspace, candidate SHA and harness manifests.
  2. Prove Auto-review is active and full/danger access is not active.
  3. Prove the live checkout, live CLI symlink, live auth, live state.db, live ports 8642/9119 and services remain outside writable shadow roots.

Stage 1 — isolated real provider shadow

  1. Rehydrate exact candidate d39c853c9538e64662d23f5cff170ac8bba7f79a, detached and clean.
  2. Create a fresh private shadow root, workspace, logs and ports 18642/19119.
  3. Copy only the minimum OpenAI Codex provider state into the private shadow root; never print or hash token values.
  4. Perform an immediate offline readiness/expiry check.
  5. Allowlist only chatgpt.com:443; explicitly deny auth.openai.com:443, api.openai.com:443, arbitrary hosts, IP literals and non-443 ports. OAuth refresh is forbidden in this stage.
  6. Launch the candidate gateway/dashboard in foreground under the proven filesystem/network confinement.
  7. Prove health, exact candidate process provenance, one bounded provider/model request and one two-turn session continuity check using the minimal clarify toolset only.
  8. If the access token is not usable without refresh, stop as BLOCKED_AUTH_EXPIRY; do not enable refresh.

Stage 2 — isolated real Telegram shadow

Only after Stage 1 passes:

  1. Copy only the minimum Telegram configuration into the private shadow root; redact values from all evidence.
  2. Add only api.telegram.org:443 to the allowlist. Keep TELEGRAM_FALLBACK_IPS empty and all DoH/system-DNS/direct-IP paths blocked.
  3. Verify getMe, bounded polling and one uniquely labelled outbound shadow test message to the configured private home channel.
  4. Prove exactly one delivery, no duplicate polling process and no collision with the living gateway.

Stage 3 — disposable cron/state/restart proof

Only after Stage 2 passes:

  1. Create one shadow-only disposable cron job with no external side effect beyond a marker inside the shadow root.
  2. Prove cron namespace isolation and exactly-once execution.
  3. Create and independently verify a SQLite online-backup snapshot of the shadow state.
  4. Stop cleanly, verify no residual listener/process, restart once, and prove session/state persistence.
  5. Rehearse rollback inside the shadow lane only to exact audited foundation SHA 2485d81251f1a4621cfd8fefd9c709883c8f4754, then return to the candidate and prove both transitions. Never move a live ref, symlink or service.

Mandatory final state

  • Stop all shadow processes.
  • Delete copied credentials, tokens, temporary checkout, temporary certificates, caches and disposable cron state.
  • Preserve only redacted evidence, manifested non-secret harnesses and the verified shadow snapshot if it contains no credentials.
  • No source modification, commit, push, merge, Ready for Review, staging/stable movement, live restart, live service mutation or upstream rebase.

Return one consolidated report:

PHASE := M5-UNATTENDED-SHADOW-SEQUENCE
AUTONOMY_PROFILE_PROOF
FULL_ACCESS_DISABLED_PROOF
CANDIDATE_PROOF
SHADOW_ROOTS_PORTS_PROOF
AUTH_READINESS
NETWORK_ALLOWLIST_PROOF
PROVIDER_MODEL_SHADOW
SESSION_CONTINUITY
TELEGRAM_SHADOW
DUPLICATE_DELIVERY_PROOF
CRON_ISOLATION
STATE_SNAPSHOT_PROOF
RESTART_PERSISTENCE
SHADOW_ROLLBACK_REHEARSAL
LIVE_BEFORE_AFTER
CLEANUP_PROOF
RESULT := PASS | BLOCKED | FAIL
RESIDUE
NEXT_CRITICAL_BOUNDARY := STOP

No subagent execution lane, no dangerous full access, and no promotion are authorized.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M5 unattended sequence review — BLOCKED safely; authorize one-click M5A provider shadow only

CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
M4_SYNTHETIC_CHAIN := PASS
M5_PREFLIGHT := PASS
AUTO_REVIEW := WORKED_AS_DESIGNED
LIVE_STATE_CHANGED := NO
CURRENT_BOUNDARY := real copied OpenAI OAuth credential + chatgpt.com

The block is expected and is not a runtime failure. auto_review must not silently cross the first real-credential boundary.

Authorized operation: M5A-PROVIDER-SHADOW-ONECLICK

Operator: GPT-5.6 Sol High. No sub-agent.

Prepare a persistent non-secret runner and manifest outside Git, for example:

/home/se7h/.local/share/avaeon/harnesses/m5a_provider_shadow_v1.py
/home/se7h/.local/share/avaeon/harnesses/m5a_provider_shadow_v1.manifest.json

Before asking SE7H for approval, complete all non-sensitive work:

  1. verify every M4/M5 harness manifest;
  2. rehydrate exact candidate d39c853c9538e64662d23f5cff170ac8bba7f79a, detached and clean;
  3. create the private disposable shadow root and prove live ports 8642/9119 and reserved shadow ports are untouched;
  4. dry-run the runner with no credential and no network;
  5. prove the runner is restricted to this single sequence and has bounded timeouts/cleanup traps;
  6. print one redacted execution summary and request approval for exactly one top-level runner command.

After that single human approval, the runner may autonomously:

  • copy only the minimum openai-codex provider/auth material into disposable shadow paths, without printing, hashing or publishing any token;
  • immediately re-check offline access-token validity (>=300s remaining), provider singleton/pool consistency and file permissions;
  • allow network only to chatgpt.com:443 through the already validated V2 gate;
  • explicitly deny auth.openai.com, api.openai.com, Telegram hosts, DNS, IP literals, LAN, arbitrary CONNECT and live ports;
  • forbid OAuth refresh: any refresh attempt, 401, token expiry, auth-file mutation or unexpected host is a hard stop;
  • run the exact candidate with explicit provider openai-codex, model gpt-5.6-sol, toolset clarify only;
  • perform a bounded two-turn continuity smoke proving same durable session ID, restored first-turn marker, no fork and exact usage/provider/model readback;
  • compare both disposable auth files byte-for-byte before/after;
  • remove copied credentials, shadow state, candidate checkout, venv/cache, processes, sockets and logs after collecting a redacted proof report.

Forbidden in M5A:

  • Telegram, gateway, dashboard, cron or service launch;
  • terminal/file tools inside the model smoke;
  • OAuth refresh or auth.openai.com;
  • live auth/state/CLI/service mutation;
  • source change, commit, push, rebase, merge, promotion or rollback.

Report:

PHASE := M5A-PROVIDER-SHADOW-ONECLICK
RUNNER_MANIFEST_PROOF
SINGLE_APPROVAL_COMMAND_PROOF
CANDIDATE_PROOF
AUTH_OFFLINE_READINESS
MINIMAL_CREDENTIAL_COPY_SCOPE
NETWORK_ALLOWLIST_PROOF
REFRESH_FORBIDDEN_PROOF
PROVIDER_MODEL_SHADOW
SESSION_CONTINUITY
SESSION_FORK_PROOF
USAGE_READBACK_PROOF
DISPOSABLE_AUTH_BEFORE_AFTER
LIVE_BEFORE_AFTER
CLEANUP_PROOF
RESULT
RESIDUE
NEXT_CRITICAL_BOUNDARY := STOP

If Codex requests approval for any second command after the top-level runner starts, fail closed, clean up and report the exact reason. Stop after M5A.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M5A review — fail-closed before provider

The candidate is not defective. The M5A runner used a non-canonical managed identity. A shadow AEON run must keep AVA_ENTITY=aeon; isolation belongs in disposable runtime roots and process configuration, not in a new identity name.

Authorized next operation: update only the non-secret M5A runner and manifest, then perform an offline binding preflight proving all resolved writable paths remain inside a fresh disposable shadow root. Do not access any external endpoint or living runtime state in this operation. Return the binding report and stop.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M5A canonical identity binding — PASS; authorize provider shadow rerun only

OPERATOR_ID := avaeon-codex
TARGET_ENTITY := aeon
HOST_ID := minisforum
INSTANCE_ID := shadow-m5a-provider
AVA_ENTITY := aeon
CANONICAL_IDENTITY_BINDING := PASS
LIVE_STATE_CHANGED := NO

The prior fail-closed result was caused only by an invalid composite identity value. The corrected runner now proves that every runtime path resolves inside the disposable shadow root and that no live AEON path is reachable.

Authorized single operation: rerun M5A-PROVIDER-SHADOW-ONECLICK under GPT-5.6 Sol High, without sub-agent.

Requirements:

  • exact candidate SHA d39c853c9538e64662d23f5cff170ac8bba7f79a, detached and clean;
  • one human approval maximum;
  • AVA_ENTITY=aeon with operator/host/instance metadata kept separate;
  • provider/model shadow only;
  • two-turn managed session continuity test;
  • prove stable session identity, restored context, no fork, and usage readback;
  • preserve refresh prohibition and byte-identical disposable auth before/after;
  • strict network allowlist; all non-authorized paths denied;
  • no Telegram, gateway, dashboard, cron, service, live state, source change, rebase, commit, push, merge, or promotion;
  • complete cleanup and stop after the consolidated M5A report.

If a second approval is requested or any path escapes the disposable root, fail closed, clean up, and stop.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M5A provider shadow — PASS; authorize final shadow goal sequence

MODE := Goal
MODEL := GPT-5.6 Sol High
OPERATOR_ID := avaeon-codex
TARGET_ENTITY := aeon
HOST_ID := minisforum
AVA_ENTITY := aeon
CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
ROLLBACK_SHA := 2485d81251f1a4621cfd8fefd9c709883c8f4754
PROVIDER_SHADOW := PASS
LIVE_RUNTIME_MUTATION := FORBIDDEN

Authorized goal: finish the remaining AEON Minisforum shadow validation in one continuous bounded run. Do not stop after each successful stage.

Required stages:

  1. Telegram shadow preflight and bounded live-path validation.
  2. Prove no competing live Telegram consumer before polling; if one exists, do not disrupt it and classify only that polling proof as blocked.
  3. Validate bounded getMe, getUpdates, and sendMessage behavior, routing, and duplicate-delivery invariants where safely reachable.
  4. Launch gateway and cron only inside disposable shadow roots, ports, logs, and process namespace.
  5. Prove cron isolation and absence of duplicate work.
  6. Create and independently verify a shadow state.db snapshot with integrity check and manifest.
  7. Stop and restart the shadow; prove session/state persistence and clean process ownership.
  8. Rehearse rollback inside the shadow only: candidate -> exact rollback SHA -> candidate, verifying identity, state compatibility, cleanup, and no live ref movement.
  9. Stop all shadow processes and remove all disposable roots, copied runtime material, sockets, ports, logs, and temporary checkouts.

Execution policy:

  • continue automatically across successful stages;
  • use existing on-request + auto_review + workspace-write controls;
  • batch any sensitive boundary into at most one clearly scoped human approval command;
  • no sub-agent;
  • no mutation of the living Hermes checkout, auth, state database, CLI, service units, ports, branch refs, or processes;
  • no dashboard unless strictly required for a listed proof;
  • no rebase, commit, push, merge, promotion, or Ready for Review;
  • fail closed and clean up only on a real boundary violation or unrecoverable contradiction.

Return one consolidated report only:

PHASE := M5-FINAL-SHADOW-GOAL
GOAL_MODE_PROOF
TELEGRAM_SHADOW
DUPLICATE_DELIVERY_PROOF
GATEWAY_SHADOW
CRON_ISOLATION
STATE_SNAPSHOT_PROOF
RESTART_PERSISTENCE
ROLLBACK_REHEARSAL
CANDIDATE_PROOF
LIVE_BEFORE_AFTER
CLEANUP_PROOF
RESULT
EXACT_REMAINING_GAPS
NEXT_CRITICAL_BOUNDARY := STOP

Do not request review between successful stages. Stop only at final completion or after a fail-closed cleanup.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M5 final shadow closure — PASS with documented Telegram polling exception

RESULT := PASS_WITH_DOCUMENTED_EXCEPTION
CANDIDATE_SHA := d39c853c9538e64662d23f5cff170ac8bba7f79a
PROVIDER_SHADOW := PASS
TELEGRAM_GETME := PASS
TELEGRAM_SENDMESSAGE := PASS
TELEGRAM_GETUPDATES := BLOCKED_BY_LIVE_CONSUMER
DUPLICATE_DELIVERY := PASS
GATEWAY_SHADOW := PASS
CRON_ISOLATION := PASS
STATE_SNAPSHOT := PASS
RESTART_PERSISTENCE := PASS
ROLLBACK_REHEARSAL := PASS
LIVE_STATE_CHANGED := NO
CLEANUP := COMPLETE
REPORT_SHA256 := 6ec4b9c5e2e8740026e39403b74fa17b6fdff7f817e882f782c04c467a162a29

The omitted getUpdates call is accepted as a documented exception because the authorized procedure explicitly forbade disturbing the living Telegram consumer. This is not a candidate failure and does not reopen the shadow lane.

The hosted AEON Minisforum validation lane is closed. No live deployment, merge, promotion, or ref movement is authorized by this closure.

Authorized next operation: one Goal-mode final audit and current-upstream rebase preparation in isolated worktrees only. It may inspect current upstream main, PR NousResearch#74397, and our candidate; construct and test a rebased candidate locally; preserve provenance; and produce an evidence report. No push, force-push, merge, Ready for Review, staging/stable ref movement, service restart, or living runtime mutation.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M6 review — local rebase used stale PR base; fresh-main rebase required

REPORTED_MAIN := a4973c3f11d9cc92da986cbe150d1e79d094626f
PR_BASE_SHA := a4973c3f11d9cc92da986cbe150d1e79d094626f
LATEST_OBSERVED_UPSTREAM_MAIN := 43717123ca1566a073270c5a61431e2e0e4a0211
DELTA := 1410 commits ahead
REPORTED_REBASE := e7881cf99ce1735249de6910c324abb8548876ac
STATUS := NOT_PUSHABLE

The reported main is exactly the stale base recorded on upstream PR NousResearch#74397, not the current NousResearch/hermes-agent:main. The clean rebase and 126 targeted passes remain useful evidence, but they do not validate the patch against current upstream.

Authorized next operation: M6R-FRESH-MAIN-REBASE, GPT-5.6 Luna medium, no subagent, isolated worktrees only.

Required gate:

  1. Run git ls-remote <upstream> refs/heads/main immediately before the rebase and record the exact SHA and UTC timestamp.
  2. Fetch that exact SHA and prove the local upstream/main resolves to it.
  3. Rebase PR head c55ce708ed2889ca3e9ec4529f6da9b1fd48b609 onto that frozen SHA, not onto the PR base.
  4. Preserve session identity/history, CWD restoration, post-success TERMINAL_CWD, unavailable-workspace fail-closed, workspace-first --continue, and create-on-first-use semantics.
  5. Run the 126 targeted tests, compile, Ruff, git diff --check, plus any directly affected current-main tests.
  6. Report conflicts, exact rebased SHA, changed files, clean-tree proof, and whether the frozen upstream SHA is still current at report time.
  7. No push, force-push, merge, deployment, or runtime mutation.

If upstream advances after the frozen SHA, report the new head separately; do not restart repeatedly unless a relevant file changed.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M6R semantic conflict resolution — preserve current main test topology, transplant only resume invariants

Decision for conflict in tests/hermes_cli/test_tui_resume_flow.py:

  • Keep the frozen upstream-main version of this file as the conflict base (ours).
  • Do not restore the old large test suite from the PR branch.
  • Create a dedicated test module, e.g. tests/hermes_cli/test_oneshot_resume_flow.py, containing only the PR-specific invariants that are absent from current main:
    1. _run_and_exit_oneshot forwards resume_session_id, continue_last, and restore_resume_cwd.
    2. top-level/Termux one-shot forwarding carries the default resume fields.
    3. _run_agent reuses the resolved durable tip, filters session_meta, reopens the same session, and passes prior history.
    4. bare --continue prefers the current workspace.
    5. bare --continue falls back to global CLI MRU only when the workspace has no session.
  • Keep test_oneshot_resume_cwd.py and test_oneshot_terminal_cwd.py unchanged except for genuine rebase adaptations; do not duplicate their CWD/TERMINAL_CWD cases.
  • Continue the rebase, then run the dedicated resume files, current test_tui_resume_flow.py, the prior 126 focused tests, compile, Ruff, and git diff --check.

Reason: current upstream main intentionally has a much smaller test_tui_resume_flow.py; the PR patch targets tests that no longer exist there. Whole-file theirs would resurrect deleted upstream coverage and regress the current test topology. Whole-file ours without transplant would lose new resume coverage.

No push or runtime mutation is authorized.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M6R closure — fresh-main candidate accepted; controlled upstream push authorized

FROZEN_MAIN := 43717123ca1566a073270c5a61431e2e0e4a0211
CURRENT_MAIN := fdc342c082c837847ca8de4a77d489f36a4af354
MAIN_DELTA := 1 commit · no affected patch files
ORIGINAL_UPSTREAM_PR_HEAD := c55ce708ed2889ca3e9ec4529f6da9b1fd48b609
FINAL_REBASED_CANDIDATE := 5931f54131ce336a3024bd2b5f844b1162cda30c
TARGET_BRANCH := agent/fix-oneshot-resume

The reduced current-main test topology is authoritative. The historical 126-test count is not a required gate because those tests no longer exist in that topology and were intentionally not restored. Accepted evidence: 6 dedicated resume tests, 31 current resume/session/CWD tests, compile PASS, Ruff PASS, diff-check PASS, clean worktree.

Authorized operation: verify the remote branch still equals the exact old head above, then push only the final candidate to SE87H/hermes-agent:agent/fix-oneshot-resume using an exact --force-with-lease expectation. If the lease fails, stop; do not broaden or force unconditionally.

After push, add one concise comment to upstream PR NousResearch#74397 recording the frozen/current main SHAs, semantic conflict resolution, final head, and current test results. Do not mark ready, merge, deploy, or mutate any runtime. Stop after reporting the pushed SHA and initial CI run identifiers.

SE87H pushed a commit that referenced this pull request Aug 4, 2026
…own (NousResearch#74136)

Fix-up for the cherry-picked cooldown persistence: the PR's tests mocked
the DB (SimpleNamespace(_db=MagicMock())), which cannot prove the cooldown
survives a restart. Replace with the production shape — a real SessionDB
on disk behind the real AsyncSessionDB facade — and add a restart
regression: fail a hygiene compression on runner #1, tear it down, build a
fresh GatewayRunner on the SAME database, and assert the cooldown is still
honored (no compression agent instantiated). Also updates the timeout test
to assert the DB-backed record_compression_failure_cooldown write instead
of the removed in-memory dict.

Sabotage-verified: reverting gateway/run.py to the in-memory dict makes
the restart test fail.
SE87H pushed a commit that referenced this pull request Aug 4, 2026
Users following abbreviated links guess /docs/quickstart and
/docs/installation and hit raw GitHub-Pages 404s — the real pages live
under /docs/getting-started/. Add client redirects for both.

Consumer-onboarding audit finding #1, Aug 2026.
SE87H pushed a commit that referenced this pull request Aug 4, 2026
The #1 patch failure class in production (state.db mining, 250k-window)
is a re-send of an edit that already landed: 'old_string and new_string
are identical' (299 occurrences) plus a share of hunk-not-found errors
where the new text is already in the file. These errored, sending
models into re-read/re-patch loops.

New tools/fuzzy_match.is_already_applied(content, old, new) — a
conservative check requiring (1) non-trivial new_string (>=8 chars),
(2) EXACT presence of new_string, (3) old_string gone (unless
identical). Wired into three sites:

- patch_replace (replace mode): returns success + no_change: true +
  an explicit note instead of the identical-strings / no-match error.
- V4A validation phase: an already-applied hunk validates as a no-op
  so multi-hunk patches no longer fail wholesale when one hunk landed
  in a prior call.
- V4A apply phase: mirrors the same skip so the two phases agree.

Genuine no-matches (new text absent) and half-applied renames (old
text still present) keep their error behavior — covered by tests.
SE87H pushed a commit that referenced this pull request Aug 4, 2026
process(action='wait') hitting its window returned status='timeout'
with a terse note — models read it as an error and re-issued identical
waits (process is the #1 exact-duplicate tool call in production: 511
dupes in a 400k-msg window; wait is 57% of all process actions).

The timeout result now carries:
- process_running: true — machine-readable 'this is a status, not a
  failure'
- an explicit note: 'Wait window of Ns elapsed — the process is still
  running. This is not an error. Uptime: Ms.' plus the right next step:
  when notify_on_complete is set, 'you will be notified on exit — do
  more work instead of waiting again'; otherwise a pointer to
  notify_on_complete for next time.
- the clamp note (requested > max) now composes with the status note
  instead of replacing it.

Exited/interrupted results are unchanged.
SE87H pushed a commit that referenced this pull request Aug 4, 2026
…e-review #1)

revoke_commit_admission() used to invoke the holder-qualified lease
release unconditionally — including while an admitted commit was still
mutating SessionDB — letting a second compressor acquire the durable
lock mid-commit and interleave with the first commit's writes.

The admission_revoked flag store stays lock-free, but the lease-release
decision now coordinates with the fence lock:
- revoke acquires the fence lock non-blocking; on success no commit can
  be in flight (an admitted commit retains the lock until finish_commit)
  and the release runs immediately, still under the lock so a racing
  begin_commit cannot slip between the check and the release.
- on failure the release is deferred: finish_commit() re-checks
  _admission_revoked and performs it AFTER the commit completes (prompt
  even if the worker thread is later parked), and the begin_commit
  refusal path does the same for a revoke that lost the race to a
  transient lock-setup/cancel boundary. All paths are idempotent with
  the worker's own outer cleanup (DB release is holder-qualified).

Invariant encoded + tested: no second compressor can acquire the durable
lock while an admitted commit is still mutating; after a post-revoke
commit finishes the lease is released promptly. Both regressions
(revoke-during-commit deferral, revoke-before-commit immediate release +
refused begin_commit) are sabotage-verified.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M6R upstream CI gate — awaiting maintainer approval, not a code failure

UPSTREAM_PR := NousResearch/hermes-agent#74397
HEAD_SHA := 5931f54131ce336a3024bd2b5f844b1162cda30c
WORKFLOW_RUN := 30951534350
STATUS := completed
CONCLUSION := action_required
JOBS_CREATED := 0

Interpretation: the workflow did not execute any job. The run is awaiting approval required for a pull request workflow originating from an external fork. This is an upstream repository governance boundary, not a test or code failure.

No rerun, code change, rebase, push, or CI repair is authorized. The next valid event is maintainer approval of the workflow in NousResearch/hermes-agent. After approval, inspect the newly executed jobs and logs before any further action.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

Operator/runtime type split + frozen live-update policy

Canonical topology

RuntimeEntity    := ava | aeon
OperatorIdentity := avaeon-codex
HostIdentity     := avaorus | minisforum
InstanceIdentity := live | shadow-* | test-*

operator_id   := avaeon-codex
target_entity := ava | aeon
host_id       := avaorus | minisforum
instance_id   := live | shadow-* | test-*
AVA_ENTITY    := target_entity

avaeon-codex is a portable deployment/audit operator, not a third Hermes runtime entity. It must not be counted in runtime fleet completeness, promotion quorum, doctor/smoke/snapshot obligations, gateway/Telegram/service inventory, or permanent state-root requirements.

AVAEON may retain operator metadata, isolated worktrees, harnesses, manifests, reports, and disposable shadow roots. It must never reuse a live AVA/AEON state root or present an operator instance as AVA_ENTITY.

Required control-plane repair

Refactor the PR so that:

  • runtime entity schemas/enums accept only ava | aeon;
  • operator schemas/enums accept avaeon-codex separately;
  • fleet validation distinguishes deployed runtimes from operators;
  • promotion gates require only the runtime entities actually in scope;
  • an AEON-only promotion is typed AEON_HOST_PROMOTION, never fleet-wide closure;
  • AVA/AVAORUS remains explicitly deferred/unvalidated while the host is unavailable;
  • all existing cross-root/collision and provenance protections remain enforced between operator, target, host, and instance.

Live Hermes update policy

The living AEON Hermes runtime on the Minisforum is frozen at its exact current working revision until an explicit controlled promotion.

auto_update      := false
hermes update    := forbidden
moving branch    := forbidden as live source
self-update      := forbidden
silent update    := forbidden

Do not assume the live revision equals the validated shadow candidate. Inventory and record the exact live SHA before any future promotion.

All future Hermes updates must use this pipeline:

upstream fetch
→ isolated pinned candidate
→ semantic diff/audit
→ focused + repository-compatible tests
→ disposable shadow with copied/minimal credentials
→ state snapshot + rollback target
→ explicit SE7H/ChatGPT authorization
→ controlled live promotion
→ health/session/gateway verification
→ rollback on failed closure

Upstream changes are intake material, never authority to mutate the live vessel automatically.

Authority separation

  • AVAEON Codex executes, audits, snapshots, promotes, and rolls back.
  • AEON Core may provide read-only diagnostics, application-level smoke results, and product-behavior observations.
  • AEON Core must not mutate, approve, deploy, or solely validate its own runtime path.
  • ChatGPT/SE7H remains the promotion gate.

Execution authorization

Use GPT-5.6 Luna medium, Goal mode, no sub-agent. Modify only PR #1 code/tests/docs and isolated worktrees. Run the relevant control-plane and schema tests. A normal fast-forward push to agent/ava-hermes-foundation is authorized only if all affected tests pass and the branch has not changed remotely; otherwise stop with the exact divergence.

No live runtime change, no service restart, no hermes update, no staging/stable movement, no AEON Unchained work, and no AVAORUS operation.

Return one consolidated report:

M7-OPERATOR-RUNTIME-SPLIT-AND-UPDATE-POLICY

Include modified files, tests, resulting SHA, proof that AVAEON is no longer a runtime entity, proof that auto_update/live self-update remain fail-closed, and any residual migration issue.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M7 postflight — structure accepted; three closure repairs required

dcc9538145a4d58438bbc7137a859009166fba9b correctly separates runtime entities (ava|aeon) from operator identity (avaeon-codex) and keeps the live runtime untouched. The fast-forward and 77 AVA-runtime tests are accepted.

Before M7 is fully closed, apply only these repairs:

  1. Stop and prove cleanup of the two residual background terminals. Inspect them first; if they are test/worktree processes rather than live AEON services, terminate them and report zero residual process/socket/port.
  2. In docs/ava-runtime/PHASE2_CONTROL_PLANE.md, remove the duplicated smoke aeon command left by deleting the former AVAEON runtime example.
  3. Update PR feat(ava): establish controlled Hermes runtime foundation #1 body, which still describes AVAEON Codex as a third runtime, requires three-entity promotion evidence, and lists obsolete remaining gates/test counts. Rewrite it to the current two-runtime/operator topology and current evidence.

Accuracy correction for update policy:

  • the managed fleet control plane already rejects auto_update=true and non-40-character moving refs;
  • update_policy.py expresses and tests the ban on hermes update, but it does not globally intercept an arbitrary direct invocation of the upstream live CLI outside the managed control plane.

Therefore document the exact boundary as: hermes update is forbidden operationally and rejected by managed paths; the upstream binary must not be invoked directly for updates. Do not claim a host-wide technical interception unless one is actually installed and tested.

The residual external-fleet migration remains deferred: inventory it read-only before any future promotion, but do not touch live AEON configuration now.

No runtime restart, promotion, Unchained work, AVAORUS work, or broad Hermes CLI test run is authorized. Push one fast-forward cleanup commit only after the focused checks pass, then STOP.

SE87H commented Aug 4, 2026

Copy link
Copy Markdown
Owner Author

M7 final closure — operator/runtime split and frozen update policy sealed

FINAL_HEAD := 06b98566ae85d36a479003a9b6da344963c48207
RUNTIME_ENTITIES := ava | aeon
OPERATOR_ID := avaeon-codex
RESULT := PASS

Postflight confirmed:

  • the final commit contains only the intended policy wording correction and duplicate documentation cleanup;
  • the PR body now models AVAEON Codex exclusively as the portable operator, never a runtime or fleet member;
  • the managed control plane rejects auto_update: true and moving live references;
  • direct upstream hermes update remains operationally forbidden but is not falsely claimed to be globally intercepted;
  • residual pytest groups were stopped without touching AEON live services;
  • 77 AVA-runtime tests, compile, Ruff and git diff --check passed;
  • no live runtime, service, state, staging/stable ref or promotion was modified.

Deferred boundaries remain explicit: read-only inventory and migration of external fleet configurations before any promotion; AEON Unchained later; AVAORUS validation when the host becomes reachable.

M7 is closed. AVAEON Codex should remain stopped until a new authorized goal exists.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Projects

None yet

Development

Successfully merging this pull request may close these issues.

1 participant